Merge tag 'powerpc-4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux

Pull powerpc updates from Michael Ellerman:
 "Notable changes:

   - A large series to rewrite our SLB miss handling, replacing a lot of
     fairly complicated asm with much fewer lines of C.

   - Following on from that, we now maintain a cache of SLB entries for
     each process and preload them on context switch. Leading to a 27%
     speedup for our context switch benchmark on Power9.

   - Improvements to our handling of SLB multi-hit errors. We now print
     more debug information when they occur, and try to continue running
     by flushing the SLB and reloading, rather than treating them as
     fatal.

   - Enable THP migration on 64-bit Book3S machines (eg. Power7/8/9).

   - Add support for physical memory up to 2PB in the linear mapping on
     64-bit Book3S. We only support up to 512TB as regular system
     memory, otherwise the percpu allocator runs out of vmalloc space.

   - Add stack protector support for 32 and 64-bit, with a per-task
     canary.

   - Add support for PTRACE_SYSEMU and PTRACE_SYSEMU_SINGLESTEP.

   - Support recognising "big cores" on Power9, where two SMT4 cores are
     presented to us as a single SMT8 core.

   - A large series to cleanup some of our ioremap handling and PTE
     flags.

   - Add a driver for the PAPR SCM (storage class memory) interface,
     allowing guests to operate on SCM devices (acked by Dan).

   - Changes to our ftrace code to handle very large kernels, where we
     need to use a trampoline to get to ftrace_caller().

  And many other smaller enhancements and cleanups.

  Thanks to: Alan Modra, Alistair Popple, Aneesh Kumar K.V, Anton
  Blanchard, Aravinda Prasad, Bartlomiej Zolnierkiewicz, Benjamin
  Herrenschmidt, Breno Leitao, Cédric Le Goater, Christophe Leroy,
  Christophe Lombard, Dan Carpenter, Daniel Axtens, Finn Thain, Gautham
  R. Shenoy, Gustavo Romero, Haren Myneni, Hari Bathini, Jia Hongtao,
  Joel Stanley, John Allen, Laurent Dufour, Madhavan Srinivasan, Mahesh
  Salgaonkar, Mark Hairgrove, Masahiro Yamada, Michael Bringmann,
  Michael Neuling, Michal Suchanek, Murilo Opsfelder Araujo, Nathan
  Fontenot, Naveen N. Rao, Nicholas Piggin, Nick Desaulniers, Oliver
  O'Halloran, Paul Mackerras, Petr Vorel, Rashmica Gupta, Reza Arbab,
  Rob Herring, Sam Bobroff, Samuel Mendoza-Jonas, Scott Wood, Stan
  Johnson, Stephen Rothwell, Stewart Smith, Suraj Jitindar Singh, Tyrel
  Datwyler, Vaibhav Jain, Vasant Hegde, YueHaibing, zhong jiang"

* tag 'powerpc-4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (221 commits)
  Revert "selftests/powerpc: Fix out-of-tree build errors"
  powerpc/msi: Fix compile error on mpc83xx
  powerpc: Fix stack protector crashes on CPU hotplug
  powerpc/traps: restore recoverability of machine_check interrupts
  powerpc/64/module: REL32 relocation range check
  powerpc/64s/radix: Fix radix__flush_tlb_collapsed_pmd double flushing pmd
  selftests/powerpc: Add a test of wild bctr
  powerpc/mm: Fix page table dump to work on Radix
  powerpc/mm/radix: Display if mappings are exec or not
  powerpc/mm/radix: Simplify split mapping logic
  powerpc/mm/radix: Remove the retry in the split mapping logic
  powerpc/mm/radix: Fix small page at boundary when splitting
  powerpc/mm/radix: Fix overuse of small pages in splitting logic
  powerpc/mm/radix: Fix off-by-one in split mapping logic
  powerpc/ftrace: Handle large kernel configs
  powerpc/mm: Fix WARN_ON with THP NUMA migration
  selftests/powerpc: Fix out-of-tree build errors
  powerpc/time: no steal_time when CONFIG_PPC_SPLPAR is not selected
  powerpc/time: Only set CONFIG_ARCH_HAS_SCALED_CPUTIME on PPC64
  powerpc/time: isolate scaled cputime accounting in dedicated functions.
  ...

15 files changed, 735 insertions, 25 deletions

diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 201b598558b9..b3ad909aefbc 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -28,7 +28,8 @@ SUB_DIRS = alignment		\
            tm                   \
            vphn         \
            math         \
-           ptrace
+           ptrace       \
+           security
 
 endif
 
diff --git a/tools/testing/selftests/powerpc/include/reg.h b/tools/testing/selftests/powerpc/include/reg.h
index 7f348c059bc2..52b4710469d2 100644
--- a/tools/testing/selftests/powerpc/include/reg.h
+++ b/tools/testing/selftests/powerpc/include/reg.h
@@ -17,6 +17,7 @@
                                     : "memory")
 
 #define mb()            asm volatile("sync" : : : "memory");
+#define barrier()       asm volatile("" : : : "memory");
 
 #define SPRN_MMCR2     769
 #define SPRN_MMCRA     770
diff --git a/tools/testing/selftests/powerpc/include/utils.h b/tools/testing/selftests/powerpc/include/utils.h
index c58c370828b4..49621822d7c3 100644
--- a/tools/testing/selftests/powerpc/include/utils.h
+++ b/tools/testing/selftests/powerpc/include/utils.h
@@ -11,6 +11,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <linux/auxvec.h>
+#include <linux/perf_event.h>
 #include "reg.h"
 
 /* Avoid headaches with PRI?64 - just use %ll? always */
@@ -31,6 +32,15 @@ void *get_auxv_entry(int type);
 
 int pick_online_cpu(void);
 
+int read_debugfs_file(char *debugfs_file, int *result);
+int write_debugfs_file(char *debugfs_file, int result);
+void set_dscr(unsigned long val);
+int perf_event_open_counter(unsigned int type,
+                            unsigned long config, int group_fd);
+int perf_event_enable(int fd);
+int perf_event_disable(int fd);
+int perf_event_reset(int fd);
+
 static inline bool have_hwcap(unsigned long ftr)
 {
         return ((unsigned long)get_auxv_entry(AT_HWCAP) & ftr) == ftr;
@@ -80,4 +90,12 @@ do {								\
 #define PPC_FEATURE2_ARCH_3_00 0x00800000
 #endif
 
+#if defined(__powerpc64__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.gp_regs[PT_NIP]
+#elif defined(__powerpc__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.uc_regs->gregs[PT_NIP]
+#else
+#error implement UCONTEXT_NIA
+#endif
+
 #endif /* _SELFTESTS_POWERPC_UTILS_H */
diff --git a/tools/testing/selftests/powerpc/mm/.gitignore b/tools/testing/selftests/powerpc/mm/.gitignore
index 7d7c42ed6de9..ba919308fe30 100644
--- a/tools/testing/selftests/powerpc/mm/.gitignore
+++ b/tools/testing/selftests/powerpc/mm/.gitignore
@@ -2,4 +2,5 @@ hugetlb_vs_thp_test
 subpage_prot
 tempfile
 prot_sao
-segv_errors
\ No newline at end of file
+segv_errors
+wild_bctr
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/mm/Makefile b/tools/testing/selftests/powerpc/mm/Makefile
index 33ced6e0ad25..43d68420e363 100644
--- a/tools/testing/selftests/powerpc/mm/Makefile
+++ b/tools/testing/selftests/powerpc/mm/Makefile
@@ -2,7 +2,7 @@
 noarg:
         $(MAKE) -C ../
 
-TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors
+TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors wild_bctr
 TEST_GEN_FILES := tempfile
 
 top_srcdir = ../../../../..
@@ -12,6 +12,8 @@ $(TEST_GEN_PROGS): ../harness.c
 
 $(OUTPUT)/prot_sao: ../utils.c
 
+$(OUTPUT)/wild_bctr: CFLAGS += -m64
+
 $(OUTPUT)/tempfile:
         dd if=/dev/zero of=$@ bs=64k count=1
 
diff --git a/tools/testing/selftests/powerpc/mm/wild_bctr.c b/tools/testing/selftests/powerpc/mm/wild_bctr.c
new file mode 100644
index 000000000000..1b0e9e9a2ddc
--- /dev/null
+++ b/tools/testing/selftests/powerpc/mm/wild_bctr.c
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright 2018, Michael Ellerman, IBM Corp.
+ *
+ * Test that an out-of-bounds branch to counter behaves as expected.
+ */
+
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#include "utils.h"
+
+
+#define BAD_NIP 0x788c545a18000000ull
+
+static struct pt_regs signal_regs;
+static jmp_buf setjmp_env;
+
+static void save_regs(ucontext_t *ctxt)
+{
+        struct pt_regs *regs = ctxt->uc_mcontext.regs;
+
+        memcpy(&signal_regs, regs, sizeof(signal_regs));
+}
+
+static void segv_handler(int signum, siginfo_t *info, void *ctxt_v)
+{
+        save_regs(ctxt_v);
+        longjmp(setjmp_env, 1);
+}
+
+static void usr2_handler(int signum, siginfo_t *info, void *ctxt_v)
+{
+        save_regs(ctxt_v);
+}
+
+static int ok(void)
+{
+        printf("Everything is OK in here.\n");
+        return 0;
+}
+
+#define REG_POISON      0x5a5aUL
+#define POISONED_REG(n) ((REG_POISON << 48) | ((n) << 32) | (REG_POISON << 16) | (n))
+
+static inline void poison_regs(void)
+{
+        #define POISON_REG(n)   \
+          "lis  " __stringify(n) "," __stringify(REG_POISON) ";" \
+          "addi " __stringify(n) "," __stringify(n) "," __stringify(n) ";" \
+          "sldi " __stringify(n) "," __stringify(n) ", 32 ;" \
+          "oris " __stringify(n) "," __stringify(n) "," __stringify(REG_POISON) ";" \
+          "addi " __stringify(n) "," __stringify(n) "," __stringify(n) ";"
+
+        asm (POISON_REG(15)
+             POISON_REG(16)
+             POISON_REG(17)
+             POISON_REG(18)
+             POISON_REG(19)
+             POISON_REG(20)
+             POISON_REG(21)
+             POISON_REG(22)
+             POISON_REG(23)
+             POISON_REG(24)
+             POISON_REG(25)
+             POISON_REG(26)
+             POISON_REG(27)
+             POISON_REG(28)
+             POISON_REG(29)
+             : // inputs
+             : // outputs
+             : "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25",
+               "26", "27", "28", "29"
+        );
+        #undef POISON_REG
+}
+
+static int check_regs(void)
+{
+        unsigned long i;
+
+        for (i = 15; i <= 29; i++)
+                FAIL_IF(signal_regs.gpr[i] != POISONED_REG(i));
+
+        printf("Regs OK\n");
+        return 0;
+}
+
+static void dump_regs(void)
+{
+        for (int i = 0; i < 32; i += 4) {
+                printf("r%02d 0x%016lx  r%02d 0x%016lx  " \
+                       "r%02d 0x%016lx  r%02d 0x%016lx\n",
+                       i, signal_regs.gpr[i],
+                       i+1, signal_regs.gpr[i+1],
+                       i+2, signal_regs.gpr[i+2],
+                       i+3, signal_regs.gpr[i+3]);
+        }
+}
+
+int test_wild_bctr(void)
+{
+        int (*func_ptr)(void);
+        struct sigaction segv = {
+                .sa_sigaction = segv_handler,
+                .sa_flags = SA_SIGINFO
+        };
+        struct sigaction usr2 = {
+                .sa_sigaction = usr2_handler,
+                .sa_flags = SA_SIGINFO
+        };
+
+        FAIL_IF(sigaction(SIGSEGV, &segv, NULL));
+        FAIL_IF(sigaction(SIGUSR2, &usr2, NULL));
+
+        bzero(&signal_regs, sizeof(signal_regs));
+
+        if (setjmp(setjmp_env) == 0) {
+                func_ptr = ok;
+                func_ptr();
+
+                kill(getpid(), SIGUSR2);
+                printf("Regs before:\n");
+                dump_regs();
+                bzero(&signal_regs, sizeof(signal_regs));
+
+                poison_regs();
+
+                func_ptr = (int (*)(void))BAD_NIP;
+                func_ptr();
+
+                FAIL_IF(1); /* we didn't segv? */
+        }
+
+        FAIL_IF(signal_regs.nip != BAD_NIP);
+
+        printf("All good - took SEGV as expected branching to 0x%llx\n", BAD_NIP);
+
+        dump_regs();
+        FAIL_IF(check_regs());
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_wild_bctr, "wild_bctr");
+}
diff --git a/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
index ed3239bbfae2..ee1e9ca22f0d 100644
--- a/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
+++ b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
@@ -65,14 +65,6 @@ static int unprotect_region(void)
 extern char __start___ex_table[];
 extern char __stop___ex_table[];
 
-#if defined(__powerpc64__)
-#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.gp_regs[PT_NIP]
-#elif defined(__powerpc__)
-#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.uc_regs->gregs[PT_NIP]
-#else
-#error implement UCONTEXT_NIA
-#endif
-
 struct extbl_entry {
         int insn;
         int fixup;
diff --git a/tools/testing/selftests/powerpc/ptrace/Makefile b/tools/testing/selftests/powerpc/ptrace/Makefile
index 923d531265f8..9b35ca8e8f13 100644
--- a/tools/testing/selftests/powerpc/ptrace/Makefile
+++ b/tools/testing/selftests/powerpc/ptrace/Makefile
@@ -2,7 +2,7 @@
 TEST_PROGS := ptrace-gpr ptrace-tm-gpr ptrace-tm-spd-gpr \
               ptrace-tar ptrace-tm-tar ptrace-tm-spd-tar ptrace-vsx ptrace-tm-vsx \
               ptrace-tm-spd-vsx ptrace-tm-spr ptrace-hwbreak ptrace-pkey core-pkey \
-              perf-hwbreak
+              perf-hwbreak ptrace-syscall
 
 top_srcdir = ../../../../..
 include ../../lib.mk
diff --git a/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c b/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c
new file mode 100644
index 000000000000..3353210dcdbd
--- /dev/null
+++ b/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c
@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * A ptrace test for testing PTRACE_SYSEMU, PTRACE_SETREGS and
+ * PTRACE_GETREG.  This test basically create a child process that executes
+ * syscalls and the parent process check if it is being traced appropriated.
+ *
+ * This test is heavily based on tools/testing/selftests/x86/ptrace_syscall.c
+ * test, and it was adapted to run on Powerpc by
+ * Breno Leitao <leitao@debian.org>
+ */
+#define _GNU_SOURCE
+
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/syscall.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <err.h>
+#include <string.h>
+#include <sys/auxv.h>
+#include "utils.h"
+
+/* Bitness-agnostic defines for user_regs_struct fields. */
+#define user_syscall_nr gpr[0]
+#define user_arg0               gpr[3]
+#define user_arg1               gpr[4]
+#define user_arg2               gpr[5]
+#define user_arg3               gpr[6]
+#define user_arg4               gpr[7]
+#define user_arg5               gpr[8]
+#define user_ip         nip
+
+#define PTRACE_SYSEMU           0x1d
+
+static int nerrs;
+
+static void wait_trap(pid_t chld)
+{
+        siginfo_t si;
+
+        if (waitid(P_PID, chld, &si, WEXITED|WSTOPPED) != 0)
+                err(1, "waitid");
+        if (si.si_pid != chld)
+                errx(1, "got unexpected pid in event\n");
+        if (si.si_code != CLD_TRAPPED)
+                errx(1, "got unexpected event type %d\n", si.si_code);
+}
+
+static void test_ptrace_syscall_restart(void)
+{
+        int status;
+        struct pt_regs regs;
+        pid_t chld;
+
+        printf("[RUN]\tptrace-induced syscall restart\n");
+
+        chld = fork();
+        if (chld < 0)
+                err(1, "fork");
+
+        /*
+         * Child process is running 4 syscalls after ptrace.
+         *
+         * 1) getpid()
+         * 2) gettid()
+         * 3) tgkill() -> Send SIGSTOP
+         * 4) gettid() -> Where the tests will happen essentially
+         */
+        if (chld == 0) {
+                if (ptrace(PTRACE_TRACEME, 0, 0, 0) != 0)
+                        err(1, "PTRACE_TRACEME");
+
+                pid_t pid = getpid(), tid = syscall(SYS_gettid);
+
+                printf("\tChild will make one syscall\n");
+                syscall(SYS_tgkill, pid, tid, SIGSTOP);
+
+                syscall(SYS_gettid, 10, 11, 12, 13, 14, 15);
+                _exit(0);
+        }
+        /* Parent process below */
+
+        /* Wait for SIGSTOP sent by tgkill above. */
+        if (waitpid(chld, &status, 0) != chld || !WIFSTOPPED(status))
+                err(1, "waitpid");
+
+        printf("[RUN]\tSYSEMU\n");
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        /*
+         * Ptrace trapped prior to executing the syscall, thus r3 still has
+         * the syscall number instead of the sys_gettid() result
+         */
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tInitial args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                 nerrs++;
+        } else {
+                printf("[OK]\tInitial nr and args are correct\n"); }
+
+        printf("[RUN]\tRestart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        /*
+         * Rewind to retry the same syscall again. This will basically test
+         * the rewind process together with PTRACE_SETREGS and PTRACE_GETREGS.
+         */
+        regs.user_ip -= 4;
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tRestarted nr and args are correct\n");
+        }
+
+        printf("[RUN]\tChange nr and args and restart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        /*
+         * Inject a new syscall (getpid) in the same place the previous
+         * syscall (gettid), rewind and re-execute.
+         */
+        regs.user_syscall_nr = SYS_getpid;
+        regs.user_arg0 = 20;
+        regs.user_arg1 = 21;
+        regs.user_arg2 = 22;
+        regs.user_arg3 = 23;
+        regs.user_arg4 = 24;
+        regs.user_arg5 = 25;
+        regs.user_ip -= 4;
+
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        /* Check that ptrace stopped at the new syscall that was
+         * injected, and guarantee that it haven't executed, i.e, user_args
+         * contain the arguments and not the syscall return value, for
+         * instance.
+         */
+        if (regs.user_syscall_nr != SYS_getpid
+                || regs.user_arg0 != 20 || regs.user_arg1 != 21
+                || regs.user_arg2 != 22 || regs.user_arg3 != 23
+                || regs.user_arg4 != 24 || regs.user_arg5 != 25) {
+
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tReplacement nr and args are correct\n");
+        }
+
+        if (ptrace(PTRACE_CONT, chld, 0, 0) != 0)
+                err(1, "PTRACE_CONT");
+
+        if (waitpid(chld, &status, 0) != chld)
+                err(1, "waitpid");
+
+        /* Guarantee that the process executed properly, returning 0 */
+        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+                printf("[FAIL]\tChild failed\n");
+                nerrs++;
+        } else {
+                printf("[OK]\tChild exited cleanly\n");
+        }
+}
+
+int ptrace_syscall(void)
+{
+        test_ptrace_syscall_restart();
+
+        return nerrs;
+}
+
+int main(void)
+{
+        return test_harness(ptrace_syscall, "ptrace_syscall");
+}
diff --git a/tools/testing/selftests/powerpc/security/Makefile b/tools/testing/selftests/powerpc/security/Makefile
new file mode 100644
index 000000000000..44690f1bb26a
--- /dev/null
+++ b/tools/testing/selftests/powerpc/security/Makefile
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0+
+
+TEST_GEN_PROGS := rfi_flush
+
+CFLAGS += -I../../../../../usr/include
+
+include ../../lib.mk
+
+$(TEST_GEN_PROGS): ../harness.c ../utils.c
diff --git a/tools/testing/selftests/powerpc/security/rfi_flush.c b/tools/testing/selftests/powerpc/security/rfi_flush.c
new file mode 100644
index 000000000000..564ed45bbf73
--- /dev/null
+++ b/tools/testing/selftests/powerpc/security/rfi_flush.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/*
+ * Copyright 2018 IBM Corporation.
+ */
+
+#define __SANE_USERSPACE_TYPES__
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <malloc.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "utils.h"
+
+#define CACHELINE_SIZE 128
+
+struct perf_event_read {
+        __u64 nr;
+        __u64 l1d_misses;
+};
+
+static inline __u64 load(void *addr)
+{
+        __u64 tmp;
+
+        asm volatile("ld %0,0(%1)" : "=r"(tmp) : "b"(addr));
+
+        return tmp;
+}
+
+static void syscall_loop(char *p, unsigned long iterations,
+                         unsigned long zero_size)
+{
+        for (unsigned long i = 0; i < iterations; i++) {
+                for (unsigned long j = 0; j < zero_size; j += CACHELINE_SIZE)
+                        load(p + j);
+                getppid();
+        }
+}
+
+int rfi_flush_test(void)
+{
+        char *p;
+        int repetitions = 10;
+        int fd, passes = 0, iter, rc = 0;
+        struct perf_event_read v;
+        __u64 l1d_misses_total = 0;
+        unsigned long iterations = 100000, zero_size = 24 * 1024;
+        int rfi_flush_org, rfi_flush;
+
+        SKIP_IF(geteuid() != 0);
+
+        if (read_debugfs_file("powerpc/rfi_flush", &rfi_flush_org)) {
+                perror("Unable to read powerpc/rfi_flush debugfs file");
+                SKIP_IF(1);
+        }
+
+        rfi_flush = rfi_flush_org;
+
+        fd = perf_event_open_counter(PERF_TYPE_RAW, /* L1d miss */ 0x400f0, -1);
+        FAIL_IF(fd < 0);
+
+        p = (char *)memalign(zero_size, CACHELINE_SIZE);
+
+        FAIL_IF(perf_event_enable(fd));
+
+        set_dscr(1);
+
+        iter = repetitions;
+
+again:
+        FAIL_IF(perf_event_reset(fd));
+
+        syscall_loop(p, iterations, zero_size);
+
+        FAIL_IF(read(fd, &v, sizeof(v)) != sizeof(v));
+
+        /* Expect at least zero_size/CACHELINE_SIZE misses per iteration */
+        if (v.l1d_misses >= (iterations * zero_size / CACHELINE_SIZE) && rfi_flush)
+                passes++;
+        else if (v.l1d_misses < iterations && !rfi_flush)
+                passes++;
+
+        l1d_misses_total += v.l1d_misses;
+
+        while (--iter)
+                goto again;
+
+        if (passes < repetitions) {
+                printf("FAIL (L1D misses with rfi_flush=%d: %llu %c %lu) [%d/%d failures]\n",
+                       rfi_flush, l1d_misses_total, rfi_flush ? '<' : '>',
+                       rfi_flush ? (repetitions * iterations * zero_size / CACHELINE_SIZE) : iterations,
+                       repetitions - passes, repetitions);
+                rc = 1;
+        } else
+                printf("PASS (L1D misses with rfi_flush=%d: %llu %c %lu) [%d/%d pass]\n",
+                       rfi_flush, l1d_misses_total, rfi_flush ? '>' : '<',
+                       rfi_flush ? (repetitions * iterations * zero_size / CACHELINE_SIZE) : iterations,
+                       passes, repetitions);
+
+        if (rfi_flush == rfi_flush_org) {
+                rfi_flush = !rfi_flush_org;
+                if (write_debugfs_file("powerpc/rfi_flush", rfi_flush) < 0) {
+                        perror("error writing to powerpc/rfi_flush debugfs file");
+                        return 1;
+                }
+                iter = repetitions;
+                l1d_misses_total = 0;
+                passes = 0;
+                goto again;
+        }
+
+        perf_event_disable(fd);
+        close(fd);
+
+        set_dscr(0);
+
+        if (write_debugfs_file("powerpc/rfi_flush", rfi_flush_org) < 0) {
+                perror("unable to restore original value of powerpc/rfi_flush debugfs file");
+                return 1;
+        }
+
+        return rc;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(rfi_flush_test, "rfi_flush_test");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-tmspr.c b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
index 2bda81c7bf23..df1d7d4b1c89 100644
--- a/tools/testing/selftests/powerpc/tm/tm-tmspr.c
+++ b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
@@ -98,7 +98,7 @@ void texasr(void *in)
 
 int test_tmspr()
 {
-        pthread_t       thread;
+        pthread_t       *thread;
         int             thread_num;
         unsigned long   i;
 
@@ -107,21 +107,28 @@ int test_tmspr()
         /* To cause some context switching */
         thread_num = 10 * sysconf(_SC_NPROCESSORS_ONLN);
 
+        thread = malloc(thread_num * sizeof(pthread_t));
+        if (thread == NULL)
+                return EXIT_FAILURE;
+
         /* Test TFIAR and TFHAR */
-        for (i = 0 ; i < thread_num ; i += 2){
-                if (pthread_create(&thread, NULL, (void*)tfiar_tfhar, (void *)i))
+        for (i = 0; i < thread_num; i += 2) {
+                if (pthread_create(&thread[i], NULL, (void *)tfiar_tfhar,
+                                   (void *)i))
                         return EXIT_FAILURE;
         }
-        if (pthread_join(thread, NULL) != 0)
-                return EXIT_FAILURE;
-
         /* Test TEXASR */
-        for (i = 0 ; i < thread_num ; i++){
-                if (pthread_create(&thread, NULL, (void*)texasr, (void *)i))
+        for (i = 1; i < thread_num; i += 2) {
+                if (pthread_create(&thread[i], NULL, (void *)texasr, (void *)i))
                         return EXIT_FAILURE;
         }
-        if (pthread_join(thread, NULL) != 0)
-                return EXIT_FAILURE;
+
+        for (i = 0; i < thread_num; i++) {
+                if (pthread_join(thread[i], NULL) != 0)
+                        return EXIT_FAILURE;
+        }
+
+        free(thread);
 
         if (passed)
                 return 0;
diff --git a/tools/testing/selftests/powerpc/tm/tm-unavailable.c b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
index 156c8e750259..09894f4ff62e 100644
--- a/tools/testing/selftests/powerpc/tm/tm-unavailable.c
+++ b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
@@ -236,7 +236,8 @@ void *tm_una_ping(void *input)
         }
 
         /* Check if we were not expecting a failure and a it occurred. */
-        if (!expecting_failure() && is_failure(cr_)) {
+        if (!expecting_failure() && is_failure(cr_) &&
+            !failure_is_reschedule()) {
                 printf("\n\tUnexpected transaction failure 0x%02lx\n\t",
                         failure_code());
                 return (void *) -1;
@@ -244,9 +245,11 @@ void *tm_una_ping(void *input)
 
         /*
          * Check if TM failed due to the cause we were expecting. 0xda is a
-         * TM_CAUSE_FAC_UNAV cause, otherwise it's an unexpected cause.
+         * TM_CAUSE_FAC_UNAV cause, otherwise it's an unexpected cause, unless
+         * it was caused by a reschedule.
          */
-        if (is_failure(cr_) && !failure_is_unavailable()) {
+        if (is_failure(cr_) && !failure_is_unavailable() &&
+            !failure_is_reschedule()) {
                 printf("\n\tUnexpected failure cause 0x%02lx\n\t",
                         failure_code());
                 return (void *) -1;
diff --git a/tools/testing/selftests/powerpc/tm/tm.h b/tools/testing/selftests/powerpc/tm/tm.h
index df4204247d45..5518b1d4ef8b 100644
--- a/tools/testing/selftests/powerpc/tm/tm.h
+++ b/tools/testing/selftests/powerpc/tm/tm.h
@@ -52,6 +52,15 @@ static inline bool failure_is_unavailable(void)
         return (failure_code() & TM_CAUSE_FAC_UNAV) == TM_CAUSE_FAC_UNAV;
 }
 
+static inline bool failure_is_reschedule(void)
+{
+        if ((failure_code() & TM_CAUSE_RESCHED) == TM_CAUSE_RESCHED ||
+            (failure_code() & TM_CAUSE_KVM_RESCHED) == TM_CAUSE_KVM_RESCHED)
+                return true;
+
+        return false;
+}
+
 static inline bool failure_is_nesting(void)
 {
         return (__builtin_get_texasru() & 0x400000);
diff --git a/tools/testing/selftests/powerpc/utils.c b/tools/testing/selftests/powerpc/utils.c
index aa8fc1e6365b..43c342845be0 100644
--- a/tools/testing/selftests/powerpc/utils.c
+++ b/tools/testing/selftests/powerpc/utils.c
@@ -10,16 +10,22 @@
 #include <fcntl.h>
 #include <link.h>
 #include <sched.h>
+#include <signal.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
+#include <asm/unistd.h>
+#include <linux/limits.h>
 
 #include "utils.h"
 
 static char auxv[4096];
+extern unsigned int dscr_insn[];
 
 int read_auxv(char *buf, ssize_t buf_size)
 {
@@ -121,3 +127,149 @@ bool is_ppc64le(void)
 
         return strcmp(uts.machine, "ppc64le") == 0;
 }
+
+int read_debugfs_file(char *debugfs_file, int *result)
+{
+        int rc = -1, fd;
+        char path[PATH_MAX];
+        char value[16];
+
+        strcpy(path, "/sys/kernel/debug/");
+        strncat(path, debugfs_file, PATH_MAX - strlen(path) - 1);
+
+        if ((fd = open(path, O_RDONLY)) < 0)
+                return rc;
+
+        if ((rc = read(fd, value, sizeof(value))) < 0)
+                return rc;
+
+        value[15] = 0;
+        *result = atoi(value);
+        close(fd);
+
+        return 0;
+}
+
+int write_debugfs_file(char *debugfs_file, int result)
+{
+        int rc = -1, fd;
+        char path[PATH_MAX];
+        char value[16];
+
+        strcpy(path, "/sys/kernel/debug/");
+        strncat(path, debugfs_file, PATH_MAX - strlen(path) - 1);
+
+        if ((fd = open(path, O_WRONLY)) < 0)
+                return rc;
+
+        snprintf(value, 16, "%d", result);
+
+        if ((rc = write(fd, value, strlen(value))) < 0)
+                return rc;
+
+        close(fd);
+
+        return 0;
+}
+
+static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
+                int cpu, int group_fd, unsigned long flags)
+{
+        return syscall(__NR_perf_event_open, hw_event, pid, cpu,
+                      group_fd, flags);
+}
+
+static void perf_event_attr_init(struct perf_event_attr *event_attr,
+                                        unsigned int type,
+                                        unsigned long config)
+{
+        memset(event_attr, 0, sizeof(*event_attr));
+
+        event_attr->type = type;
+        event_attr->size = sizeof(struct perf_event_attr);
+        event_attr->config = config;
+        event_attr->read_format = PERF_FORMAT_GROUP;
+        event_attr->disabled = 1;
+        event_attr->exclude_kernel = 1;
+        event_attr->exclude_hv = 1;
+        event_attr->exclude_guest = 1;
+}
+
+int perf_event_open_counter(unsigned int type,
+                            unsigned long config, int group_fd)
+{
+        int fd;
+        struct perf_event_attr event_attr;
+
+        perf_event_attr_init(&event_attr, type, config);
+
+        fd = perf_event_open(&event_attr, 0, -1, group_fd, 0);
+
+        if (fd < 0)
+                perror("perf_event_open() failed");
+
+        return fd;
+}
+
+int perf_event_enable(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error while enabling perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+int perf_event_disable(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error disabling perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+int perf_event_reset(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error resetting perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+static void sigill_handler(int signr, siginfo_t *info, void *unused)
+{
+        static int warned = 0;
+        ucontext_t *ctx = (ucontext_t *)unused;
+        unsigned long *pc = &UCONTEXT_NIA(ctx);
+
+        if (*pc == (unsigned long)&dscr_insn) {
+                if (!warned++)
+                        printf("WARNING: Skipping over dscr setup. Consider running 'ppc64_cpu --dscr=1' manually.\n");
+                *pc += 4;
+        } else {
+                printf("SIGILL at %p\n", pc);
+                abort();
+        }
+}
+
+void set_dscr(unsigned long val)
+{
+        static int init = 0;
+        struct sigaction sa;
+
+        if (!init) {
+                memset(&sa, 0, sizeof(sa));
+                sa.sa_sigaction = sigill_handler;
+                sa.sa_flags = SA_SIGINFO;
+                if (sigaction(SIGILL, &sa, NULL))
+                        perror("sigill_handler");
+                init = 1;
+        }
+
+        asm volatile("dscr_insn: mtspr %1,%0" : : "r" (val), "i" (SPRN_DSCR));
+}