genksyms: track symbol checksum changes

Sometimes it is preferable to avoid changes of exported symbol checksums
(to avoid breaking externally provided modules).  When a checksum change
occurs, it can be hard to figure out what caused this change: underlying
types may have changed, or additional type information may simply have
become available at the point where a symbol is exported.

Add a new --reference option to genksyms which allows it to report why
checksums change, based on the type information dumps it creates with the
--dump-types flag.  Genksyms will read in such a dump from a previous run,
and report which symbols have changed (and why).

The behavior can be controlled for an entire build as follows: If
KBUILD_SYMTYPES is set, genksyms uses --dump-types to produce *.symtypes
dump files.  If any *.symref files exist, those will be used as the
reference to check against.  If KBUILD_PRESERVE is set, checksum changes
will fail the build.

Signed-off-by: Andreas Gruenbacher <agruen@suse.de>
Cc: Randy Dunlap <randy.dunlap@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>

3 files changed, 239 insertions, 19 deletions

diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 468fbc9016c7..d21f0eac2e52 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -153,12 +153,18 @@ $(obj)/%.i: $(src)/%.c FORCE
 
 quiet_cmd_cc_symtypes_c = SYM $(quiet_modtag) $@
 cmd_cc_symtypes_c          = \
+                set -e;                                                 \
                 $(CPP) -D__GENKSYMS__ $(c_flags) $<                     \
-                | $(GENKSYMS) -T $@ >/dev/null;                         \
+                | $(GENKSYMS) -T $@                                     \
+                              -r $(firstword $(wildcard                 \
+                                     $(@:.symtypes=.symref) /dev/null)) \
+                              $(if $(KBUILD_PRESERVE),-p)               \
+                              -a $(ARCH)                                \
+                  >/dev/null;                                           \
                 test -s $@ || rm -f $@
 
 $(obj)/%.symtypes : $(src)/%.c FORCE
-        $(call if_changed_dep,cc_symtypes_c)
+        $(call cmd,cc_symtypes_c)
 
 # C (.c) files
 # The C file is compiled and updated dependency information is generated.
@@ -187,7 +193,11 @@ cmd_modversions =							\
         if $(OBJDUMP) -h $(@D)/.tmp_$(@F) | grep -q __ksymtab; then     \
                 $(CPP) -D__GENKSYMS__ $(c_flags) $<                     \
                 | $(GENKSYMS) $(if $(KBUILD_SYMTYPES),                  \
-                              -T $(@D)/$(@F:.o=.symtypes)) -a $(ARCH)   \
+                                   -T $(@:.o=.symtypes))                \
+                              -r $(firstword $(wildcard                 \
+                                     $(@:.o=.symref) /dev/null))        \
+                              $(if $(KBUILD_PRESERVE),-p)               \
+                              -a $(ARCH)                                \
                 > $(@D)/.tmp_$(@F:.o=.ver);                             \
                                                                         \
                 $(LD) $(LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F)              \
diff --git a/scripts/genksyms/genksyms.c b/scripts/genksyms/genksyms.c
index c249274e005a..ddac1746908e 100644
--- a/scripts/genksyms/genksyms.c
+++ b/scripts/genksyms/genksyms.c
@@ -42,7 +42,8 @@ static FILE *debugfile;
 int cur_line = 1;
 char *cur_filename;
 
-static int flag_debug, flag_dump_defs, flag_dump_types, flag_warnings;
+static int flag_debug, flag_dump_defs, flag_reference, flag_dump_types,
+           flag_preserve, flag_warnings;
 static const char *arch = "";
 static const char *mod_prefix = "";
 
@@ -58,6 +59,8 @@ static const char *const symbol_type_name[] = {
 
 static int equal_list(struct string_list *a, struct string_list *b);
 static void print_list(FILE * f, struct string_list *list);
+static void print_location(void);
+static void print_type_name(enum symbol_type type, const char *name);
 
 /*----------------------------------------------------------------------*/
 
@@ -151,27 +154,68 @@ struct symbol *find_symbol(const char *name, enum symbol_type ns)
 
         for (sym = symtab[h]; sym; sym = sym->hash_next)
                 if (map_to_ns(sym->type) == map_to_ns(ns) &&
-                    strcmp(name, sym->name) == 0)
+                    strcmp(name, sym->name) == 0 &&
+                    sym->is_declared)
                         break;
 
         return sym;
 }
 
-struct symbol *add_symbol(const char *name, enum symbol_type type,
-                          struct string_list *defn, int is_extern)
+static int is_unknown_symbol(struct symbol *sym)
+{
+        struct string_list *defn;
+
+        return ((sym->type == SYM_STRUCT ||
+                 sym->type == SYM_UNION ||
+                 sym->type == SYM_ENUM) &&
+                (defn = sym->defn)  && defn->tag == SYM_NORMAL &&
+                        strcmp(defn->string, "}") == 0 &&
+                (defn = defn->next) && defn->tag == SYM_NORMAL &&
+                        strcmp(defn->string, "UNKNOWN") == 0 &&
+                (defn = defn->next) && defn->tag == SYM_NORMAL &&
+                        strcmp(defn->string, "{") == 0);
+}
+
+struct symbol *__add_symbol(const char *name, enum symbol_type type,
+                            struct string_list *defn, int is_extern,
+                            int is_reference)
 {
         unsigned long h = crc32(name) % HASH_BUCKETS;
         struct symbol *sym;
+        enum symbol_status status = STATUS_UNCHANGED;
 
         for (sym = symtab[h]; sym; sym = sym->hash_next) {
-                if (map_to_ns(sym->type) == map_to_ns(type)
-                    && strcmp(name, sym->name) == 0) {
-                        if (!equal_list(sym->defn, defn))
+                if (map_to_ns(sym->type) == map_to_ns(type) &&
+                    strcmp(name, sym->name) == 0) {
+                        if (is_reference)
+                                /* fall through */ ;
+                        else if (sym->type == type &&
+                                 equal_list(sym->defn, defn)) {
+                                sym->is_declared = 1;
+                                return sym;
+                        } else if (!sym->is_declared) {
+                                status = is_unknown_symbol(sym) ?
+                                        STATUS_DEFINED : STATUS_MODIFIED;
+                        } else {
                                 error_with_pos("redefinition of %s", name);
-                        return sym;
+                                return sym;
+                        }
+                        break;
                 }
         }
 
+        if (sym) {
+                struct symbol **psym;
+
+                for (psym = &symtab[h]; *psym; psym = &(*psym)->hash_next) {
+                        if (*psym == sym) {
+                                *psym = sym->hash_next;
+                                break;
+                        }
+                }
+                --nsyms;
+        }
+
         sym = xmalloc(sizeof(*sym));
         sym->name = name;
         sym->type = type;
@@ -183,6 +227,9 @@ struct symbol *add_symbol(const char *name, enum symbol_type type,
         sym->hash_next = symtab[h];
         symtab[h] = sym;
 
+        sym->is_declared = !is_reference;
+        sym->status = status;
+
         if (flag_debug) {
                 fprintf(debugfile, "Defn for %s %s == <",
                         symbol_type_name[type], name);
@@ -196,6 +243,18 @@ struct symbol *add_symbol(const char *name, enum symbol_type type,
         return sym;
 }
 
+struct symbol *add_symbol(const char *name, enum symbol_type type,
+                          struct string_list *defn, int is_extern)
+{
+        return __add_symbol(name, type, defn, is_extern, 0);
+}
+
+struct symbol *add_reference_symbol(const char *name, enum symbol_type type,
+                                    struct string_list *defn, int is_extern)
+{
+        return __add_symbol(name, type, defn, is_extern, 1);
+}
+