Merge branch 'x86-extable-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull exception table generation updates from Ingo Molnar:
 "The biggest change here is to allow the build-time sorting of the
  exception table, to speed up booting.  This is achieved by the
  architecture enabling BUILDTIME_EXTABLE_SORT.  This option is enabled
  for x86 and MIPS currently.

  On x86 a number of fixes and changes were needed to allow build-time
  sorting of the exception table, in particular a relocation invariant
  exception table format was needed.  This required the abstracting out
  of exception table protocol and the removal of 20 years of accumulated
  assumptions about the x86 exception table format.

  While at it, this tree also cleans up various other aspects of
  exception handling, such as early(er) exception handling for
  rdmsr_safe() et al.

  All in one, as the result of these changes the x86 exception code is
  now pretty nice and modern.  As an added bonus any regressions in this
  code will be early and violent crashes, so if you see any of those,
  you'll know whom to blame!"

Fix up trivial conflicts in arch/{mips,x86}/Kconfig files due to nearby
modifications of other core architecture options.

* 'x86-extable-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (35 commits)
  Revert "x86, extable: Disable presorted exception table for now"
  scripts/sortextable: Handle relative entries, and other cleanups
  x86, extable: Switch to relative exception table entries
  x86, extable: Disable presorted exception table for now
  x86, extable: Add _ASM_EXTABLE_EX() macro
  x86, extable: Remove open-coded exception table entries in arch/x86/ia32/ia32entry.S
  x86, extable: Remove open-coded exception table entries in arch/x86/include/asm/xsave.h
  x86, extable: Remove open-coded exception table entries in arch/x86/include/asm/kvm_host.h
  x86, extable: Remove the now-unused __ASM_EX_SEC macros
  x86, extable: Remove open-coded exception table entries in arch/x86/xen/xen-asm_32.S
  x86, extable: Remove open-coded exception table entries in arch/x86/um/checksum_32.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/usercopy_32.c
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/putuser.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/getuser.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/csum-copy_64.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/copy_user_nocache_64.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/copy_user_64.S
  x86, extable: Remove open-coded exception table entries in arch/x86/lib/checksum_32.S
  x86, extable: Remove open-coded exception table entries in arch/x86/kernel/test_rodata.c
  x86, extable: Remove open-coded exception table entries in arch/x86/kernel/entry_64.S
  ...

1 files changed, 322 insertions, 0 deletions

diff --git a/scripts/sortextable.c b/scripts/sortextable.c
new file mode 100644
index 000000000000..1ca9ceb95eb6
--- /dev/null
+++ b/scripts/sortextable.c
@@ -0,0 +1,322 @@
+/*
+ * sortextable.c: Sort the kernel's exception table
+ *
+ * Copyright 2011 - 2012 Cavium, Inc.
+ *
+ * Based on code taken from recortmcount.c which is:
+ *
+ * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved.
+ * Licensed under the GNU General Public License, version 2 (GPLv2).
+ *
+ * Restructured to fit Linux format, as well as other updates:
+ *  Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
+ */
+
+/*
+ * Strategy: alter the vmlinux file in-place.
+ */
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <getopt.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <tools/be_byteshift.h>
+#include <tools/le_byteshift.h>
+
+static int fd_map;      /* File descriptor for file being modified. */
+static int mmap_failed; /* Boolean flag. */
+static void *ehdr_curr; /* current ElfXX_Ehdr *  for resource cleanup */
+static struct stat sb;  /* Remember .st_size, etc. */
+static jmp_buf jmpenv;  /* setjmp/longjmp per-file error escape */
+
+/* setjmp() return values */
+enum {
+        SJ_SETJMP = 0,  /* hardwired first return */
+        SJ_FAIL,
+        SJ_SUCCEED
+};
+
+/* Per-file resource cleanup when multiple files. */
+static void
+cleanup(void)
+{
+        if (!mmap_failed)
+                munmap(ehdr_curr, sb.st_size);
+        close(fd_map);
+}
+
+static void __attribute__((noreturn))
+fail_file(void)
+{
+        cleanup();
+        longjmp(jmpenv, SJ_FAIL);
+}
+
+static void __attribute__((noreturn))
+succeed_file(void)
+{
+        cleanup();
+        longjmp(jmpenv, SJ_SUCCEED);
+}
+
+
+/*
+ * Get the whole file as a programming convenience in order to avoid
+ * malloc+lseek+read+free of many pieces.  If successful, then mmap
+ * avoids copying unused pieces; else just read the whole file.
+ * Open for both read and write.
+ */
+static void *mmap_file(char const *fname)
+{
+        void *addr;
+
+        fd_map = open(fname, O_RDWR);
+        if (fd_map < 0 || fstat(fd_map, &sb) < 0) {
+                perror(fname);
+                fail_file();
+        }
+        if (!S_ISREG(sb.st_mode)) {
+                fprintf(stderr, "not a regular file: %s\n", fname);
+                fail_file();
+        }
+        addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
+                    fd_map, 0);
+        if (addr == MAP_FAILED) {
+                mmap_failed = 1;
+                fprintf(stderr, "Could not mmap file: %s\n", fname);
+                fail_file();
+        }
+        return addr;
+}
+
+static uint64_t r8be(const uint64_t *x)
+{
+        return get_unaligned_be64(x);
+}
+static uint32_t rbe(const uint32_t *x)
+{
+        return get_unaligned_be32(x);
+}
+static uint16_t r2be(const uint16_t *x)
+{
+        return get_unaligned_be16(x);
+}
+static uint64_t r8le(const uint64_t *x)
+{
+        return get_unaligned_le64(x);
+}
+static uint32_t rle(const uint32_t *x)
+{
+        return get_unaligned_le32(x);
+}
+static uint16_t r2le(const uint16_t *x)
+{
+        return get_unaligned_le16(x);
+}
+
+static void w8be(uint64_t val, uint64_t *x)
+{
+        put_unaligned_be64(val, x);
+}
+static void wbe(uint32_t val, uint32_t *x)
+{
+        put_unaligned_be32(val, x);
+}
+static void w2be(uint16_t val, uint16_t *x)
+{
+        put_unaligned_be16(val, x);
+}
+static void w8le(uint64_t val, uint64_t *x)
+{
+        put_unaligned_le64(val, x);
+}
+static void wle(uint32_t val, uint32_t *x)
+{
+        put_unaligned_le32(val, x);
+}
+static void w2le(uint16_t val, uint16_t *x)
+{
+        put_unaligned_le16(val, x);
+}
+
+static uint64_t (*r8)(const uint64_t *);
+static uint32_t (*r)(const uint32_t *);
+static uint16_t (*r2)(const uint16_t *);
+static void (*w8)(uint64_t, uint64_t *);
+static void (*w)(uint32_t, uint32_t *);
+static void (*w2)(uint16_t, uint16_t *);
+
+typedef void (*table_sort_t)(char *, int);
+
+/* 32 bit and 64 bit are very similar */
+#include "sortextable.h"
+#define SORTEXTABLE_64
+#include "sortextable.h"
+
+static int compare_x86_table(const void *a, const void *b)
+{
+        int32_t av = (int32_t)r(a);
+        int32_t bv = (int32_t)r(b);
+
+        if (av < bv)
+                return -1;
+        if (av > bv)
+                return 1;
+        return 0;
+}
+
+static void sort_x86_table(char *extab_image, int image_size)
+{
+        int i;
+
+        /*
+         * Do the same thing the runtime sort does, first normalize to
+         * being relative to the start of the section.
+         */
+        i = 0;
+        while (i < image_size) {
+                uint32_t *loc = (uint32_t *)(extab_image + i);
+                w(r(loc) + i, loc);
+                i += 4;
+        }
+
+        qsort(extab_image, image_size / 8, 8, compare_x86_table);
+
+        /* Now denormalize. */
+        i = 0;
+        while (i < image_size) {
+                uint32_t *loc = (uint32_t *)(extab_image + i);
+                w(r(loc) - i, loc);
+                i += 4;
+        }
+}
+
+static void
+do_file(char const *const fname)
+{
+        table_sort_t custom_sort;
+        Elf32_Ehdr *ehdr = mmap_file(fname);
+
+        ehdr_curr = ehdr;
+        switch (ehdr->e_ident[EI_DATA]) {
+        default:
+                fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
+                        ehdr->e_ident[EI_DATA], fname);
+                fail_file();
+                break;
+        case ELFDATA2LSB:
+                r = rle;
+                r2 = r2le;
+                r8 = r8le;
+                w = wle;
+                w2 = w2le;
+                w8 = w8le;
+                break;
+        case ELFDATA2MSB:
+                r = rbe;
+                r2 = r2be;
+                r8 = r8be;
+                w = wbe;
+                w2 = w2be;
+                w8 = w8be;
+                break;
+        }  /* end switch */
+        if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
+        ||  r2(&ehdr->e_type) != ET_EXEC
+        ||  ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
+                fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname);
+                fail_file();
+        }
+
+        custom_sort = NULL;
+        switch (r2(&ehdr->e_machine)) {
+        default:
+                fprintf(stderr, "unrecognized e_machine %d %s\n",
+                        r2(&ehdr->e_machine), fname);
+                fail_file();
+                break;
+        case EM_386:
+        case EM_X86_64:
+                custom_sort = sort_x86_table;
+                break;
+        case EM_MIPS:
+                break;
+        }  /* end switch */
+
+        switch (ehdr->e_ident[EI_CLASS]) {
+        default:
+                fprintf(stderr, "unrecognized ELF class %d %s\n",
+                        ehdr->e_ident[EI_CLASS], fname);
+                fail_file();
+                break;
+        case ELFCLASS32:
+                if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
+                ||  r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
+                        fprintf(stderr,
+                                "unrecognized ET_EXEC file: %s\n", fname);
+                        fail_file();
+                }
+                do32(ehdr, fname, custom_sort);
+                break;
+        case ELFCLASS64: {
+                Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
+                if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
+                ||  r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
+                        fprintf(stderr,
+                                "unrecognized ET_EXEC file: %s\n", fname);
+                        fail_file();
+                }
+                do64(ghdr, fname, custom_sort);
+                break;
+        }
+        }  /* end switch */
+
+        cleanup();
+}
+
+int
+main(int argc, char *argv[])
+{
+        int n_error = 0;  /* gcc-4.3.0 false positive complaint */
+        int i;
+
+        if (argc < 2) {
+                fprintf(stderr, "usage: sortextable vmlinux...\n");
+                return 0;
+        }
+
+        /* Process each file in turn, allowing deep failure. */
+        for (i = 1; i < argc; i++) {
+                char *file = argv[i];
+                int const sjval = setjmp(jmpenv);
+
+                switch (sjval) {
+                default:
+                        fprintf(stderr, "internal error: %s\n", file);
+                        exit(1);
+                        break;
+                case SJ_SETJMP:    /* normal sequence */
+                        /* Avoid problems if early cleanup() */
+                        fd_map = -1;
+                        ehdr_curr = NULL;
+                        mmap_failed = 1;
+                        do_file(file);
+                        break;
+                case SJ_FAIL:    /* error in do_file or below */
+                        ++n_error;
+                        break;
+                case SJ_SUCCEED:    /* premature success */
+                        /* do nothing */
+                        break;
+                }  /* end switch */
+        }
+        return !!n_error;
+}