x86, vdso: Get rid of the fake section mechanism

Now that we can tolerate extra things dangling off the end of the
vdso image, we can strip the vdso the old fashioned way rather than
using an overcomplicated custom stripping algorithm.

This is a partial reversion of:
    6f121e5 x86, vdso: Reimplement vdso.so preparation in build-time C

Signed-off-by: Andy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/50e01ed6dcc0575d20afd782f9fe98d5ee3e2d8a.1405040914.git.luto@amacapital.net
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>

1 files changed, 91 insertions, 25 deletions

diff --git a/arch/x86/vdso/vdso2c.c b/arch/x86/vdso/vdso2c.c
index 22c54d04bced..8627db24a7f6 100644
--- a/arch/x86/vdso/vdso2c.c
+++ b/arch/x86/vdso/vdso2c.c
@@ -1,3 +1,53 @@
+/*
+ * vdso2c - A vdso image preparation tool
+ * Copyright (c) 2014 Andy Lutomirski and others
+ * Licensed under the GPL v2
+ *
+ * vdso2c requires stripped and unstripped input.  It would be trivial
+ * to fully strip the input in here, but, for reasons described below,
+ * we need to write a section table.  Doing this is more or less
+ * equivalent to dropping all non-allocatable sections, but it's
+ * easier to let objcopy handle that instead of doing it ourselves.
+ * If we ever need to do something fancier than what objcopy provides,
+ * it would be straightforward to add here.
+ *
+ * We're keep a section table for a few reasons:
+ *
+ * The Go runtime had a couple of bugs: it would read the section
+ * table to try to figure out how many dynamic symbols there were (it
+ * shouldn't have looked at the section table at all) and, if there
+ * were no SHT_SYNDYM section table entry, it would use an
+ * uninitialized value for the number of symbols.  An empty DYNSYM
+ * table would work, but I see no reason not to write a valid one (and
+ * keep full performance for old Go programs).  This hack is only
+ * needed on x86_64.
+ *
+ * The bug was introduced on 2012-08-31 by:
+ * https://code.google.com/p/go/source/detail?r=56ea40aac72b
+ * and was fixed on 2014-06-13 by:
+ * https://code.google.com/p/go/source/detail?r=fc1cd5e12595
+ *
+ * Binutils has issues debugging the vDSO: it reads the section table to
+ * find SHT_NOTE; it won't look at PT_NOTE for the in-memory vDSO, which
+ * would break build-id if we removed the section table.  Binutils
+ * also requires that shstrndx != 0.  See:
+ * https://sourceware.org/bugzilla/show_bug.cgi?id=17064
+ *
+ * elfutils might not look for PT_NOTE if there is a section table at
+ * all.  I don't know whether this matters for any practical purpose.
+ *
+ * For simplicity, rather than hacking up a partial section table, we
+ * just write a mostly complete one.  We omit non-dynamic symbols,
+ * though, since they're rather large.
+ *
+ * Once binutils gets fixed, we might be able to drop this for all but
+ * the 64-bit vdso, since build-id only works in kernel RPMs, and
+ * systems that update to new enough kernel RPMs will likely update
+ * binutils in sync.  build-id has never worked for home-built kernel
+ * RPMs without manual symlinking, and I suspect that no one ever does
+ * that.
+ */
+
 #include <inttypes.h>
 #include <stdint.h>
 #include <unistd.h>
@@ -61,7 +111,8 @@ static void fail(const char *format, ...)
         va_start(ap, format);
         fprintf(stderr, "Error: ");
         vfprintf(stderr, format, ap);
-        unlink(outfilename);
+        if (outfilename)
+                unlink(outfilename);
         exit(1);
         va_end(ap);
 }
@@ -114,30 +165,53 @@ extern void bad_put_le(void);
 #include "vdso2c.h"
 #undef ELF_BITS
 
-static void go(void *addr, size_t len, FILE *outfile, const char *name)
+static void go(void *raw_addr, size_t raw_len,
+               void *stripped_addr, size_t stripped_len,
+               FILE *outfile, const char *name)
 {
-        Elf64_Ehdr *hdr = (Elf64_Ehdr *)addr;
+        Elf64_Ehdr *hdr = (Elf64_Ehdr *)raw_addr;
 
         if (hdr->e_ident[EI_CLASS] == ELFCLASS64) {
-                go64(addr, len, outfile, name);
+                go64(raw_addr, raw_len, stripped_addr, stripped_len,
+                     outfile, name);
         } else if (hdr->e_ident[EI_CLASS] == ELFCLASS32) {
-                go32(addr, len, outfile, name);
+                go32(raw_addr, raw_len, stripped_addr, stripped_len,
+                     outfile, name);
         } else {
                 fail("unknown ELF class\n");
         }
 }
 
+static void map_input(const char *name, void **addr, size_t *len, int prot)
+{
+        off_t tmp_len;
+
+        int fd = open(name, O_RDONLY);
+        if (fd == -1)
+                err(1, "%s", name);
+
+        tmp_len = lseek(fd, 0, SEEK_END);
+        if (tmp_len == (off_t)-1)
+                err(1, "lseek");
+        *len = (size_t)tmp_len;
+
+        *addr = mmap(NULL, tmp_len, prot, MAP_PRIVATE, fd, 0);
+        if (*addr == MAP_FAILED)
+                err(1, "mmap");
+
+        close(fd);
+}
+
 int main(int argc, char **argv)
 {
-        int fd;
-        off_t len;
-        void *addr;
+        size_t raw_len, stripped_len;
+        void *raw_addr, *stripped_addr;
         FILE *outfile;
         char *name, *tmp;
         int namelen;
 
-        if (argc != 3) {
-                printf("Usage: vdso2c INPUT OUTPUT\n");
+        if (argc != 4) {
+                printf("Usage: vdso2c RAW_INPUT STRIPPED_INPUT OUTPUT\n");
                 return 1;
         }
 
@@ -145,7 +219,7 @@ int main(int argc, char **argv)
          * Figure out the struct name.  If we're writing to a .so file,
          * generate raw output insted.
          */
-        name = strdup(argv[2]);
+        name = strdup(argv[3]);
         namelen = strlen(name);
         if (namelen >= 3 && !strcmp(name + namelen - 3, ".so")) {
                 name = NULL;
@@ -161,26 +235,18 @@ int main(int argc, char **argv)
                                 *tmp = '_';
         }
 
-        fd = open(argv[1], O_RDONLY);
-        if (fd == -1)
-                err(1, "%s", argv[1]);
-
-        len = lseek(fd, 0, SEEK_END);
-        if (len == (off_t)-1)
-                err(1, "lseek");
-
-        addr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
-        if (addr == MAP_FAILED)
-                err(1, "mmap");
+        map_input(argv[1], &raw_addr, &raw_len, PROT_READ);
+        map_input(argv[2], &stripped_addr, &stripped_len, PROT_READ);
 
-        outfilename = argv[2];
+        outfilename = argv[3];
         outfile = fopen(outfilename, "w");
         if (!outfile)
                 err(1, "%s", argv[2]);
 
-        go(addr, (size_t)len, outfile, name);
+        go(raw_addr, raw_len, stripped_addr, stripped_len, outfile, name);
 
-        munmap(addr, len);
+        munmap(raw_addr, raw_len);
+        munmap(stripped_addr, stripped_len);
         fclose(outfile);
 
         return 0;