From: Mika Kukkonen CHECK kernel/kallsyms.c kernel/kallsyms.c:136:7: warning: bad constant expression kernel/kallsyms.c:136:7: warning: bad constant expression kernel/kallsyms.c:136:7: warning: bad constant expression kernel/kallsyms.c:143:22: warning: bad constant expression kernel/kallsyms.c:143:22: warning: bad constant expression kernel/kallsyms.c:143:22: warning: bad constant expression Now the cause of sparse warnings is that it does not handle runtime array dimensioning (which I take it is a sparse problem), but in this particular case it _might_ make sense to change the runtime allocation to compile time, as the upper size of the array is known, because the code in kernel/kallsyms.c clearly uses 127 (or 128) as "magic constant" for kernel symbol (array) length, and in the other hand in include/linux/module.h there is: #define MODULE_NAME_LEN (64 - sizeof(unsigned long)) The only concern is that the array become quite big (the original comment of it being "pretty small" no longer applies ...). One way to help that would be to use buffer[] also in place of namebuf[], but that would be little tricky as the format string should be before the symbol name ... Signed-off-by: Andrew Morton --- 25-akpm/include/linux/kallsyms.h | 2 + 25-akpm/kernel/kallsyms.c | 49 +++++++++++++++------------------------ 2 files changed, 21 insertions(+), 30 deletions(-) diff -puN include/linux/kallsyms.h~define-max-kernel-symbol-lenght-and-clean-up include/linux/kallsyms.h --- 25/include/linux/kallsyms.h~define-max-kernel-symbol-lenght-and-clean-up 2004-06-29 22:13:01.080358000 -0700 +++ 25-akpm/include/linux/kallsyms.h 2004-06-29 22:13:01.085357240 -0700 @@ -7,6 +7,8 @@ #include +#define KSYM_NAME_LEN 127 + #ifdef CONFIG_KALLSYMS /* Lookup the address for a symbol. Returns 0 if not found. */ unsigned long kallsyms_lookup_name(const char *name); diff -puN kernel/kallsyms.c~define-max-kernel-symbol-lenght-and-clean-up kernel/kallsyms.c --- 25/kernel/kallsyms.c~define-max-kernel-symbol-lenght-and-clean-up 2004-06-29 22:13:01.082357696 -0700 +++ 25-akpm/kernel/kallsyms.c 2004-06-29 22:13:01.086357088 -0700 @@ -40,14 +40,14 @@ static inline int is_kernel_text(unsigne /* Lookup the address for this symbol. Returns 0 if not found. */ unsigned long kallsyms_lookup_name(const char *name) { - char namebuf[128]; + char namebuf[KSYM_NAME_LEN+1]; unsigned long i; char *knames; for (i = 0, knames = kallsyms_names; i < kallsyms_num_syms; i++) { unsigned prefix = *knames++; - strlcpy(namebuf + prefix, knames, 127 - prefix); + strlcpy(namebuf + prefix, knames, KSYM_NAME_LEN - prefix); if (strcmp(namebuf, name) == 0) return kallsyms_addresses[i]; @@ -67,7 +67,7 @@ const char *kallsyms_lookup(unsigned lon /* This kernel should never had been booted. */ BUG_ON(!kallsyms_addresses); - namebuf[127] = 0; + namebuf[KSYM_NAME_LEN] = 0; namebuf[0] = 0; if (is_kernel_text(addr) || is_kernel_inittext(addr)) { @@ -84,7 +84,7 @@ const char *kallsyms_lookup(unsigned lon /* Grab name */ for (i = 0; i <= best; i++) { unsigned prefix = *name++; - strncpy(namebuf + prefix, name, 127 - prefix); + strncpy(namebuf + prefix, name, KSYM_NAME_LEN - prefix); name += strlen(name) + 1; } @@ -117,34 +117,22 @@ void __print_symbol(const char *fmt, uns char *modname; const char *name; unsigned long offset, size; - char namebuf[128]; + char namebuf[KSYM_NAME_LEN+1]; + char buffer[sizeof("%s+%#lx/%#lx [%s]") + KSYM_NAME_LEN + + 2*(BITS_PER_LONG*3/10) + MODULE_NAME_LEN + 1]; name = kallsyms_lookup(address, &size, &offset, &modname, namebuf); - if (!name) { - char addrstr[sizeof("0x%lx") + (BITS_PER_LONG*3/10)]; - - sprintf(addrstr, "0x%lx", address); - printk(fmt, addrstr); - return; - } - - if (modname) { - /* This is pretty small. */ - char buffer[sizeof("%s+%#lx/%#lx [%s]") - + strlen(name) + 2*(BITS_PER_LONG*3/10) - + strlen(modname)]; - - sprintf(buffer, "%s+%#lx/%#lx [%s]", - name, offset, size, modname); - printk(fmt, buffer); - } else { - char buffer[sizeof("%s+%#lx/%#lx") - + strlen(name) + 2*(BITS_PER_LONG*3/10)]; - - sprintf(buffer, "%s+%#lx/%#lx", name, offset, size); - printk(fmt, buffer); + if (!name) + sprintf(buffer, "0x%lx", address); + else { + if (modname) + sprintf(buffer, "%s+%#lx/%#lx [%s]", name, offset, + size, modname); + else + sprintf(buffer, "%s+%#lx/%#lx", name, offset, size); } + printk(fmt, buffer); } /* To avoid O(n^2) iteration, we carry prefix along. */ @@ -155,7 +143,7 @@ struct kallsym_iter unsigned long value; unsigned int nameoff; /* If iterating in core kernel symbols */ char type; - char name[128]; + char name[KSYM_NAME_LEN+1]; }; /* Only label it "global" if it is exported. */ @@ -186,7 +174,8 @@ static unsigned long get_ksymbol_core(st shared with previous name (stem compression). */ stemlen = kallsyms_names[off++]; - strlcpy(iter->name+stemlen, kallsyms_names + off, 128-stemlen); + strlcpy(iter->name+stemlen, kallsyms_names + off, + KSYM_NAME_LEN+1-stemlen); off += strlen(kallsyms_names + off) + 1; iter->owner = NULL; iter->value = kallsyms_addresses[iter->pos]; _