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

Pull x86 core updates from Ingo Molnar:
 "Note that in this cycle most of the x86 topics interacted at a level
  that caused them to be merged into tip:x86/asm - but this should be a
  temporary phenomenon, hopefully we'll back to the usual patterns in
  the next merge window.

  The main changes in this cycle were:

  Hardware enablement:

   - Add support for the Intel UMIP (User Mode Instruction Prevention)
     CPU feature. This is a security feature that disables certain
     instructions such as SGDT, SLDT, SIDT, SMSW and STR. (Ricardo Neri)

     [ Note that this is disabled by default for now, there are some
       smaller enhancements in the pipeline that I'll follow up with in
       the next 1-2 days, which allows this to be enabled by default.]

   - Add support for the AMD SEV (Secure Encrypted Virtualization) CPU
     feature, on top of SME (Secure Memory Encryption) support that was
     added in v4.14. (Tom Lendacky, Brijesh Singh)

   - Enable new SSE/AVX/AVX512 CPU features: AVX512_VBMI2, GFNI, VAES,
     VPCLMULQDQ, AVX512_VNNI, AVX512_BITALG. (Gayatri Kammela)

  Other changes:

   - A big series of entry code simplifications and enhancements (Andy
     Lutomirski)

   - Make the ORC unwinder default on x86 and various objtool
     enhancements. (Josh Poimboeuf)

   - 5-level paging enhancements (Kirill A. Shutemov)

   - Micro-optimize the entry code a bit (Borislav Petkov)

   - Improve the handling of interdependent CPU features in the early
     FPU init code (Andi Kleen)

   - Build system enhancements (Changbin Du, Masahiro Yamada)

   - ... plus misc enhancements, fixes and cleanups"

* 'x86-asm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (118 commits)
  x86/build: Make the boot image generation less verbose
  selftests/x86: Add tests for the STR and SLDT instructions
  selftests/x86: Add tests for User-Mode Instruction Prevention
  x86/traps: Fix up general protection faults caused by UMIP
  x86/umip: Enable User-Mode Instruction Prevention at runtime
  x86/umip: Force a page fault when unable to copy emulated result to user
  x86/umip: Add emulation code for UMIP instructions
  x86/cpufeature: Add User-Mode Instruction Prevention definitions
  x86/insn-eval: Add support to resolve 16-bit address encodings
  x86/insn-eval: Handle 32-bit address encodings in virtual-8086 mode
  x86/insn-eval: Add wrapper function for 32 and 64-bit addresses
  x86/insn-eval: Add support to resolve 32-bit address encodings
  x86/insn-eval: Compute linear address in several utility functions
  resource: Fix resource_size.cocci warnings
  X86/KVM: Clear encryption attribute when SEV is active
  X86/KVM: Decrypt shared per-cpu variables when SEV is active
  percpu: Introduce DEFINE_PER_CPU_DECRYPTED
  x86: Add support for changing memory encryption attribute in early boot
  x86/io: Unroll string I/O when SEV is active
  x86/boot: Add early boot support when running with SEV active
  ...

5 files changed, 183 insertions, 31 deletions

diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index c0e26ad1fa7e..9b341584eb1b 100644
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -1757,11 +1757,14 @@ static int validate_branch(struct objtool_file *file, struct instruction *first,
                 if (insn->dead_end)
                         return 0;
 
-                insn = next_insn;
-                if (!insn) {
+                if (!next_insn) {
+                        if (state.cfa.base == CFI_UNDEFINED)
+                                return 0;
                         WARN("%s: unexpected end of section", sec->name);
                         return 1;
                 }
+
+                insn = next_insn;
         }
 
         return 0;
diff --git a/tools/objtool/objtool.c b/tools/objtool/objtool.c
index 31e0f9143840..07f329919828 100644
--- a/tools/objtool/objtool.c
+++ b/tools/objtool/objtool.c
@@ -70,7 +70,7 @@ static void cmd_usage(void)
 
         printf("\n");
 
-        exit(1);
+        exit(129);
 }
 
 static void handle_options(int *argc, const char ***argv)
@@ -86,9 +86,7 @@ static void handle_options(int *argc, const char ***argv)
                         break;
                 } else {
                         fprintf(stderr, "Unknown option: %s\n", cmd);
-                        fprintf(stderr, "\n Usage: %s\n",
-                                objtool_usage_string);
-                        exit(1);
+                        cmd_usage();
                 }
 
                 (*argv)++;
diff --git a/tools/testing/selftests/x86/entry_from_vm86.c b/tools/testing/selftests/x86/entry_from_vm86.c
index d075ea0e5ca1..361466a2eaef 100644
--- a/tools/testing/selftests/x86/entry_from_vm86.c
+++ b/tools/testing/selftests/x86/entry_from_vm86.c
@@ -95,6 +95,27 @@ asm (
         "int3\n\t"
         "vmcode_int80:\n\t"
         "int $0x80\n\t"
+        "vmcode_umip:\n\t"
+        /* addressing via displacements */
+        "smsw (2052)\n\t"
+        "sidt (2054)\n\t"
+        "sgdt (2060)\n\t"
+        /* addressing via registers */
+        "mov $2066, %bx\n\t"
+        "smsw (%bx)\n\t"
+        "mov $2068, %bx\n\t"
+        "sidt (%bx)\n\t"
+        "mov $2074, %bx\n\t"
+        "sgdt (%bx)\n\t"
+        /* register operands, only for smsw */
+        "smsw %ax\n\t"
+        "mov %ax, (2080)\n\t"
+        "int3\n\t"
+        "vmcode_umip_str:\n\t"
+        "str %eax\n\t"
+        "vmcode_umip_sldt:\n\t"
+        "sldt %eax\n\t"
+        "int3\n\t"
         ".size vmcode, . - vmcode\n\t"
         "end_vmcode:\n\t"
         ".code32\n\t"
@@ -103,7 +124,8 @@ asm (
 
 extern unsigned char vmcode[], end_vmcode[];
 extern unsigned char vmcode_bound[], vmcode_sysenter[], vmcode_syscall[],
-        vmcode_sti[], vmcode_int3[], vmcode_int80[];
+        vmcode_sti[], vmcode_int3[], vmcode_int80[], vmcode_umip[],
+        vmcode_umip_str[], vmcode_umip_sldt[];
 
 /* Returns false if the test was skipped. */
 static bool do_test(struct vm86plus_struct *v86, unsigned long eip,
@@ -160,6 +182,68 @@ static bool do_test(struct vm86plus_struct *v86, unsigned long eip,
         return true;
 }
 
+void do_umip_tests(struct vm86plus_struct *vm86, unsigned char *test_mem)
+{
+        struct table_desc {
+                unsigned short limit;
+                unsigned long base;
+        } __attribute__((packed));
+
+        /* Initialize variables with arbitrary values */
+        struct table_desc gdt1 = { .base = 0x3c3c3c3c, .limit = 0x9999 };
+        struct table_desc gdt2 = { .base = 0x1a1a1a1a, .limit = 0xaeae };
+        struct table_desc idt1 = { .base = 0x7b7b7b7b, .limit = 0xf1f1 };
+        struct table_desc idt2 = { .base = 0x89898989, .limit = 0x1313 };
+        unsigned short msw1 = 0x1414, msw2 = 0x2525, msw3 = 3737;
+
+        /* UMIP -- exit with INT3 unless kernel emulation did not trap #GP */
+        do_test(vm86, vmcode_umip - vmcode, VM86_TRAP, 3, "UMIP tests");
+
+        /* Results from displacement-only addressing */
+        msw1 = *(unsigned short *)(test_mem + 2052);
+        memcpy(&idt1, test_mem + 2054, sizeof(idt1));
+        memcpy(&gdt1, test_mem + 2060, sizeof(gdt1));
+
+        /* Results from register-indirect addressing */
+        msw2 = *(unsigned short *)(test_mem + 2066);
+        memcpy(&idt2, test_mem + 2068, sizeof(idt2));
+        memcpy(&gdt2, test_mem + 2074, sizeof(gdt2));
+
+        /* Results when using register operands */
+        msw3 = *(unsigned short *)(test_mem + 2080);
+
+        printf("[INFO]\tResult from SMSW:[0x%04x]\n", msw1);
+        printf("[INFO]\tResult from SIDT: limit[0x%04x]base[0x%08lx]\n",
+               idt1.limit, idt1.base);
+        printf("[INFO]\tResult from SGDT: limit[0x%04x]base[0x%08lx]\n",
+               gdt1.limit, gdt1.base);
+
+        if (msw1 != msw2 || msw1 != msw3)
+                printf("[FAIL]\tAll the results of SMSW should be the same.\n");
+        else
+                printf("[PASS]\tAll the results from SMSW are identical.\n");
+
+        if (memcmp(&gdt1, &gdt2, sizeof(gdt1)))
+                printf("[FAIL]\tAll the results of SGDT should be the same.\n");
+        else
+                printf("[PASS]\tAll the results from SGDT are identical.\n");
+
+        if (memcmp(&idt1, &idt2, sizeof(idt1)))
+                printf("[FAIL]\tAll the results of SIDT should be the same.\n");
+        else
+                printf("[PASS]\tAll the results from SIDT are identical.\n");
+
+        sethandler(SIGILL, sighandler, 0);
+        do_test(vm86, vmcode_umip_str - vmcode, VM86_SIGNAL, 0,
+                "STR instruction");
+        clearhandler(SIGILL);
+
+        sethandler(SIGILL, sighandler, 0);
+        do_test(vm86, vmcode_umip_sldt - vmcode, VM86_SIGNAL, 0,
+                "SLDT instruction");
+        clearhandler(SIGILL);
+}
+
 int main(void)
 {
         struct vm86plus_struct v86;
@@ -218,6 +302,9 @@ int main(void)
         v86.regs.eax = (unsigned int)-1;
         do_test(&v86, vmcode_int80 - vmcode, VM86_INTx, 0x80, "int80");
 
+        /* UMIP -- should exit with INTx 0x80 unless UMIP was not disabled */
+        do_umip_tests(&v86, addr);
+
         /* Execute a null pointer */
         v86.regs.cs = 0;
         v86.regs.ss = 0;
diff --git a/tools/testing/selftests/x86/ldt_gdt.c b/tools/testing/selftests/x86/ldt_gdt.c
index 961e3ee26c27..66e5ce5b91f0 100644
--- a/tools/testing/selftests/x86/ldt_gdt.c
+++ b/tools/testing/selftests/x86/ldt_gdt.c
@@ -115,7 +115,15 @@ static void check_valid_segment(uint16_t index, int ldt,
                 return;
         }
 
-        if (ar != expected_ar) {
+        /* The SDM says "bits 19:16 are undefined".  Thanks. */
+        ar &= ~0xF0000;
+
+        /*
+         * NB: Different Linux versions do different things with the
+         * accessed bit in set_thread_area().
+         */
+        if (ar != expected_ar &&
+            (ldt || ar != (expected_ar | AR_ACCESSED))) {
                 printf("[FAIL]\t%s entry %hu has AR 0x%08X but expected 0x%08X\n",
                        (ldt ? "LDT" : "GDT"), index, ar, expected_ar);
                 nerrs++;
@@ -129,30 +137,51 @@ static void check_valid_segment(uint16_t index, int ldt,
         }
 }
 
-static bool install_valid_mode(const struct user_desc *desc, uint32_t ar,
-                               bool oldmode)
+static bool install_valid_mode(const struct user_desc *d, uint32_t ar,
+                               bool oldmode, bool ldt)
 {
-        int ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
-                          desc, sizeof(*desc));
-        if (ret < -1)
-                errno = -ret;
+        struct user_desc desc = *d;
+        int ret;
+
+        if (!ldt) {
+#ifndef __i386__
+                /* No point testing set_thread_area in a 64-bit build */
+                return false;
+#endif
+                if (!gdt_entry_num)
+                        return false;
+                desc.entry_number = gdt_entry_num;
+
+                ret = syscall(SYS_set_thread_area, &desc);
+        } else {
+                ret = syscall(SYS_modify_ldt, oldmode ? 1 : 0x11,
+                              &desc, sizeof(desc));
+
+                if (ret < -1)
+                        errno = -ret;
+
+                if (ret != 0 && errno == ENOSYS) {
+                        printf("[OK]\tmodify_ldt returned -ENOSYS\n");
+                        return false;
+                }
+        }
+
         if (ret == 0) {
-                uint32_t limit = desc->limit;
-                if (desc->limit_in_pages)
+                uint32_t limit = desc.limit;
+                if (desc.limit_in_pages)
                         limit = (limit << 12) + 4095;
-                check_valid_segment(desc->entry_number, 1, ar, limit, true);
+                check_valid_segment(desc.entry_number, ldt, ar, limit, true);
                 return true;
-        } else if (errno == ENOSYS) {
-                printf("[OK]\tmodify_ldt returned -ENOSYS\n");
-                return false;
         } else {
-                if (desc->seg_32bit) {
-                        printf("[FAIL]\tUnexpected modify_ldt failure %d\n",
+                if (desc.seg_32bit) {
+                        printf("[FAIL]\tUnexpected %s failure %d\n",
+                               ldt ? "modify_ldt" : "set_thread_area",
                                errno);
                         nerrs++;
                         return false;
                 } else {
-                        printf("[OK]\tmodify_ldt rejected 16 bit segment\n");
+                        printf("[OK]\t%s rejected 16 bit segment\n",
+                               ldt ? "modify_ldt" : "set_thread_area");
                         return false;
                 }
         }
@@ -160,7 +189,15 @@ static bool install_valid_mode(const struct user_desc *desc, uint32_t ar,
 
 static bool install_valid(const struct user_desc *desc, uint32_t ar)
 {
-        return install_valid_mode(desc, ar, false);
+        bool ret = install_valid_mode(desc, ar, false, true);
+
+        if (desc->contents <= 1 && desc->seg_32bit &&
+            !desc->seg_not_present) {
+                /* Should work in the GDT, too. */
+                install_valid_mode(desc, ar, false, false);
+        }
+
+        return ret;
 }
 
 static void install_invalid(const struct user_desc *desc, bool oldmode)
@@ -367,9 +404,24 @@ static void do_simple_tests(void)
         install_invalid(&desc, false);
 
         desc.seg_not_present = 0;
-        desc.read_exec_only = 0;
         desc.seg_32bit = 1;
+        desc.read_exec_only = 0;
+        desc.limit = 0xfffff;
+
         install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P | AR_DB);
+
+        desc.limit_in_pages = 1;
+
+        install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA | AR_S | AR_P | AR_DB | AR_G);
+        desc.read_exec_only = 1;
+        install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA | AR_S | AR_P | AR_DB | AR_G);
+        desc.contents = 1;
+        desc.read_exec_only = 0;
+        install_valid(&desc, AR_DPL3 | AR_TYPE_RWDATA_EXPDOWN | AR_S | AR_P | AR_DB | AR_G);
+        desc.read_exec_only = 1;
+        install_valid(&desc, AR_DPL3 | AR_TYPE_RODATA_EXPDOWN | AR_S | AR_P | AR_DB | AR_G);
+
+        desc.limit = 0;
         install_invalid(&desc, true);
 }
 
diff --git a/tools/testing/selftests/x86/protection_keys.c b/tools/testing/selftests/x86/protection_keys.c
index 555e43ca846b..7a1cc0e56d2d 100644
--- a/tools/testing/selftests/x86/protection_keys.c
+++ b/tools/testing/selftests/x86/protection_keys.c
@@ -189,17 +189,29 @@ void lots_o_noops_around_write(int *write_to_me)
 #define u64 uint64_t
 
 #ifdef __i386__
-#define SYS_mprotect_key 380
-#define SYS_pkey_alloc   381
-#define SYS_pkey_free    382
+
+#ifndef SYS_mprotect_key
+# define SYS_mprotect_key 380
+#endif
+#ifndef SYS_pkey_alloc
+# define SYS_pkey_alloc  381
+# define SYS_pkey_free   382
+#endif
 #define REG_IP_IDX REG_EIP
 #define si_pkey_offset 0x14
+
 #else
-#define SYS_mprotect_key 329
-#define SYS_pkey_alloc   330
-#define SYS_pkey_free    331
+
+#ifndef SYS_mprotect_key
+# define SYS_mprotect_key 329
+#endif
+#ifndef SYS_pkey_alloc
+# define SYS_pkey_alloc  330
+# define SYS_pkey_free   331
+#endif
 #define REG_IP_IDX REG_RIP
 #define si_pkey_offset 0x20
+
 #endif
 
 void dump_mem(void *dumpme, int len_bytes)