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

Pull x86 asm updates from Ingo Molnar:
 "The main changes in this cycle were:

   - MSR access API fixes and enhancements (Andy Lutomirski)

   - early exception handling improvements (Andy Lutomirski)

   - user-space FS/GS prctl usage fixes and improvements (Andy
     Lutomirski)

   - Remove the cpu_has_*() APIs and replace them with equivalents
     (Borislav Petkov)

   - task switch micro-optimization (Brian Gerst)

   - 32-bit entry code simplification (Denys Vlasenko)

   - enhance PAT handling in enumated CPUs (Toshi Kani)

  ... and lots of other cleanups/fixlets"

* 'x86-asm-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (70 commits)
  x86/arch_prctl/64: Restore accidentally removed put_cpu() in ARCH_SET_GS
  x86/entry/32: Remove asmlinkage_protect()
  x86/entry/32: Remove GET_THREAD_INFO() from entry code
  x86/entry, sched/x86: Don't save/restore EFLAGS on task switch
  x86/asm/entry/32: Simplify pushes of zeroed pt_regs->REGs
  selftests/x86/ldt_gdt: Test set_thread_area() deletion of an active segment
  x86/tls: Synchronize segment registers in set_thread_area()
  x86/asm/64: Rename thread_struct's fs and gs to fsbase and gsbase
  x86/arch_prctl/64: Remove FSBASE/GSBASE < 4G optimization
  x86/segments/64: When load_gs_index fails, clear the base
  x86/segments/64: When loadsegment(fs, ...) fails, clear the base
  x86/asm: Make asm/alternative.h safe from assembly
  x86/asm: Stop depending on ptrace.h in alternative.h
  x86/entry: Rename is_{ia32,x32}_task() to in_{ia32,x32}_syscall()
  x86/asm: Make sure verify_cpu() has a good stack
  x86/extable: Add a comment about early exception handlers
  x86/msr: Set the return value to zero when native_rdmsr_safe() fails
  x86/paravirt: Make "unsafe" MSR accesses unsafe even if PARAVIRT=y
  x86/paravirt: Add paravirt_{read,write}_msr()
  x86/msr: Carry on after a non-"safe" MSR access fails
  ...

3 files changed, 649 insertions, 0 deletions

diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile
index b47ebd170690..c73425de3cfe 100644
--- a/tools/testing/selftests/x86/Makefile
+++ b/tools/testing/selftests/x86/Makefile
@@ -9,6 +9,7 @@ TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt ptrace_sysc
 TARGETS_C_32BIT_ONLY := entry_from_vm86 syscall_arg_fault test_syscall_vdso unwind_vdso \
                         test_FCMOV test_FCOMI test_FISTTP \
                         vdso_restorer
+TARGETS_C_64BIT_ONLY := fsgsbase
 
 TARGETS_C_32BIT_ALL := $(TARGETS_C_BOTHBITS) $(TARGETS_C_32BIT_ONLY)
 TARGETS_C_64BIT_ALL := $(TARGETS_C_BOTHBITS) $(TARGETS_C_64BIT_ONLY)
diff --git a/tools/testing/selftests/x86/fsgsbase.c b/tools/testing/selftests/x86/fsgsbase.c
new file mode 100644
index 000000000000..5b2b4b3c634c
--- /dev/null
+++ b/tools/testing/selftests/x86/fsgsbase.c
@@ -0,0 +1,398 @@
+/*
+ * fsgsbase.c, an fsgsbase test
+ * Copyright (c) 2014-2016 Andy Lutomirski
+ * GPL v2
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <err.h>
+#include <sys/user.h>
+#include <asm/prctl.h>
+#include <sys/prctl.h>
+#include <signal.h>
+#include <limits.h>
+#include <sys/ucontext.h>
+#include <sched.h>
+#include <linux/futex.h>
+#include <pthread.h>
+#include <asm/ldt.h>
+#include <sys/mman.h>
+
+#ifndef __x86_64__
+# error This test is 64-bit only
+#endif
+
+static volatile sig_atomic_t want_segv;
+static volatile unsigned long segv_addr;
+
+static int nerrs;
+
+static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
+                       int flags)
+{
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_sigaction = handler;
+        sa.sa_flags = SA_SIGINFO | flags;
+        sigemptyset(&sa.sa_mask);
+        if (sigaction(sig, &sa, 0))
+                err(1, "sigaction");
+}
+
+static void clearhandler(int sig)
+{
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_handler = SIG_DFL;
+        sigemptyset(&sa.sa_mask);
+        if (sigaction(sig, &sa, 0))
+                err(1, "sigaction");
+}
+
+static void sigsegv(int sig, siginfo_t *si, void *ctx_void)
+{
+        ucontext_t *ctx = (ucontext_t*)ctx_void;
+
+        if (!want_segv) {
+                clearhandler(SIGSEGV);
+                return;  /* Crash cleanly. */
+        }
+
+        want_segv = false;
+        segv_addr = (unsigned long)si->si_addr;
+
+        ctx->uc_mcontext.gregs[REG_RIP] += 4;   /* Skip the faulting mov */
+
+}
+
+enum which_base { FS, GS };
+
+static unsigned long read_base(enum which_base which)
+{
+        unsigned long offset;
+        /*
+         * Unless we have FSGSBASE, there's no direct way to do this from
+         * user mode.  We can get at it indirectly using signals, though.
+         */
+
+        want_segv = true;
+
+        offset = 0;
+        if (which == FS) {
+                /* Use a constant-length instruction here. */
+                asm volatile ("mov %%fs:(%%rcx), %%rax" : : "c" (offset) : "rax");
+        } else {
+                asm volatile ("mov %%gs:(%%rcx), %%rax" : : "c" (offset) : "rax");
+        }
+        if (!want_segv)
+                return segv_addr + offset;
+
+        /*
+         * If that didn't segfault, try the other end of the address space.
+         * Unless we get really unlucky and run into the vsyscall page, this
+         * is guaranteed to segfault.
+         */
+
+        offset = (ULONG_MAX >> 1) + 1;
+        if (which == FS) {
+                asm volatile ("mov %%fs:(%%rcx), %%rax"
+                              : : "c" (offset) : "rax");
+        } else {
+                asm volatile ("mov %%gs:(%%rcx), %%rax"
+                              : : "c" (offset) : "rax");
+        }
+        if (!want_segv)
+                return segv_addr + offset;
+
+        abort();
+}
+
+static void check_gs_value(unsigned long value)
+{
+        unsigned long base;
+        unsigned short sel;
+
+        printf("[RUN]\tARCH_SET_GS to 0x%lx\n", value);
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, value) != 0)
+                err(1, "ARCH_SET_GS");
+
+        asm volatile ("mov %%gs, %0" : "=rm" (sel));
+        base = read_base(GS);
+        if (base == value) {
+                printf("[OK]\tGSBASE was set as expected (selector 0x%hx)\n",
+                       sel);
+        } else {
+                nerrs++;
+                printf("[FAIL]\tGSBASE was not as expected: got 0x%lx (selector 0x%hx)\n",
+                       base, sel);
+        }
+
+        if (syscall(SYS_arch_prctl, ARCH_GET_GS, &base) != 0)
+                err(1, "ARCH_GET_GS");
+        if (base == value) {
+                printf("[OK]\tARCH_GET_GS worked as expected (selector 0x%hx)\n",
+                       sel);
+        } else {
+                nerrs++;
+                printf("[FAIL]\tARCH_GET_GS was not as expected: got 0x%lx (selector 0x%hx)\n",
+                       base, sel);
+        }
+}
+
+static void mov_0_gs(unsigned long initial_base, bool schedule)
+{
+        unsigned long base, arch_base;
+
+        printf("[RUN]\tARCH_SET_GS to 0x%lx then mov 0 to %%gs%s\n", initial_base, schedule ? " and schedule " : "");
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, initial_base) != 0)
+                err(1, "ARCH_SET_GS");
+
+        if (schedule)
+                usleep(10);
+
+        asm volatile ("mov %0, %%gs" : : "rm" (0));
+        base = read_base(GS);
+        if (syscall(SYS_arch_prctl, ARCH_GET_GS, &arch_base) != 0)
+                err(1, "ARCH_GET_GS");
+        if (base == arch_base) {
+                printf("[OK]\tGSBASE is 0x%lx\n", base);
+        } else {
+                nerrs++;
+                printf("[FAIL]\tGSBASE changed to 0x%lx but kernel reports 0x%lx\n", base, arch_base);
+        }
+}
+
+static volatile unsigned long remote_base;
+static volatile bool remote_hard_zero;
+static volatile unsigned int ftx;
+
+/*
+ * ARCH_SET_FS/GS(0) may or may not program a selector of zero.  HARD_ZERO
+ * means to force the selector to zero to improve test coverage.
+ */
+#define HARD_ZERO 0xa1fa5f343cb85fa4
+
+static void do_remote_base()
+{
+        unsigned long to_set = remote_base;
+        bool hard_zero = false;
+        if (to_set == HARD_ZERO) {
+                to_set = 0;
+                hard_zero = true;
+        }
+
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, to_set) != 0)
+                err(1, "ARCH_SET_GS");
+
+        if (hard_zero)
+                asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)0));
+
+        unsigned short sel;
+        asm volatile ("mov %%gs, %0" : "=rm" (sel));
+        printf("\tother thread: ARCH_SET_GS(0x%lx)%s -- sel is 0x%hx\n",
+               to_set, hard_zero ? " and clear gs" : "", sel);
+}
+
+void do_unexpected_base(void)
+{
+        /*
+         * The goal here is to try to arrange for GS == 0, GSBASE !=
+         * 0, and for the the kernel the think that GSBASE == 0.
+         *
+         * To make the test as reliable as possible, this uses
+         * explicit descriptorss.  (This is not the only way.  This
+         * could use ARCH_SET_GS with a low, nonzero base, but the
+         * relevant side effect of ARCH_SET_GS could change.)
+         */
+
+        /* Step 1: tell the kernel that we have GSBASE == 0. */
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, 0) != 0)
+                err(1, "ARCH_SET_GS");
+
+        /* Step 2: change GSBASE without telling the kernel. */
+        struct user_desc desc = {
+                .entry_number    = 0,
+                .base_addr       = 0xBAADF00D,
+                .limit           = 0xfffff,
+                .seg_32bit       = 1,
+                .contents        = 0, /* Data, grow-up */
+                .read_exec_only  = 0,
+                .limit_in_pages  = 1,
+                .seg_not_present = 0,
+                .useable         = 0
+        };
+        if (syscall(SYS_modify_ldt, 1, &desc, sizeof(desc)) == 0) {
+                printf("\tother thread: using LDT slot 0\n");
+                asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)0x7));
+        } else {
+                /* No modify_ldt for us (configured out, perhaps) */
+
+                struct user_desc *low_desc = mmap(
+                        NULL, sizeof(desc),
+                        PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT, -1, 0);
+                memcpy(low_desc, &desc, sizeof(desc));
+
+                low_desc->entry_number = -1;
+
+                /* 32-bit set_thread_area */
+                long ret;
+                asm volatile ("int $0x80"
+                              : "=a" (ret) : "a" (243), "b" (low_desc)
+                              : "flags");
+                memcpy(&desc, low_desc, sizeof(desc));
+                munmap(low_desc, sizeof(desc));
+
+                if (ret != 0) {
+                        printf("[NOTE]\tcould not create a segment -- test won't do anything\n");
+                        return;
+                }
+                printf("\tother thread: using GDT slot %d\n", desc.entry_number);
+                asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)((desc.entry_number << 3) | 0x3)));
+        }
+
+        /*
+         * Step 3: set the selector back to zero.  On AMD chips, this will
+         * preserve GSBASE.
+         */
+
+        asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)0));
+}
+
+static void *threadproc(void *ctx)
+{
+        while (1) {
+                while (ftx == 0)
+                        syscall(SYS_futex, &ftx, FUTEX_WAIT, 0, NULL, NULL, 0);
+                if (ftx == 3)
+                        return NULL;
+
+                if (ftx == 1)
+                        do_remote_base();
+                else if (ftx == 2)
+                        do_unexpected_base();
+                else
+                        errx(1, "helper thread got bad command");
+
+                ftx = 0;
+                syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
+        }
+}
+
+static void set_gs_and_switch_to(unsigned long local, unsigned long remote)
+{
+        unsigned long base;
+
+        bool hard_zero = false;
+        if (local == HARD_ZERO) {
+                hard_zero = true;
+                local = 0;
+        }
+
+        printf("[RUN]\tARCH_SET_GS(0x%lx)%s, then schedule to 0x%lx\n",
+               local, hard_zero ? " and clear gs" : "", remote);
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, local) != 0)
+                err(1, "ARCH_SET_GS");
+        if (hard_zero)
+                asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)0));
+
+        if (read_base(GS) != local) {
+                nerrs++;
+                printf("[FAIL]\tGSBASE wasn't set as expected\n");
+        }
+
+        remote_base = remote;
+        ftx = 1;
+        syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
+        while (ftx != 0)
+                syscall(SYS_futex, &ftx, FUTEX_WAIT, 1, NULL, NULL, 0);
+
+        base = read_base(GS);
+        if (base == local) {
+                printf("[OK]\tGSBASE remained 0x%lx\n", local);
+        } else {
+                nerrs++;
+                printf("[FAIL]\tGSBASE changed to 0x%lx\n", base);
+        }
+}
+
+static void test_unexpected_base(void)
+{
+        unsigned long base;
+
+        printf("[RUN]\tARCH_SET_GS(0), clear gs, then manipulate GSBASE in a different thread\n");
+        if (syscall(SYS_arch_prctl, ARCH_SET_GS, 0) != 0)
+                err(1, "ARCH_SET_GS");
+        asm volatile ("mov %0, %%gs" : : "rm" ((unsigned short)0));
+
+        ftx = 2;
+        syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
+        while (ftx != 0)
+                syscall(SYS_futex, &ftx, FUTEX_WAIT, 1, NULL, NULL, 0);
+
+        base = read_base(GS);
+        if (base == 0) {
+                printf("[OK]\tGSBASE remained 0\n");
+        } else {
+                nerrs++;
+                printf("[FAIL]\tGSBASE changed to 0x%lx\n", base);
+        }
+}
+
+int main()
+{
+        pthread_t thread;
+
+        sethandler(SIGSEGV, sigsegv, 0);
+
+        check_gs_value(0);
+        check_gs_value(1);
+        check_gs_value(0x200000000);
+        check_gs_value(0);
+        check_gs_value(0x200000000);
+        check_gs_value(1);
+
+        for (int sched = 0; sched < 2; sched++) {
+                mov_0_gs(0, !!sched);
+                mov_0_gs(1, !!sched);
+                mov_0_gs(0x200000000, !!sched);
+        }
+
+        /* Set up for multithreading. */
+
+        cpu_set_t cpuset;
+        CPU_ZERO(&cpuset);
+        CPU_SET(0, &cpuset);
+        if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0)
+                err(1, "sched_setaffinity to CPU 0");   /* should never fail */
+
+        if (pthread_create(&thread, 0, threadproc, 0) != 0)
+                err(1, "pthread_create");
+
+        static unsigned long bases_with_hard_zero[] = {
+                0, HARD_ZERO, 1, 0x200000000,
+        };
+
+        for (int local = 0; local < 4; local++) {
+                for (int remote = 0; remote < 4; remote++) {
+                        set_gs_and_switch_to(bases_with_hard_zero[local],
+                                             bases_with_hard_zero[remote]);
+                }
+        }
+
+        test_unexpected_base();
+
+        ftx = 3;  /* Kill the thread. */
+        syscall(SYS_futex, &ftx, FUTEX_WAKE, 0, NULL, NULL, 0);
+
+        if (pthread_join(thread, NULL) != 0)
+                err(1, "pthread_join");
+
+        return nerrs == 0 ? 0 : 1;
+}
diff --git a/tools/testing/selftests/x86/ldt_gdt.c b/tools/testing/selftests/x86/ldt_gdt.c
index 31a3035cd4eb..4af47079cf04 100644
--- a/tools/testing/selftests/x86/ldt_gdt.c
+++ b/tools/testing/selftests/x86/ldt_gdt.c
@@ -21,6 +21,9 @@
 #include <pthread.h>
 #include <sched.h>
 #include <linux/futex.h>
+#include <sys/mman.h>
+#include <asm/prctl.h>
+#include <sys/prctl.h>
 
 #define AR_ACCESSED             (1<<8)
 
@@ -44,6 +47,12 @@
 
 static int nerrs;
 
+/* Points to an array of 1024 ints, each holding its own index. */
+static const unsigned int *counter_page;
+static struct user_desc *low_user_desc;
+static struct user_desc *low_user_desc_clear;  /* Use to delete GDT entry */
+static int gdt_entry_num;
+
 static void check_invalid_segment(uint16_t index, int ldt)
 {
         uint32_t has_limit = 0, has_ar = 0, limit, ar;
@@ -561,16 +570,257 @@ static void do_exec_test(void)
         }
 }
 
+static void setup_counter_page(void)
+{
+        unsigned int *page = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
+                         MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT, -1, 0);
+        if (page == MAP_FAILED)
+                err(1, "mmap");
+
+        for (int i = 0; i < 1024; i++)
+                page[i] = i;
+        counter_page = page;
+}
+
+static int invoke_set_thread_area(void)
+{
+        int ret;
+        asm volatile ("int $0x80"
+                      : "=a" (ret), "+m" (low_user_desc) :
+                        "a" (243), "b" (low_user_desc)
+                      : "flags");
+        return ret;
+}
+
+static void setup_low_user_desc(void)
+{
+        low_user_desc = mmap(NULL, 2 * sizeof(struct user_desc),
+                             PROT_READ | PROT_WRITE,
+                             MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT, -1, 0);
+        if (low_user_desc == MAP_FAILED)
+                err(1, "mmap");
+
+        low_user_desc->entry_number     = -1;
+        low_user_desc->base_addr        = (unsigned long)&counter_page[1];
+        low_user_desc->limit            = 0xfffff;
+        low_user_desc->seg_32bit        = 1;
+        low_user_desc->contents         = 0; /* Data, grow-up*/
+        low_user_desc->read_exec_only   = 0;
+        low_user_desc->limit_in_pages   = 1;
+        low_user_desc->seg_not_present  = 0;
+        low_user_desc->useable          = 0;
+
+        if (invoke_set_thread_area() == 0) {
+                gdt_entry_num = low_user_desc->entry_number;
+                printf("[NOTE]\tset_thread_area is available; will use GDT index %d\n", gdt_entry_num);
+        } else {
+                printf("[NOTE]\tset_thread_area is unavailable\n");
+        }
+
+        low_user_desc_clear = low_user_desc + 1;
+        low_user_desc_clear->entry_number = gdt_entry_num;
+        low_user_desc_clear->read_exec_only = 1;
+        low_user_desc_clear->seg_not_present = 1;
+}
+
+static void test_gdt_invalidation(void)
+{
+        if (!gdt_entry_num)
+                return; /* 64-bit only system -- we can't use set_thread_area */
+
+        unsigned short prev_sel;
+        unsigned short sel;
+        unsigned int eax;
+        const char *result;
+#ifdef __x86_64__
+        unsigned long saved_base;
+        unsigned long new_base;
+#endif
+
+        /* Test DS */
+        invoke_set_thread_area();
+        eax = 243;
+        sel = (gdt_entry_num << 3) | 3;
+        asm volatile ("movw %%ds, %[prev_sel]\n\t"
+                      "movw %[sel], %%ds\n\t"
+#ifdef __i386__
+                      "pushl %%ebx\n\t"
+#endif
+                      "movl %[arg1], %%ebx\n\t"
+                      "int $0x80\n\t"   /* Should invalidate ds */
+#ifdef __i386__
+                      "popl %%ebx\n\t"
+#endif
+                      "movw %%ds, %[sel]\n\t"
+                      "movw %[prev_sel], %%ds"
+                      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
+                        "+a" (eax)
+                      : "m" (low_user_desc_clear),
+                        [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
+                      : "flags");
+
+        if (sel != 0) {
+                result = "FAIL";
+                nerrs++;
+        } else {
+                result = "OK";
+        }
+        printf("[%s]\tInvalidate DS with set_thread_area: new DS = 0x%hx\n",
+               result, sel);
+
+        /* Test ES */
+        invoke_set_thread_area();
+        eax = 243;
+        sel = (gdt_entry_num << 3) | 3;
+        asm volatile ("movw %%es, %[prev_sel]\n\t"
+                      "movw %[sel], %%es\n\t"
+#ifdef __i386__
+                      "pushl %%ebx\n\t"
+#endif
+                      "movl %[arg1], %%ebx\n\t"
+                      "int $0x80\n\t"   /* Should invalidate es */
+#ifdef __i386__
+                      "popl %%ebx\n\t"
+#endif
+                      "movw %%es, %[sel]\n\t"
+                      "movw %[prev_sel], %%es"
+                      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
+                        "+a" (eax)
+                      : "m" (low_user_desc_clear),
+                        [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
+                      : "flags");
+
+        if (sel != 0) {
+                result = "FAIL";
+                nerrs++;
+        } else {
+                result = "OK";
+        }
+        printf("[%s]\tInvalidate ES with set_thread_area: new ES = 0x%hx\n",
+               result, sel);
+
+        /* Test FS */
+        invoke_set_thread_area();
+        eax = 243;
+        sel = (gdt_entry_num << 3) | 3;
+#ifdef __x86_64__
+        syscall(SYS_arch_prctl, ARCH_GET_FS, &saved_base);
+#endif
+        asm volatile ("movw %%fs, %[prev_sel]\n\t"
+                      "movw %[sel], %%fs\n\t"
+#ifdef __i386__
+                      "pushl %%ebx\n\t"
+#endif
+                      "movl %[arg1], %%ebx\n\t"
+                      "int $0x80\n\t"   /* Should invalidate fs */
+#ifdef __i386__
+                      "popl %%ebx\n\t"
+#endif
+                      "movw %%fs, %[sel]\n\t"
+                      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
+                        "+a" (eax)
+                      : "m" (low_user_desc_clear),
+                        [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
+                      : "flags");
+
+#ifdef __x86_64__
+        syscall(SYS_arch_prctl, ARCH_GET_FS, &new_base);
+#endif
+
+        /* Restore FS/BASE for glibc */
+        asm volatile ("movw %[prev_sel], %%fs" : : [prev_sel] "rm" (prev_sel));
+#ifdef __x86_64__
+        if (saved_base)
+                syscall(SYS_arch_prctl, ARCH_SET_FS, saved_base);
+#endif
+
+        if (sel != 0) {
+                result = "FAIL";
+                nerrs++;
+        } else {
+                result = "OK";
+        }
+        printf("[%s]\tInvalidate FS with set_thread_area: new FS = 0x%hx\n",
+               result, sel);
+
+#ifdef __x86_64__
+        if (sel == 0 && new_base != 0) {
+                nerrs++;
+                printf("[FAIL]\tNew FSBASE was 0x%lx\n", new_base);
+        } else {
+                printf("[OK]\tNew FSBASE was zero\n");
+        }
+#endif
+
+        /* Test GS */
+        invoke_set_thread_area();
+        eax = 243;
+        sel = (gdt_entry_num << 3) | 3;
+#ifdef __x86_64__
+        syscall(SYS_arch_prctl, ARCH_GET_GS, &saved_base);
+#endif
+        asm volatile ("movw %%gs, %[prev_sel]\n\t"
+                      "movw %[sel], %%gs\n\t"
+#ifdef __i386__
+                      "pushl %%ebx\n\t"
+#endif
+                      "movl %[arg1], %%ebx\n\t"
+                      "int $0x80\n\t"   /* Should invalidate gs */
+#ifdef __i386__
+                      "popl %%ebx\n\t"
+#endif
+                      "movw %%gs, %[sel]\n\t"
+                      : [prev_sel] "=&r" (prev_sel), [sel] "+r" (sel),
+                        "+a" (eax)
+                      : "m" (low_user_desc_clear),
+                        [arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
+                      : "flags");
+
+#ifdef __x86_64__
+        syscall(SYS_arch_prctl, ARCH_GET_GS, &new_base);
+#endif
+
+        /* Restore GS/BASE for glibc */
+        asm volatile ("movw %[prev_sel], %%gs" : : [prev_sel] "rm" (prev_sel));
+#ifdef __x86_64__
+        if (saved_base)
+                syscall(SYS_arch_prctl, ARCH_SET_GS, saved_base);
+#endif
+
+        if (sel != 0) {
+                result = "FAIL";
+                nerrs++;
+        } else {
+                result = "OK";
+        }
+        printf("[%s]\tInvalidate GS with set_thread_area: new GS = 0x%hx\n",
+               result, sel);
+
+#ifdef __x86_64__
+        if (sel == 0 && new_base != 0) {
+                nerrs++;
+                printf("[FAIL]\tNew GSBASE was 0x%lx\n", new_base);
+        } else {
+                printf("[OK]\tNew GSBASE was zero\n");
+        }
+#endif
+}
+
 int main(int argc, char **argv)
 {
         if (argc == 1 && !strcmp(argv[0], "ldt_gdt_test_exec"))
                 return finish_exec_test();
 
+        setup_counter_page();
+        setup_low_user_desc();
+
         do_simple_tests();
 
         do_multicpu_tests();
 
         do_exec_test();
 
+        test_gdt_invalidation();
+
         return nerrs ? 1 : 0;
 }