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

Pull powerpc updates from Michael Ellerman:
 "Notable changes:

   - Support for 4PB user address space on 64-bit, opt-in via mmap().

   - Removal of POWER4 support, which was accidentally broken in 2016
     and no one noticed, and blocked use of some modern instructions.

   - Workarounds so that the hypervisor can enable Transactional Memory
     on Power9.

   - A series to disable the DAWR (Data Address Watchpoint Register) on
     Power9.

   - More information displayed in the meltdown/spectre_v1/v2 sysfs
     files.

   - A vpermxor (Power8 Altivec) implementation for the raid6 Q
     Syndrome.

   - A big series to make the allocation of our pacas (per cpu area),
     kernel page tables, and per-cpu stacks NUMA aware when using the
     Radix MMU on Power9.

  And as usual many fixes, reworks and cleanups.

  Thanks to: Aaro Koskinen, Alexandre Belloni, Alexey Kardashevskiy,
  Alistair Popple, Andy Shevchenko, Aneesh Kumar K.V, Anshuman Khandual,
  Balbir Singh, Benjamin Herrenschmidt, Christophe Leroy, Christophe
  Lombard, Cyril Bur, Daniel Axtens, Dave Young, Finn Thain, Frederic
  Barrat, Gustavo Romero, Horia Geantă, Jonathan Neuschäfer, Kees Cook,
  Larry Finger, Laurent Dufour, Laurent Vivier, Logan Gunthorpe,
  Madhavan Srinivasan, Mark Greer, Mark Hairgrove, Markus Elfring,
  Mathieu Malaterre, Matt Brown, Matt Evans, Mauricio Faria de Oliveira,
  Michael Neuling, Naveen N. Rao, Nicholas Piggin, Paul Mackerras,
  Philippe Bergheaud, Ram Pai, Rob Herring, Sam Bobroff, Segher
  Boessenkool, Simon Guo, Simon Horman, Stewart Smith, Sukadev
  Bhattiprolu, Suraj Jitindar Singh, Thiago Jung Bauermann, Vaibhav
  Jain, Vaidyanathan Srinivasan, Vasant Hegde, Wei Yongjun"

* tag 'powerpc-4.17-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (207 commits)
  powerpc/64s/idle: Fix restore of AMOR on POWER9 after deep sleep
  powerpc/64s: Fix POWER9 DD2.2 and above in cputable features
  powerpc/64s: Fix pkey support in dt_cpu_ftrs, add CPU_FTR_PKEY bit
  powerpc/64s: Fix dt_cpu_ftrs to have restore_cpu clear unwanted LPCR bits
  Revert "powerpc/64s/idle: POWER9 ESL=0 stop avoid save/restore overhead"
  powerpc: iomap.c: introduce io{read|write}64_{lo_hi|hi_lo}
  powerpc: io.h: move iomap.h include so that it can use readq/writeq defs
  cxl: Fix possible deadlock when processing page faults from cxllib
  powerpc/hw_breakpoint: Only disable hw breakpoint if cpu supports it
  powerpc/mm/radix: Update command line parsing for disable_radix
  powerpc/mm/radix: Parse disable_radix commandline correctly.
  powerpc/mm/hugetlb: initialize the pagetable cache correctly for hugetlb
  powerpc/mm/radix: Update pte fragment count from 16 to 256 on radix
  powerpc/mm/keys: Update documentation and remove unnecessary check
  powerpc/64s/idle: POWER9 ESL=0 stop avoid save/restore overhead
  powerpc/64s/idle: Consolidate power9_offline_stop()/power9_idle_stop()
  powerpc/powernv: Always stop secondaries before reboot/shutdown
  powerpc: hard disable irqs in smp_send_stop loop
  powerpc: use NMI IPI for smp_send_stop
  powerpc/powernv: Fix SMT4 forcing idle code
  ...

8 files changed, 457 insertions, 12 deletions

diff --git a/tools/testing/selftests/powerpc/benchmarks/.gitignore b/tools/testing/selftests/powerpc/benchmarks/.gitignore
index 04dc1e6ef2ce..9161679b1e1a 100644
--- a/tools/testing/selftests/powerpc/benchmarks/.gitignore
+++ b/tools/testing/selftests/powerpc/benchmarks/.gitignore
@@ -1,5 +1,7 @@
 gettimeofday
 context_switch
+fork
+exec_target
 mmap_bench
 futex_bench
 null_syscall
diff --git a/tools/testing/selftests/powerpc/benchmarks/Makefile b/tools/testing/selftests/powerpc/benchmarks/Makefile
index a35058e3766c..b4d7432a0ecd 100644
--- a/tools/testing/selftests/powerpc/benchmarks/Makefile
+++ b/tools/testing/selftests/powerpc/benchmarks/Makefile
@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0
-TEST_GEN_PROGS := gettimeofday context_switch mmap_bench futex_bench null_syscall
+TEST_GEN_PROGS := gettimeofday context_switch fork mmap_bench futex_bench null_syscall
+TEST_GEN_FILES := exec_target
 
 CFLAGS += -O2
 
@@ -10,3 +11,7 @@ $(TEST_GEN_PROGS): ../harness.c
 $(OUTPUT)/context_switch: ../utils.c
 $(OUTPUT)/context_switch: CFLAGS += -maltivec -mvsx -mabi=altivec
 $(OUTPUT)/context_switch: LDLIBS += -lpthread
+
+$(OUTPUT)/fork: LDLIBS += -lpthread
+
+$(OUTPUT)/exec_target: CFLAGS += -static -nostartfiles
diff --git a/tools/testing/selftests/powerpc/benchmarks/exec_target.c b/tools/testing/selftests/powerpc/benchmarks/exec_target.c
new file mode 100644
index 000000000000..3c9c144192be
--- /dev/null
+++ b/tools/testing/selftests/powerpc/benchmarks/exec_target.c
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/*
+ * Part of fork context switch microbenchmark.
+ *
+ * Copyright 2018, Anton Blanchard, IBM Corp.
+ */
+
+void _exit(int);
+void _start(void)
+{
+        _exit(0);
+}
diff --git a/tools/testing/selftests/powerpc/benchmarks/fork.c b/tools/testing/selftests/powerpc/benchmarks/fork.c
new file mode 100644
index 000000000000..d312e638cb37
--- /dev/null
+++ b/tools/testing/selftests/powerpc/benchmarks/fork.c
@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/*
+ * Context switch microbenchmark.
+ *
+ * Copyright 2018, Anton Blanchard, IBM Corp.
+ */
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <errno.h>
+#include <getopt.h>
+#include <limits.h>
+#include <linux/futex.h>
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/shm.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static unsigned int timeout = 30;
+
+static void set_cpu(int cpu)
+{
+        cpu_set_t cpuset;
+
+        if (cpu == -1)
+                return;
+
+        CPU_ZERO(&cpuset);
+        CPU_SET(cpu, &cpuset);
+
+        if (sched_setaffinity(0, sizeof(cpuset), &cpuset)) {
+                perror("sched_setaffinity");
+                exit(1);
+        }
+}
+
+static void start_process_on(void *(*fn)(void *), void *arg, int cpu)
+{
+        int pid;
+
+        pid = fork();
+        if (pid == -1) {
+                perror("fork");
+                exit(1);
+        }
+
+        if (pid)
+                return;
+
+        set_cpu(cpu);
+
+        fn(arg);
+
+        exit(0);
+}
+
+static int cpu;
+static int do_fork = 0;
+static int do_vfork = 0;
+static int do_exec = 0;
+static char *exec_file;
+static int exec_target = 0;
+static unsigned long iterations;
+static unsigned long iterations_prev;
+
+static void run_exec(void)
+{
+        char *const argv[] = { "./exec_target", NULL };
+
+        if (execve("./exec_target", argv, NULL) == -1) {
+                perror("execve");
+                exit(1);
+        }
+}
+
+static void bench_fork(void)
+{
+        while (1) {
+                pid_t pid = fork();
+                if (pid == -1) {
+                        perror("fork");
+                        exit(1);
+                }
+                if (pid == 0) {
+                        if (do_exec)
+                                run_exec();
+                        _exit(0);
+                }
+                pid = waitpid(pid, NULL, 0);
+                if (pid == -1) {
+                        perror("waitpid");
+                        exit(1);
+                }
+                iterations++;
+        }
+}
+
+static void bench_vfork(void)
+{
+        while (1) {
+                pid_t pid = vfork();
+                if (pid == -1) {
+                        perror("fork");
+                        exit(1);
+                }
+                if (pid == 0) {
+                        if (do_exec)
+                                run_exec();
+                        _exit(0);
+                }
+                pid = waitpid(pid, NULL, 0);
+                if (pid == -1) {
+                        perror("waitpid");
+                        exit(1);
+                }
+                iterations++;
+        }
+}
+
+static void *null_fn(void *arg)
+{
+        pthread_exit(NULL);
+}
+
+static void bench_thread(void)
+{
+        pthread_t tid;
+        cpu_set_t cpuset;
+        pthread_attr_t attr;
+        int rc;
+
+        rc = pthread_attr_init(&attr);
+        if (rc) {
+                errno = rc;
+                perror("pthread_attr_init");
+                exit(1);
+        }
+
+        if (cpu != -1) {
+                CPU_ZERO(&cpuset);
+                CPU_SET(cpu, &cpuset);
+
+                rc = pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset);
+                if (rc) {
+                        errno = rc;
+                        perror("pthread_attr_setaffinity_np");
+                        exit(1);
+                }
+        }
+
+        while (1) {
+                rc = pthread_create(&tid, &attr, null_fn, NULL);
+                if (rc) {
+                        errno = rc;
+                        perror("pthread_create");
+                        exit(1);
+                }
+                rc = pthread_join(tid, NULL);
+                if (rc) {
+                        errno = rc;
+                        perror("pthread_join");
+                        exit(1);
+                }
+                iterations++;
+        }
+}
+
+static void sigalrm_handler(int junk)
+{
+        unsigned long i = iterations;
+
+        printf("%ld\n", i - iterations_prev);
+        iterations_prev = i;
+
+        if (--timeout == 0)
+                kill(0, SIGUSR1);
+
+        alarm(1);
+}
+
+static void sigusr1_handler(int junk)
+{
+        exit(0);
+}
+
+static void *bench_proc(void *arg)
+{
+        signal(SIGALRM, sigalrm_handler);
+        alarm(1);
+
+        if (do_fork)
+                bench_fork();
+        else if (do_vfork)
+                bench_vfork();
+        else
+                bench_thread();
+
+        return NULL;
+}
+
+static struct option options[] = {
+        { "fork", no_argument, &do_fork, 1 },
+        { "vfork", no_argument, &do_vfork, 1 },
+        { "exec", no_argument, &do_exec, 1 },
+        { "timeout", required_argument, 0, 's' },
+        { "exec-target", no_argument, &exec_target, 1 },
+        { NULL },
+};
+
+static void usage(void)
+{
+        fprintf(stderr, "Usage: fork <options> CPU\n\n");
+        fprintf(stderr, "\t\t--fork\tUse fork() (default threads)\n");
+        fprintf(stderr, "\t\t--vfork\tUse vfork() (default threads)\n");
+        fprintf(stderr, "\t\t--exec\tAlso exec() (default no exec)\n");
+        fprintf(stderr, "\t\t--timeout=X\tDuration in seconds to run (default 30)\n");
+        fprintf(stderr, "\t\t--exec-target\tInternal option for exec workload\n");
+}
+
+int main(int argc, char *argv[])
+{
+        signed char c;
+
+        while (1) {
+                int option_index = 0;
+
+                c = getopt_long(argc, argv, "", options, &option_index);
+
+                if (c == -1)
+                        break;
+
+                switch (c) {
+                case 0:
+                        if (options[option_index].flag != 0)
+                                break;
+
+                        usage();
+                        exit(1);
+                        break;
+
+                case 's':
+                        timeout = atoi(optarg);
+                        break;
+
+                default:
+                        usage();
+                        exit(1);
+                }
+        }
+
+        if (do_fork && do_vfork) {
+                usage();
+                exit(1);
+        }
+        if (do_exec && !do_fork && !do_vfork) {
+                usage();
+                exit(1);
+        }
+
+        if (do_exec) {
+                char *dirname = strdup(argv[0]);
+                int i;
+                i = strlen(dirname) - 1;
+                while (i) {
+                        if (dirname[i] == '/') {
+                                dirname[i] = '\0';
+                                if (chdir(dirname) == -1) {
+                                        perror("chdir");
+                                        exit(1);
+                                }
+                                break;
+                        }
+                        i--;
+                }
+        }
+
+        if (exec_target) {
+                exit(0);
+        }
+
+        if (((argc - optind) != 1)) {
+                cpu = -1;
+        } else {
+                cpu = atoi(argv[optind++]);
+        }
+
+        if (do_exec)
+                exec_file = argv[0];
+
+        set_cpu(cpu);
+
+        printf("Using ");
+        if (do_fork)
+                printf("fork");
+        else if (do_vfork)
+                printf("vfork");
+        else
+                printf("clone");
+
+        if (do_exec)
+                printf(" + exec");
+
+        printf(" on cpu %d\n", cpu);
+
+        /* Create a new process group so we can signal everyone for exit */
+        setpgid(getpid(), getpid());
+
+        signal(SIGUSR1, sigusr1_handler);
+
+        start_process_on(bench_proc, NULL, cpu);
+
+        while (1)
+                sleep(3600);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/powerpc/copyloops/Makefile b/tools/testing/selftests/powerpc/copyloops/Makefile
index ac4a52e19e59..eedce3366f64 100644
--- a/tools/testing/selftests/powerpc/copyloops/Makefile
+++ b/tools/testing/selftests/powerpc/copyloops/Makefile
@@ -5,8 +5,8 @@ CFLAGS += -I$(CURDIR)
 CFLAGS += -D SELFTEST
 CFLAGS += -maltivec
 
-# Use our CFLAGS for the implicit .S rule
-ASFLAGS = $(CFLAGS)
+# Use our CFLAGS for the implicit .S rule & set the asm machine type
+ASFLAGS = $(CFLAGS) -Wa,-mpower4
 
 TEST_GEN_PROGS := copyuser_64 copyuser_power7 memcpy_64 memcpy_power7
 EXTRA_SOURCES := validate.c ../harness.c
diff --git a/tools/testing/selftests/powerpc/tm/Makefile b/tools/testing/selftests/powerpc/tm/Makefile
index 5c72ff978f27..c0e45d2dde25 100644
--- a/tools/testing/selftests/powerpc/tm/Makefile
+++ b/tools/testing/selftests/powerpc/tm/Makefile
@@ -4,7 +4,7 @@ SIGNAL_CONTEXT_CHK_TESTS := tm-signal-context-chk-gpr tm-signal-context-chk-fpu
 
 TEST_GEN_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack \
         tm-vmxcopy tm-fork tm-tar tm-tmspr tm-vmx-unavail tm-unavailable tm-trap \
-        $(SIGNAL_CONTEXT_CHK_TESTS)
+        $(SIGNAL_CONTEXT_CHK_TESTS) tm-sigreturn
 
 include ../../lib.mk
 
diff --git a/tools/testing/selftests/powerpc/tm/tm-sigreturn.c b/tools/testing/selftests/powerpc/tm/tm-sigreturn.c
new file mode 100644
index 000000000000..85d63449243b
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-sigreturn.c
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/*
+ * Copyright 2015, Laurent Dufour, IBM Corp.
+ *
+ * Test the kernel's signal returning code to check reclaim is done if the
+ * sigreturn() is called while in a transaction (suspended since active is
+ * already dropped trough the system call path).
+ *
+ * The kernel must discard the transaction when entering sigreturn, since
+ * restoring the potential TM SPRS from the signal frame is requiring to not be
+ * in a transaction.
+ */
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "tm.h"
+#include "utils.h"
+
+
+void handler(int sig)
+{
+        uint64_t ret;
+
+        asm __volatile__(
+                "li             3,1             ;"
+                "tbegin.                        ;"
+                "beq            1f              ;"
+                "li             3,0             ;"
+                "tsuspend.                      ;"
+                "1:                             ;"
+                "std%X[ret]     3, %[ret]       ;"
+                : [ret] "=m"(ret)
+                :
+                : "memory", "3", "cr0");
+
+        if (ret)
+                exit(1);
+
+        /*
+         * We return from the signal handle while in a suspended transaction
+         */
+}
+
+
+int tm_sigreturn(void)
+{
+        struct sigaction sa;
+        uint64_t ret = 0;
+
+        SKIP_IF(!have_htm());
+
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_handler = handler;
+        sigemptyset(&sa.sa_mask);
+
+        if (sigaction(SIGSEGV, &sa, NULL))
+                exit(1);
+
+        asm __volatile__(
+                "tbegin.                        ;"
+                "beq            1f              ;"
+                "li             3,0             ;"
+                "std            3,0(3)          ;" /* trigger SEGV */
+                "li             3,1             ;"
+                "std%X[ret]     3,%[ret]        ;"
+                "tend.                          ;"
+                "b              2f              ;"
+                "1:                             ;"
+                "li             3,2             ;"
+                "std%X[ret]     3,%[ret]        ;"
+                "2:                             ;"
+                : [ret] "=m"(ret)
+                :
+                : "memory", "3", "cr0");
+
+        if (ret != 2)
+                exit(1);
+
+        exit(0);
+}
+
+int main(void)
+{
+        return test_harness(tm_sigreturn, "tm_sigreturn");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-unavailable.c b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
index e6a0fad2bfd0..156c8e750259 100644
--- a/tools/testing/selftests/powerpc/tm/tm-unavailable.c
+++ b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
@@ -80,7 +80,7 @@ bool is_failure(uint64_t condition_reg)
         return ((condition_reg >> 28) & 0xa) == 0xa;
 }
 
-void *ping(void *input)
+void *tm_una_ping(void *input)
 {
 
         /*
@@ -280,7 +280,7 @@ void *ping(void *input)
 }
 
 /* Thread to force context switch */
-void *pong(void *not_used)
+void *tm_una_pong(void *not_used)
 {
         /* Wait thread get its name "pong". */
         if (DEBUG)
@@ -311,11 +311,11 @@ void test_fp_vec(int fp, int vec, pthread_attr_t *attr)
         do {
                 int rc;
 
-                /* Bind 'ping' to CPU 0, as specified in 'attr'. */
-                rc = pthread_create(&t0, attr, ping, (void *) &flags);
+                /* Bind to CPU 0, as specified in 'attr'. */
+                rc = pthread_create(&t0, attr, tm_una_ping, (void *) &flags);
                 if (rc)
                         pr_err(rc, "pthread_create()");
-                rc = pthread_setname_np(t0, "ping");
+                rc = pthread_setname_np(t0, "tm_una_ping");
                 if (rc)
                         pr_warn(rc, "pthread_setname_np");
                 rc = pthread_join(t0, &ret_value);
@@ -333,13 +333,15 @@ void test_fp_vec(int fp, int vec, pthread_attr_t *attr)
         }
 }
 
-int main(int argc, char **argv)
+int tm_unavailable_test(void)
 {
         int rc, exception; /* FP = 0, VEC = 1, VSX = 2 */
         pthread_t t1;
         pthread_attr_t attr;
         cpu_set_t cpuset;
 
+        SKIP_IF(!have_htm());
+
         /* Set only CPU 0 in the mask. Both threads will be bound to CPU 0. */
         CPU_ZERO(&cpuset);
         CPU_SET(0, &cpuset);
@@ -354,12 +356,12 @@ int main(int argc, char **argv)
         if (rc)
                 pr_err(rc, "pthread_attr_setaffinity_np()");
 
-        rc = pthread_create(&t1, &attr /* Bind 'pong' to CPU 0 */, pong, NULL);
+        rc = pthread_create(&t1, &attr /* Bind to CPU 0 */, tm_una_pong, NULL);
         if (rc)
                 pr_err(rc, "pthread_create()");
 
         /* Name it for systemtap convenience */
-        rc = pthread_setname_np(t1, "pong");
+        rc = pthread_setname_np(t1, "tm_una_pong");
         if (rc)
                 pr_warn(rc, "pthread_create()");
 
@@ -394,3 +396,9 @@ int main(int argc, char **argv)
                 exit(0);
         }
 }
+
+int main(int argc, char **argv)
+{
+        test_harness_set_timeout(220);
+        return test_harness(tm_unavailable_test, "tm_unavailable_test");
+}