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

Pull scheduler updates from Ingo Molnar:

 - membarrier updates (Mathieu Desnoyers)

 - SMP balancing optimizations (Mel Gorman)

 - stats update optimizations (Peter Zijlstra)

 - RT scheduler race fixes (Steven Rostedt)

 - misc fixes and updates

* 'sched-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  sched/fair: Use a recently used CPU as an idle candidate and the basis for SIS
  sched/fair: Do not migrate if the prev_cpu is idle
  sched/fair: Restructure wake_affine*() to return a CPU id
  sched/fair: Remove unnecessary parameters from wake_affine_idle()
  sched/rt: Make update_curr_rt() more accurate
  sched/rt: Up the root domain ref count when passing it around via IPIs
  sched/rt: Use container_of() to get root domain in rto_push_irq_work_func()
  sched/core: Optimize update_stats_*()
  sched/core: Optimize ttwu_stat()
  membarrier/selftest: Test private expedited sync core command
  membarrier/arm64: Provide core serializing command
  membarrier/x86: Provide core serializing command
  membarrier: Provide core serializing command, *_SYNC_CORE
  lockin/x86: Implement sync_core_before_usermode()
  locking: Introduce sync_core_before_usermode()
  membarrier/selftest: Test global expedited command
  membarrier: Provide GLOBAL_EXPEDITED command
  membarrier: Document scheduler barrier requirements
  powerpc, membarrier: Skip memory barrier in switch_mm()
  membarrier/selftest: Test private expedited command

1 files changed, 219 insertions, 18 deletions

diff --git a/tools/testing/selftests/membarrier/membarrier_test.c b/tools/testing/selftests/membarrier/membarrier_test.c
index 9e674d9514d1..22bffd55a523 100644
--- a/tools/testing/selftests/membarrier/membarrier_test.c
+++ b/tools/testing/selftests/membarrier/membarrier_test.c
@@ -16,49 +16,210 @@ static int sys_membarrier(int cmd, int flags)
 static int test_membarrier_cmd_fail(void)
 {
         int cmd = -1, flags = 0;
+        const char *test_name = "sys membarrier invalid command";
 
         if (sys_membarrier(cmd, flags) != -1) {
                 ksft_exit_fail_msg(
-                        "sys membarrier invalid command test: command = %d, flags = %d. Should fail, but passed\n",
-                        cmd, flags);
+                        "%s test: command = %d, flags = %d. Should fail, but passed\n",
+                        test_name, cmd, flags);
+        }
+        if (errno != EINVAL) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
+                        test_name, flags, EINVAL, strerror(EINVAL),
+                        errno, strerror(errno));
         }
 
         ksft_test_result_pass(
-                "sys membarrier invalid command test: command = %d, flags = %d. Failed as expected\n",
-                cmd, flags);
+                "%s test: command = %d, flags = %d, errno = %d. Failed as expected\n",
+                test_name, cmd, flags, errno);
         return 0;
 }
 
 static int test_membarrier_flags_fail(void)
 {
         int cmd = MEMBARRIER_CMD_QUERY, flags = 1;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_QUERY invalid flags";
+
+        if (sys_membarrier(cmd, flags) != -1) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should fail, but passed\n",
+                        test_name, flags);
+        }
+        if (errno != EINVAL) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
+                        test_name, flags, EINVAL, strerror(EINVAL),
+                        errno, strerror(errno));
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d, errno = %d. Failed as expected\n",
+                test_name, flags, errno);
+        return 0;
+}
+
+static int test_membarrier_global_success(void)
+{
+        int cmd = MEMBARRIER_CMD_GLOBAL, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_GLOBAL";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d\n", test_name, flags);
+        return 0;
+}
+
+static int test_membarrier_private_expedited_fail(void)
+{
+        int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED not registered failure";
+
+        if (sys_membarrier(cmd, flags) != -1) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should fail, but passed\n",
+                        test_name, flags);
+        }
+        if (errno != EPERM) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
+                        test_name, flags, EPERM, strerror(EPERM),
+                        errno, strerror(errno));
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d, errno = %d\n",
+                test_name, flags, errno);
+        return 0;
+}
+
+static int test_membarrier_register_private_expedited_success(void)
+{
+        int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d\n",
+                test_name, flags);
+        return 0;
+}
+
+static int test_membarrier_private_expedited_success(void)
+{
+        int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d\n",
+                test_name, flags);
+        return 0;
+}
+
+static int test_membarrier_private_expedited_sync_core_fail(void)
+{
+        int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE not registered failure";
 
         if (sys_membarrier(cmd, flags) != -1) {
                 ksft_exit_fail_msg(
-                        "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Should fail, but passed\n",
-                        flags);
+                        "%s test: flags = %d. Should fail, but passed\n",
+                        test_name, flags);
+        }
+        if (errno != EPERM) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
+                        test_name, flags, EPERM, strerror(EPERM),
+                        errno, strerror(errno));
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d, errno = %d\n",
+                test_name, flags, errno);
+        return 0;
+}
+
+static int test_membarrier_register_private_expedited_sync_core_success(void)
+{
+        int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d\n",
+                test_name, flags);
+        return 0;
+}
+
+static int test_membarrier_private_expedited_sync_core_success(void)
+{
+        int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
         }
 
         ksft_test_result_pass(
-                "sys membarrier MEMBARRIER_CMD_QUERY invalid flags test: flags = %d. Failed as expected\n",
-                flags);
+                "%s test: flags = %d\n",
+                test_name, flags);
         return 0;
 }
 
-static int test_membarrier_success(void)
+static int test_membarrier_register_global_expedited_success(void)
 {
-        int cmd = MEMBARRIER_CMD_SHARED, flags = 0;
-        const char *test_name = "sys membarrier MEMBARRIER_CMD_SHARED\n";
+        int cmd = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED";
 
         if (sys_membarrier(cmd, flags) != 0) {
                 ksft_exit_fail_msg(
-                        "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n",
-                        flags);
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
         }
 
         ksft_test_result_pass(
-                "sys membarrier MEMBARRIER_CMD_SHARED test: flags = %d\n",
-                flags);
+                "%s test: flags = %d\n",
+                test_name, flags);
+        return 0;
+}
+
+static int test_membarrier_global_expedited_success(void)
+{
+        int cmd = MEMBARRIER_CMD_GLOBAL_EXPEDITED, flags = 0;
+        const char *test_name = "sys membarrier MEMBARRIER_CMD_GLOBAL_EXPEDITED";
+
+        if (sys_membarrier(cmd, flags) != 0) {
+                ksft_exit_fail_msg(
+                        "%s test: flags = %d, errno = %d\n",
+                        test_name, flags, errno);
+        }
+
+        ksft_test_result_pass(
+                "%s test: flags = %d\n",
+                test_name, flags);
         return 0;
 }
 
@@ -72,7 +233,45 @@ static int test_membarrier(void)
         status = test_membarrier_flags_fail();
         if (status)
                 return status;
-        status = test_membarrier_success();
+        status = test_membarrier_global_success();
+        if (status)
+                return status;
+        status = test_membarrier_private_expedited_fail();
+        if (status)
+                return status;
+        status = test_membarrier_register_private_expedited_success();
+        if (status)
+                return status;
+        status = test_membarrier_private_expedited_success();
+        if (status)
+                return status;
+        status = sys_membarrier(MEMBARRIER_CMD_QUERY, 0);
+        if (status < 0) {
+                ksft_test_result_fail("sys_membarrier() failed\n");
+                return status;
+        }
+        if (status & MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE) {
+                status = test_membarrier_private_expedited_sync_core_fail();
+                if (status)
+                        return status;
+                status = test_membarrier_register_private_expedited_sync_core_success();
+                if (status)
+                        return status;
+                status = test_membarrier_private_expedited_sync_core_success();
+                if (status)
+                        return status;
+        }
+        /*
+         * It is valid to send a global membarrier from a non-registered
+         * process.
+         */
+        status = test_membarrier_global_expedited_success();
+        if (status)
+                return status;
+        status = test_membarrier_register_global_expedited_success();
+        if (status)
+                return status;
+        status = test_membarrier_global_expedited_success();
         if (status)
                 return status;
         return 0;
@@ -94,8 +293,10 @@ static int test_membarrier_query(void)
                 }
                 ksft_exit_fail_msg("sys_membarrier() failed\n");
         }
-        if (!(ret & MEMBARRIER_CMD_SHARED))
+        if (!(ret & MEMBARRIER_CMD_GLOBAL)) {
+                ksft_test_result_fail("sys_membarrier() CMD_GLOBAL query failed\n");
                 ksft_exit_fail_msg("sys_membarrier is not supported.\n");
+        }
 
         ksft_test_result_pass("sys_membarrier available\n");
         return 0;
@@ -108,5 +309,5 @@ int main(int argc, char **argv)
         test_membarrier_query();
         test_membarrier();
 
-        ksft_exit_pass();
+        return ksft_exit_pass();
 }