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
  ...

4 files changed, 517 insertions, 0 deletions

diff --git a/scripts/.gitignore b/scripts/.gitignore
index 105b21f08185..65f362d931b5 100644
--- a/scripts/.gitignore
+++ b/scripts/.gitignore
@@ -9,3 +9,4 @@ unifdef
 ihex2fw
 recordmcount
 docproc
+sortextable
diff --git a/scripts/Makefile b/scripts/Makefile
index 36266665dbcb..a55b0067758a 100644
--- a/scripts/Makefile
+++ b/scripts/Makefile
@@ -15,6 +15,9 @@ hostprogs-$(CONFIG_LOGO)         += pnmtologo
 hostprogs-$(CONFIG_VT)           += conmakehash
 hostprogs-$(CONFIG_IKCONFIG)     += bin2c
 hostprogs-$(BUILD_C_RECORDMCOUNT) += recordmcount
+hostprogs-$(CONFIG_BUILDTIME_EXTABLE_SORT) += sortextable
+
+HOSTCFLAGS_sortextable.o = -I$(srctree)/tools/include
 
 always          := $(hostprogs-y) $(hostprogs-m)
 
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;
+}
diff --git a/scripts/sortextable.h b/scripts/sortextable.h
new file mode 100644
index 000000000000..e4fd45b7e456
--- /dev/null
+++ b/scripts/sortextable.h
@@ -0,0 +1,191 @@
+/*
+ * sortextable.h
+ *
+ * Copyright 2011 - 2012 Cavium, Inc.
+ *
+ * Some of this code was taken out of recordmcount.h written by:
+ *
+ * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved.
+ * Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
+ *
+ *
+ * Licensed under the GNU General Public License, version 2 (GPLv2).
+ */
+
+#undef extable_ent_size
+#undef compare_extable
+#undef do_func
+#undef Elf_Addr
+#undef Elf_Ehdr
+#undef Elf_Shdr
+#undef Elf_Rel
+#undef Elf_Rela
+#undef Elf_Sym
+#undef ELF_R_SYM
+#undef Elf_r_sym
+#undef ELF_R_INFO
+#undef Elf_r_info
+#undef ELF_ST_BIND
+#undef ELF_ST_TYPE
+#undef fn_ELF_R_SYM
+#undef fn_ELF_R_INFO
+#undef uint_t
+#undef _r
+#undef _w
+
+#ifdef SORTEXTABLE_64
+# define extable_ent_size       16
+# define compare_extable        compare_extable_64
+# define do_func                do64
+# define Elf_Addr               Elf64_Addr
+# define Elf_Ehdr               Elf64_Ehdr
+# define Elf_Shdr               Elf64_Shdr
+# define Elf_Rel                Elf64_Rel
+# define Elf_Rela               Elf64_Rela
+# define Elf_Sym                Elf64_Sym
+# define ELF_R_SYM              ELF64_R_SYM
+# define Elf_r_sym              Elf64_r_sym
+# define ELF_R_INFO             ELF64_R_INFO
+# define Elf_r_info             Elf64_r_info
+# define ELF_ST_BIND            ELF64_ST_BIND
+# define ELF_ST_TYPE            ELF64_ST_TYPE
+# define fn_ELF_R_SYM           fn_ELF64_R_SYM
+# define fn_ELF_R_INFO          fn_ELF64_R_INFO
+# define uint_t                 uint64_t
+# define _r                     r8
+# define _w                     w8
+#else
+# define extable_ent_size       8
+# define compare_extable        compare_extable_32
+# define do_func                do32
+# define Elf_Addr               Elf32_Addr
+# define Elf_Ehdr               Elf32_Ehdr
+# define Elf_Shdr               Elf32_Shdr
+# define Elf_Rel                Elf32_Rel
+# define Elf_Rela               Elf32_Rela
+# define Elf_Sym                Elf32_Sym
+# define ELF_R_SYM              ELF32_R_SYM
+# define Elf_r_sym              Elf32_r_sym
+# define ELF_R_INFO             ELF32_R_INFO
+# define Elf_r_info             Elf32_r_info
+# define ELF_ST_BIND            ELF32_ST_BIND
+# define ELF_ST_TYPE            ELF32_ST_TYPE
+# define fn_ELF_R_SYM           fn_ELF32_R_SYM
+# define fn_ELF_R_INFO          fn_ELF32_R_INFO
+# define uint_t                 uint32_t
+# define _r                     r
+# define _w                     w
+#endif
+
+static int compare_extable(const void *a, const void *b)
+{
+        Elf_Addr av = _r(a);
+        Elf_Addr bv = _r(b);
+
+        if (av < bv)
+                return -1;
+        if (av > bv)
+                return 1;
+        return 0;
+}
+
+static void
+do_func(Elf_Ehdr *ehdr, char const *const fname, table_sort_t custom_sort)
+{
+        Elf_Shdr *shdr;
+        Elf_Shdr *shstrtab_sec;
+        Elf_Shdr *strtab_sec = NULL;
+        Elf_Shdr *symtab_sec = NULL;
+        Elf_Shdr *extab_sec = NULL;
+        Elf_Sym *sym;
+        Elf_Sym *sort_needed_sym;
+        Elf_Shdr *sort_needed_sec;
+        Elf_Rel *relocs = NULL;
+        int relocs_size;
+        uint32_t *sort_done_location;
+        const char *secstrtab;
+        const char *strtab;
+        char *extab_image;
+        int extab_index = 0;
+        int i;
+        int idx;
+
+        shdr = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->e_shoff));
+        shstrtab_sec = shdr + r2(&ehdr->e_shstrndx);
+        secstrtab = (const char *)ehdr + _r(&shstrtab_sec->sh_offset);
+        for (i = 0; i < r2(&ehdr->e_shnum); i++) {
+                idx = r(&shdr[i].sh_name);
+                if (strcmp(secstrtab + idx, "__ex_table") == 0) {
+                        extab_sec = shdr + i;
+                        extab_index = i;
+                }
+                if ((r(&shdr[i].sh_type) == SHT_REL ||
+                     r(&shdr[i].sh_type) == SHT_RELA) &&
+                    r(&shdr[i].sh_info) == extab_index) {
+                        relocs = (void *)ehdr + _r(&shdr[i].sh_offset);
+                        relocs_size = _r(&shdr[i].sh_size);
+                }
+                if (strcmp(secstrtab + idx, ".symtab") == 0)
+                        symtab_sec = shdr + i;
+                if (strcmp(secstrtab + idx, ".strtab") == 0)
+                        strtab_sec = shdr + i;
+        }
+        if (strtab_sec == NULL) {
+                fprintf(stderr, "no .strtab in  file: %s\n", fname);
+                fail_file();
+        }
+        if (symtab_sec == NULL) {
+                fprintf(stderr, "no .symtab in  file: %s\n", fname);
+                fail_file();
+        }
+        if (extab_sec == NULL) {
+                fprintf(stderr, "no __ex_table in  file: %s\n", fname);
+                fail_file();
+        }
+        strtab = (const char *)ehdr + _r(&strtab_sec->sh_offset);
+
+        extab_image = (void *)ehdr + _r(&extab_sec->sh_offset);
+
+        if (custom_sort) {
+                custom_sort(extab_image, _r(&extab_sec->sh_size));
+        } else {
+                int num_entries = _r(&extab_sec->sh_size) / extable_ent_size;
+                qsort(extab_image, num_entries,
+                      extable_ent_size, compare_extable);
+        }
+        /* If there were relocations, we no longer need them. */
+        if (relocs)
+                memset(relocs, 0, relocs_size);
+
+        /* find main_extable_sort_needed */
+        sort_needed_sym = NULL;
+        for (i = 0; i < _r(&symtab_sec->sh_size) / sizeof(Elf_Sym); i++) {
+                sym = (void *)ehdr + _r(&symtab_sec->sh_offset);
+                sym += i;
+                if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT)
+                        continue;
+                idx = r(&sym->st_name);
+                if (strcmp(strtab + idx, "main_extable_sort_needed") == 0) {
+                        sort_needed_sym = sym;
+                        break;
+                }
+        }
+        if (sort_needed_sym == NULL) {
+                fprintf(stderr,
+                        "no main_extable_sort_needed symbol in  file: %s\n",
+                        fname);
+                fail_file();
+        }
+        sort_needed_sec = &shdr[r2(&sort_needed_sym->st_shndx)];
+        sort_done_location = (void *)ehdr +
+                _r(&sort_needed_sec->sh_offset) +
+                _r(&sort_needed_sym->st_value) -
+                _r(&sort_needed_sec->sh_addr);
+
+#if 1
+        printf("sort done marker at %lx\n",
+               (unsigned long)((char *)sort_done_location - (char *)ehdr));
+#endif
+        /* We sorted it, clear the flag. */
+        w(0, sort_done_location);
+}