Merge branch 'linus' into x86/microcode, to pick up merge window changes

Signed-off-by: Ingo Molnar <mingo@kernel.org>

7 files changed, 67 insertions, 44 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index b9cfdbfae9aa..805b7048a1bd 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1307,22 +1307,6 @@ config RCU_PERF_TEST
           Say M if you want the RCU performance tests to build as a module.
           Say N if you are unsure.
 
-config RCU_PERF_TEST_RUNNABLE
-        bool "performance tests for RCU runnable by default"
-        depends on RCU_PERF_TEST = y
-        default n
-        help
-          This option provides a way to build the RCU performance tests
-          directly into the kernel without them starting up at boot time.
-          You can use /sys/module to manually override this setting.
-          This /proc file is available only when the RCU performance
-          tests have been built into the kernel.
-
-          Say Y here if you want the RCU performance tests to start during
-          boot (you probably don't).
-          Say N here if you want the RCU performance tests to start only
-          after being manually enabled via /sys/module.
-
 config RCU_TORTURE_TEST
         tristate "torture tests for RCU"
         depends on DEBUG_KERNEL
@@ -1340,23 +1324,6 @@ config RCU_TORTURE_TEST
           Say M if you want the RCU torture tests to build as a module.
           Say N if you are unsure.
 
-config RCU_TORTURE_TEST_RUNNABLE
-        bool "torture tests for RCU runnable by default"
-        depends on RCU_TORTURE_TEST = y
-        default n
-        help
-          This option provides a way to build the RCU torture tests
-          directly into the kernel without them starting up at boot
-          time.  You can use /proc/sys/kernel/rcutorture_runnable
-          to manually override this setting.  This /proc file is
-          available only when the RCU torture tests have been built
-          into the kernel.
-
-          Say Y here if you want the RCU torture tests to start during
-          boot (you probably don't).
-          Say N here if you want the RCU torture tests to start only
-          after being manually enabled via /proc.
-
 config RCU_TORTURE_TEST_SLOW_PREINIT
         bool "Slow down RCU grace-period pre-initialization to expose races"
         depends on RCU_TORTURE_TEST
diff --git a/lib/Makefile b/lib/Makefile
index ff6a7a6c6395..07d06a8b9788 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -15,9 +15,6 @@ KCOV_INSTRUMENT_rbtree.o := n
 KCOV_INSTRUMENT_list_debug.o := n
 KCOV_INSTRUMENT_debugobjects.o := n
 KCOV_INSTRUMENT_dynamic_debug.o := n
-# Kernel does not boot if we instrument this file as it uses custom calling
-# convention (see CONFIG_ARCH_HWEIGHT_CFLAGS).
-KCOV_INSTRUMENT_hweight.o := n
 
 lib-y := ctype.o string.o vsprintf.o cmdline.o \
          rbtree.o radix-tree.o dump_stack.o timerqueue.o\
@@ -74,8 +71,6 @@ obj-$(CONFIG_HAS_IOMEM) += iomap_copy.o devres.o
 obj-$(CONFIG_CHECK_SIGNATURE) += check_signature.o
 obj-$(CONFIG_DEBUG_LOCKING_API_SELFTESTS) += locking-selftest.o
 
-GCOV_PROFILE_hweight.o := n
-CFLAGS_hweight.o = $(subst $(quote),,$(CONFIG_ARCH_HWEIGHT_CFLAGS))
 obj-$(CONFIG_GENERIC_HWEIGHT) += hweight.o
 
 obj-$(CONFIG_BTREE) += btree.o
diff --git a/lib/atomic64.c b/lib/atomic64.c
index 2886ebac6567..53c2d5edc826 100644
--- a/lib/atomic64.c
+++ b/lib/atomic64.c
@@ -96,17 +96,41 @@ long long atomic64_##op##_return(long long a, atomic64_t *v)		\
 }                                                                       \
 EXPORT_SYMBOL(atomic64_##op##_return);
 
+#define ATOMIC64_FETCH_OP(op, c_op)                                     \
+long long atomic64_fetch_##op(long long a, atomic64_t *v)               \
+{                                                                       \
+        unsigned long flags;                                            \
+        raw_spinlock_t *lock = lock_addr(v);                            \
+        long long val;                                                  \
+                                                                        \
+        raw_spin_lock_irqsave(lock, flags);                             \
+        val = v->counter;                                               \
+        v->counter c_op a;                                              \
+        raw_spin_unlock_irqrestore(lock, flags);                        \
+        return val;                                                     \
+}                                                                       \
+EXPORT_SYMBOL(atomic64_fetch_##op);
+
 #define ATOMIC64_OPS(op, c_op)                                          \
         ATOMIC64_OP(op, c_op)                                           \
-        ATOMIC64_OP_RETURN(op, c_op)
+        ATOMIC64_OP_RETURN(op, c_op)                                    \
+        ATOMIC64_FETCH_OP(op, c_op)
 
 ATOMIC64_OPS(add, +=)
 ATOMIC64_OPS(sub, -=)
-ATOMIC64_OP(and, &=)
-ATOMIC64_OP(or, |=)
-ATOMIC64_OP(xor, ^=)
 
 #undef ATOMIC64_OPS
+#define ATOMIC64_OPS(op, c_op)                                          \
+        ATOMIC64_OP(op, c_op)                                           \
+        ATOMIC64_OP_RETURN(op, c_op)                                    \
+        ATOMIC64_FETCH_OP(op, c_op)
+
+ATOMIC64_OPS(and, &=)
+ATOMIC64_OPS(or, |=)
+ATOMIC64_OPS(xor, ^=)
+
+#undef ATOMIC64_OPS
+#undef ATOMIC64_FETCH_OP
 #undef ATOMIC64_OP_RETURN
 #undef ATOMIC64_OP
 
diff --git a/lib/atomic64_test.c b/lib/atomic64_test.c
index 123481814320..dbb369145dda 100644
--- a/lib/atomic64_test.c
+++ b/lib/atomic64_test.c
@@ -53,11 +53,25 @@ do {								\
         BUG_ON(atomic##bit##_read(&v) != r);                    \
 } while (0)
 
+#define TEST_FETCH(bit, op, c_op, val)                          \
+do {                                                            \
+        atomic##bit##_set(&v, v0);                              \
+        r = v0;                                                 \
+        r c_op val;                                             \
+        BUG_ON(atomic##bit##_##op(val, &v) != v0);              \
+        BUG_ON(atomic##bit##_read(&v) != r);                    \
+} while (0)
+
 #define RETURN_FAMILY_TEST(bit, op, c_op, val)                  \
 do {                                                            \
         FAMILY_TEST(TEST_RETURN, bit, op, c_op, val);           \
 } while (0)
 
+#define FETCH_FAMILY_TEST(bit, op, c_op, val)                   \
+do {                                                            \
+        FAMILY_TEST(TEST_FETCH, bit, op, c_op, val);            \
+} while (0)
+
 #define TEST_ARGS(bit, op, init, ret, expect, args...)          \
 do {                                                            \
         atomic##bit##_set(&v, init);                            \
@@ -114,6 +128,16 @@ static __init void test_atomic(void)
         RETURN_FAMILY_TEST(, sub_return, -=, onestwos);
         RETURN_FAMILY_TEST(, sub_return, -=, -one);
 
+        FETCH_FAMILY_TEST(, fetch_add, +=, onestwos);
+        FETCH_FAMILY_TEST(, fetch_add, +=, -one);
+        FETCH_FAMILY_TEST(, fetch_sub, -=, onestwos);
+        FETCH_FAMILY_TEST(, fetch_sub, -=, -one);
+
+        FETCH_FAMILY_TEST(, fetch_or,  |=, v1);
+        FETCH_FAMILY_TEST(, fetch_and, &=, v1);
+        FETCH_FAMILY_TEST(, fetch_andnot, &= ~, v1);
+        FETCH_FAMILY_TEST(, fetch_xor, ^=, v1);
+
         INC_RETURN_FAMILY_TEST(, v0);
         DEC_RETURN_FAMILY_TEST(, v0);
 
@@ -154,6 +178,16 @@ static __init void test_atomic64(void)
         RETURN_FAMILY_TEST(64, sub_return, -=, onestwos);
         RETURN_FAMILY_TEST(64, sub_return, -=, -one);
 
+        FETCH_FAMILY_TEST(64, fetch_add, +=, onestwos);
+        FETCH_FAMILY_TEST(64, fetch_add, +=, -one);
+        FETCH_FAMILY_TEST(64, fetch_sub, -=, onestwos);
+        FETCH_FAMILY_TEST(64, fetch_sub, -=, -one);
+
+        FETCH_FAMILY_TEST(64, fetch_or,  |=, v1);
+        FETCH_FAMILY_TEST(64, fetch_and, &=, v1);
+        FETCH_FAMILY_TEST(64, fetch_andnot, &= ~, v1);
+        FETCH_FAMILY_TEST(64, fetch_xor, ^=, v1);
+
         INIT(v0);
         atomic64_inc(&v);
         r += one;
diff --git a/lib/bitmap.c b/lib/bitmap.c
index c66da508cbf7..eca88087fa8a 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -14,9 +14,9 @@
 #include <linux/bug.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
+#include <linux/uaccess.h>
 
 #include <asm/page.h>
-#include <asm/uaccess.h>
 
 /*
  * bitmaps provide an array of bits, implemented using an an
diff --git a/lib/hweight.c b/lib/hweight.c
index 9a5c1f221558..43273a7d83cf 100644
--- a/lib/hweight.c
+++ b/lib/hweight.c
@@ -9,6 +9,7 @@
  * The Hamming Weight of a number is the total number of bits set in it.
  */
 
+#ifndef __HAVE_ARCH_SW_HWEIGHT
 unsigned int __sw_hweight32(unsigned int w)
 {
 #ifdef CONFIG_ARCH_HAS_FAST_MULTIPLIER
@@ -25,6 +26,7 @@ unsigned int __sw_hweight32(unsigned int w)
 #endif
 }
 EXPORT_SYMBOL(__sw_hweight32);
+#endif
 
 unsigned int __sw_hweight16(unsigned int w)
 {
@@ -43,6 +45,7 @@ unsigned int __sw_hweight8(unsigned int w)
 }
 EXPORT_SYMBOL(__sw_hweight8);
 
+#ifndef __HAVE_ARCH_SW_HWEIGHT
 unsigned long __sw_hweight64(__u64 w)
 {
 #if BITS_PER_LONG == 32
@@ -65,3 +68,4 @@ unsigned long __sw_hweight64(__u64 w)
 #endif
 }
 EXPORT_SYMBOL(__sw_hweight64);
+#endif
diff --git a/lib/random32.c b/lib/random32.c
index 510d1ce7d4d2..69ed593aab07 100644
--- a/lib/random32.c
+++ b/lib/random32.c
@@ -233,7 +233,6 @@ static void __prandom_timer(unsigned long dontcare)
 
 static void __init __prandom_start_seed_timer(void)
 {
-        set_timer_slack(&seed_timer, HZ);
         seed_timer.expires = jiffies + msecs_to_jiffies(40 * MSEC_PER_SEC);
         add_timer(&seed_timer);
 }