Linux Kernel Markers: create modpost file

This adds some new magic in the MODPOST phase for CONFIG_MARKERS.  Analogous
to the Module.symvers file, the build will now write a Module.markers file
when CONFIG_MARKERS=y is set.  This file lists the name, defining module, and
format string of each marker, separated by \t characters.  This simple text
file can be used by offline build procedures for instrumentation code,
analogous to how System.map and Module.symvers can be useful to have for
kernels other than the one you are running right now.

The strings are made easy to extract by having the __trace_mark macro define
the name and format together in a single array called __mstrtab_* in the
__markers_strings section.  This is straightforward and reliable as long as
the marker structs are always defined by this macro.  It is an unreasonable
amount of hairy work to extract the string pointers from the __markers section
structs, which entails handling a relocation type for every machine under the
sun.

Mathieu :
- Ran through checkpatch.pl

Signed-off-by: Roland McGrath <roland@redhat.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Cc: David Smith <dsmith@redhat.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 163 insertions, 1 deletions

diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
index dbe1fb5e8cc0..61742771c65d 100644
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -11,6 +11,8 @@
  * Usage: modpost vmlinux module1.o module2.o ...
  */
 
+#define _GNU_SOURCE
+#include <stdio.h>
 #include <ctype.h>
 #include "modpost.h"
 #include "../../include/linux/license.h"
@@ -435,6 +437,8 @@ static int parse_elf(struct elf_info *info, const char *filename)
                         info->export_unused_gpl_sec = i;
                 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
                         info->export_gpl_future_sec = i;
+                else if (strcmp(secname, "__markers_strings") == 0)
+                        info->markers_strings_sec = i;
 
                 if (sechdrs[i].sh_type != SHT_SYMTAB)
                         continue;
@@ -1470,6 +1474,62 @@ static void check_sec_ref(struct module *mod, const char *modname,
         }
 }
 
+static void get_markers(struct elf_info *info, struct module *mod)
+{
+        const Elf_Shdr *sh = &info->sechdrs[info->markers_strings_sec];
+        const char *strings = (const char *) info->hdr + sh->sh_offset;
+        const Elf_Sym *sym, *first_sym, *last_sym;
+        size_t n;
+
+        if (!info->markers_strings_sec)
+                return;
+
+        /*
+         * First count the strings.  We look for all the symbols defined
+         * in the __markers_strings section named __mstrtab_*.  For
+         * these local names, the compiler puts a random .NNN suffix on,
+         * so the names don't correspond exactly.
+         */
+        first_sym = last_sym = NULL;
+        n = 0;
+        for (sym = info->symtab_start; sym < info->symtab_stop; sym++)
+                if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT &&
+                    sym->st_shndx == info->markers_strings_sec &&
+                    !strncmp(info->strtab + sym->st_name,
+                             "__mstrtab_", sizeof "__mstrtab_" - 1)) {
+                        if (first_sym == NULL)
+                                first_sym = sym;
+                        last_sym = sym;
+                        ++n;
+                }
+
+        if (n == 0)
+                return;
+
+        /*
+         * Now collect each name and format into a line for the output.
+         * Lines look like:
+         *      marker_name     vmlinux marker %s format %d
+         * The format string after the second \t can use whitespace.
+         */
+        mod->markers = NOFAIL(malloc(sizeof mod->markers[0] * n));
+        mod->nmarkers = n;
+
+        n = 0;
+        for (sym = first_sym; sym <= last_sym; sym++)
+                if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT &&
+                    sym->st_shndx == info->markers_strings_sec &&
+                    !strncmp(info->strtab + sym->st_name,
+                             "__mstrtab_", sizeof "__mstrtab_" - 1)) {
+                        const char *name = strings + sym->st_value;
+                        const char *fmt = strchr(name, '\0') + 1;
+                        char *line = NULL;
+                        asprintf(&line, "%s\t%s\t%s\n", name, mod->name, fmt);
+                        NOFAIL(line);
+                        mod->markers[n++] = line;
+                }
+}
+
 static void read_symbols(char *modname)
 {
         const char *symname;
@@ -1521,6 +1581,8 @@ static void read_symbols(char *modname)
                 get_src_version(modname, mod->srcversion,
                                 sizeof(mod->srcversion)-1);
 
+        get_markers(&info, mod);
+
         parse_elf_finish(&info);
 
         /* Our trick to get versioning for struct_module - it's
@@ -1867,16 +1929,104 @@ static void write_dump(const char *fname)
         write_if_changed(&buf, fname);
 }
 
+static void add_marker(struct module *mod, const char *name, const char *fmt)
+{
+        char *line = NULL;
+        asprintf(&line, "%s\t%s\t%s\n", name, mod->name, fmt);
+        NOFAIL(line);
+
+        mod->markers = NOFAIL(realloc(mod->markers, ((mod->nmarkers + 1) *
+                                                     sizeof mod->markers[0])));
+        mod->markers[mod->nmarkers++] = line;
+}
+
+static void read_markers(const char *fname)
+{
+        unsigned long size, pos = 0;
+        void *file = grab_file(fname, &size);
+        char *line;
+
+        if (!file)              /* No old markers, silently ignore */
+                return;
+
+        while ((line = get_next_line(&pos, file, size))) {
+                char *marker, *modname, *fmt;
+                struct module *mod;
+
+                marker = line;
+                modname = strchr(marker, '\t');
+                if (!modname)
+                        goto fail;
+                *modname++ = '\0';
+                fmt = strchr(modname, '\t');
+                if (!fmt)
+                        goto fail;
+                *fmt++ = '\0';
+                if (*marker == '\0' || *modname == '\0')
+                        goto fail;
+
+                mod = find_module(modname);
+                if (!mod) {
+                        if (is_vmlinux(modname))
+                                have_vmlinux = 1;
+                        mod = new_module(NOFAIL(strdup(modname)));
+                        mod->skip = 1;
+                }
+
+                add_marker(mod, marker, fmt);
+        }
+        return;
+fail:
+        fatal("parse error in markers list file\n");
+}
+
+static int compare_strings(const void *a, const void *b)
+{
+        return strcmp(*(const char **) a, *(const char **) b);
+}
+
+static void write_markers(const char *fname)
+{
+        struct buffer buf = { };
+        struct module *mod;
+        size_t i;
+
+        for (mod = modules; mod; mod = mod->next)
+                if ((!external_module || !mod->skip) && mod->markers != NULL) {
+                        /*
+                         * Sort the strings so we can skip duplicates when
+                         * we write them out.
+                         */
+                        qsort(mod->markers, mod->nmarkers,
+                              sizeof mod->markers[0], &compare_strings);
+                        for (i = 0; i < mod->nmarkers; ++i) {
+                                char *line = mod->markers[i];
+                                buf_write(&buf, line, strlen(line));
+                                while (i + 1 < mod->nmarkers &&
+                                       !strcmp(mod->markers[i],
+                                               mod->markers[i + 1]))
+                                        free(mod->markers[i++]);
+                                free(mod->markers[i]);
+                        }
+                        free(mod->markers);
+                        mod->markers = NULL;
+                }
+
+        write_if_changed(&buf, fname);
+}
+
 int main(int argc, char **argv)
 {
         struct module *mod;
         struct buffer buf = { };
         char *kernel_read = NULL, *module_read = NULL;
         char *dump_write = NULL;
+        char *markers_read = NULL;
+        char *markers_write = NULL;
         int opt;
         int err;
 
-        while ((opt = getopt(argc, argv, "i:I:msSo:aw")) != -1) {
+        while ((opt = getopt(argc, argv, "i:I:msSo:awM:K:")) != -1) {
                 switch (opt) {
                 case 'i':
                         kernel_read = optarg;
@@ -1903,6 +2053,12 @@ int main(int argc, char **argv)
                 case 'w':
                         warn_unresolved = 1;
                         break;
+                        case 'M':
+                                markers_write = optarg;
+                                break;
+                        case 'K':
+                                markers_read = optarg;
+                                break;
                 default:
                         exit(1);
                 }
@@ -1950,5 +2106,11 @@ int main(int argc, char **argv)
                      "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
                      sec_mismatch_count);
 
+        if (markers_read)
+                read_markers(markers_read);
+
+        if (markers_write)
+                write_markers(markers_write);
+
         return err;
 }