10 files changed, 908 insertions, 43 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index fe01d418b09a..d246a3bbd6ef 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -22,6 +22,9 @@ config GENERIC_STRNCPY_FROM_USER
 config GENERIC_STRNLEN_USER
         bool
 
+config GENERIC_NET_UTILS
+        bool
+
 config GENERIC_FIND_FIRST_BIT
         bool
 
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 566cf2bc08ea..7154f799541a 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -547,6 +547,19 @@ config DEBUG_MUTEXES
          This feature allows mutex semantics violations to be detected and
          reported.
 
+config DEBUG_WW_MUTEX_SLOWPATH
+        bool "Wait/wound mutex debugging: Slowpath testing"
+        depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
+        select DEBUG_LOCK_ALLOC
+        select DEBUG_SPINLOCK
+        select DEBUG_MUTEXES
+        help
+         This feature enables slowpath testing for w/w mutex users by
+         injecting additional -EDEADLK wound/backoff cases. Together with
+         the full mutex checks enabled with (CONFIG_PROVE_LOCKING) this
+         will test all possible w/w mutex interface abuse with the
+         exception of simply not acquiring all the required locks.
+
 config DEBUG_LOCK_ALLOC
         bool "Lock debugging: detect incorrect freeing of live locks"
         depends on DEBUG_KERNEL && TRACE_IRQFLAGS_SUPPORT && STACKTRACE_SUPPORT && LOCKDEP_SUPPORT
diff --git a/lib/Makefile b/lib/Makefile
index c55a037a354e..8f8d385187f2 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -13,7 +13,7 @@ lib-y := ctype.o string.o vsprintf.o cmdline.o \
          sha1.o md5.o irq_regs.o reciprocal_div.o argv_split.o \
          proportions.o flex_proportions.o prio_heap.o ratelimit.o show_mem.o \
          is_single_threaded.o plist.o decompress.o kobject_uevent.o \
-         earlycpio.o
+         earlycpio.o percpu-refcount.o
 
 obj-$(CONFIG_ARCH_HAS_DEBUG_STRICT_USER_COPY_CHECKS) += usercopy.o
 lib-$(CONFIG_MMU) += ioremap.o
@@ -137,6 +137,8 @@ obj-$(CONFIG_DDR) += jedec_ddr_data.o
 obj-$(CONFIG_GENERIC_STRNCPY_FROM_USER) += strncpy_from_user.o
 obj-$(CONFIG_GENERIC_STRNLEN_USER) += strnlen_user.o
 
+obj-$(CONFIG_GENERIC_NET_UTILS) += net_utils.o
+
 obj-$(CONFIG_STMP_DEVICE) += stmp_device.o
 
 libfdt_files = fdt.o fdt_ro.o fdt_wip.o fdt_rw.o fdt_sw.o fdt_strerror.o
diff --git a/lib/build_OID_registry b/lib/build_OID_registry
index dfbdaab81bc8..5d9827217360 100755
--- a/lib/build_OID_registry
+++ b/lib/build_OID_registry
@@ -50,8 +50,6 @@ my @indices = ();
 my @lengths = ();
 my $total_length = 0;
 
-print "Compiling ", $#names + 1, " OIDs\n";
-
 for (my $i = 0; $i <= $#names; $i++) {
     my $name = $names[$i];
     my $oid = $oids[$i];
diff --git a/lib/debug_locks.c b/lib/debug_locks.c
index f2fa60c59343..96c4c633d95e 100644
--- a/lib/debug_locks.c
+++ b/lib/debug_locks.c
@@ -30,6 +30,7 @@ EXPORT_SYMBOL_GPL(debug_locks);
  * a locking bug is detected.
  */
 int debug_locks_silent;
+EXPORT_SYMBOL_GPL(debug_locks_silent);
 
 /*
  * Generic 'turn off all lock debugging' function:
@@ -44,3 +45,4 @@ int debug_locks_off(void)
         }
         return 0;
 }
+EXPORT_SYMBOL_GPL(debug_locks_off);
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index c5c7a762b850..d7d501ea856d 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -182,27 +182,6 @@ static struct dentry *debugfs_create_stacktrace_depth(
 
 #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
 
-static int debugfs_atomic_t_set(void *data, u64 val)
-{
-        atomic_set((atomic_t *)data, val);
-        return 0;
-}
-
-static int debugfs_atomic_t_get(void *data, u64 *val)
-{
-        *val = atomic_read((atomic_t *)data);
-        return 0;
-}
-
-DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
-                        debugfs_atomic_t_set, "%lld\n");
-
-static struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
-                                struct dentry *parent, atomic_t *value)
-{
-        return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
-}
-
 struct dentry *fault_create_debugfs_attr(const char *name,
                         struct dentry *parent, struct fault_attr *attr)
 {
diff --git a/lib/kobject.c b/lib/kobject.c
index b7e29a6056d3..4a1f33d43548 100644
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -805,7 +805,7 @@ static struct kset *kset_create(const char *name,
         kset = kzalloc(sizeof(*kset), GFP_KERNEL);
         if (!kset)
                 return NULL;
-        retval = kobject_set_name(&kset->kobj, name);
+        retval = kobject_set_name(&kset->kobj, "%s", name);
         if (retval) {
                 kfree(kset);
                 return NULL;
diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
index c3eb261a7df3..aad024dde3c4 100644
--- a/lib/locking-selftest.c
+++ b/lib/locking-selftest.c
@@ -26,6 +26,8 @@
  */
 static unsigned int debug_locks_verbose;
 
+static DEFINE_WW_CLASS(ww_lockdep);
+
 static int __init setup_debug_locks_verbose(char *str)
 {
         get_option(&str, &debug_locks_verbose);
@@ -42,6 +44,10 @@ __setup("debug_locks_verbose=", setup_debug_locks_verbose);
 #define LOCKTYPE_RWLOCK 0x2
 #define LOCKTYPE_MUTEX  0x4
 #define LOCKTYPE_RWSEM  0x8
+#define LOCKTYPE_WW     0x10
+
+static struct ww_acquire_ctx t, t2;
+static struct ww_mutex o, o2, o3;
 
 /*
  * Normal standalone locks, for the circular and irq-context
@@ -193,6 +199,20 @@ static void init_shared_classes(void)
 #define RSU(x)                  up_read(&rwsem_##x)
 #define RWSI(x)                 init_rwsem(&rwsem_##x)
 
+#ifndef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+#define WWAI(x)                 ww_acquire_init(x, &ww_lockdep)
+#else
+#define WWAI(x)                 do { ww_acquire_init(x, &ww_lockdep); (x)->deadlock_inject_countdown = ~0U; } while (0)
+#endif
+#define WWAD(x)                 ww_acquire_done(x)
+#define WWAF(x)                 ww_acquire_fini(x)
+
+#define WWL(x, c)               ww_mutex_lock(x, c)
+#define WWT(x)                  ww_mutex_trylock(x)
+#define WWL1(x)                 ww_mutex_lock(x, NULL)
+#define WWU(x)                  ww_mutex_unlock(x)
+
+
 #define LOCK_UNLOCK_2(x,y)      LOCK(x); LOCK(y); UNLOCK(y); UNLOCK(x)
 
 /*
@@ -894,11 +914,13 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
 # define I_RWLOCK(x)    lockdep_reset_lock(&rwlock_##x.dep_map)
 # define I_MUTEX(x)     lockdep_reset_lock(&mutex_##x.dep_map)
 # define I_RWSEM(x)     lockdep_reset_lock(&rwsem_##x.dep_map)
+# define I_WW(x)        lockdep_reset_lock(&x.dep_map)
 #else
 # define I_SPINLOCK(x)
 # define I_RWLOCK(x)
 # define I_MUTEX(x)
 # define I_RWSEM(x)
+# define I_WW(x)
 #endif
 
 #define I1(x)                                   \
@@ -920,11 +942,20 @@ GENERATE_PERMUTATIONS_3_EVENTS(irq_read_recursion_soft)
 static void reset_locks(void)
 {
         local_irq_disable();
+        lockdep_free_key_range(&ww_lockdep.acquire_key, 1);
+        lockdep_free_key_range(&ww_lockdep.mutex_key, 1);
+
         I1(A); I1(B); I1(C); I1(D);
         I1(X1); I1(X2); I1(Y1); I1(Y2); I1(Z1); I1(Z2);
+        I_WW(t); I_WW(t2); I_WW(o.base); I_WW(o2.base); I_WW(o3.base);
         lockdep_reset();
         I2(A); I2(B); I2(C); I2(D);
         init_shared_classes();
+
+        ww_mutex_init(&o, &ww_lockdep); ww_mutex_init(&o2, &ww_lockdep); ww_mutex_init(&o3, &ww_lockdep);
+        memset(&t, 0, sizeof(t)); memset(&t2, 0, sizeof(t2));
+        memset(&ww_lockdep.acquire_key, 0, sizeof(ww_lockdep.acquire_key));
+        memset(&ww_lockdep.mutex_key, 0, sizeof(ww_lockdep.mutex_key));
         local_irq_enable();
 }
 
@@ -938,7 +969,6 @@ static int unexpected_testcase_failures;
 static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
 {
         unsigned long saved_preempt_count = preempt_count();
-        int expected_failure = 0;
 
         WARN_ON(irqs_disabled());
 
@@ -947,25 +977,17 @@ static void dotest(void (*testcase_fn)(void), int expected, int lockclass_mask)
          * Filter out expected failures:
          */
 #ifndef CONFIG_PROVE_LOCKING
-        if ((lockclass_mask & LOCKTYPE_SPIN) && debug_locks != expected)
-                expected_failure = 1;
-        if ((lockclass_mask & LOCKTYPE_RWLOCK) && debug_locks != expected)
-                expected_failure = 1;
-        if ((lockclass_mask & LOCKTYPE_MUTEX) && debug_locks != expected)
-                expected_failure = 1;
-        if ((lockclass_mask & LOCKTYPE_RWSEM) && debug_locks != expected)
-                expected_failure = 1;
+        if (expected == FAILURE && debug_locks) {
+                expected_testcase_failures++;
+                printk("failed|");
+        }
+        else
 #endif
         if (debug_locks != expected) {
-                if (expected_failure) {
-                        expected_testcase_failures++;
-                        printk("failed|");
-                } else {
-                        unexpected_testcase_failures++;
-
-                        printk("FAILED|");
-                        dump_stack();
-                }
+                unexpected_testcase_failures++;
+                printk("FAILED|");
+
+                dump_stack();
         } else {
                 testcase_successes++;
                 printk("  ok  |");
@@ -1108,6 +1130,666 @@ static inline void print_testname(const char *testname)
         DO_TESTCASE_6IRW(desc, name, 312);                      \
         DO_TESTCASE_6IRW(desc, name, 321);
 
+static void ww_test_fail_acquire(void)
+{
+        int ret;
+
+        WWAI(&t);
+        t.stamp++;
+
+        ret = WWL(&o, &t);
+
+        if (WARN_ON(!o.ctx) ||
+            WARN_ON(ret))
+                return;
+
+        /* No lockdep test, pure API */
+        ret = WWL(&o, &t);
+        WARN_ON(ret != -EALREADY);
+
+        ret = WWT(&o);
+        WARN_ON(ret);
+
+        t2 = t;
+        t2.stamp++;
+        ret = WWL(&o, &t2);
+        WARN_ON(ret != -EDEADLK);
+        WWU(&o);
+
+        if (WWT(&o))
+                WWU(&o);
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        else
+                DEBUG_LOCKS_WARN_ON(1);
+#endif
+}
+
+static void ww_test_normal(void)
+{
+        int ret;
+
+        WWAI(&t);
+
+        /*
+         * None of the ww_mutex codepaths should be taken in the 'normal'
+         * mutex calls. The easiest way to verify this is by using the
+         * normal mutex calls, and making sure o.ctx is unmodified.
+         */
+
+        /* mutex_lock (and indirectly, mutex_lock_nested) */
+        o.ctx = (void *)~0UL;
+        mutex_lock(&o.base);
+        mutex_unlock(&o.base);
+        WARN_ON(o.ctx != (void *)~0UL);
+
+        /* mutex_lock_interruptible (and *_nested) */
+        o.ctx = (void *)~0UL;
+        ret = mutex_lock_interruptible(&o.base);
+        if (!ret)
+                mutex_unlock(&o.base);
+        else
+                WARN_ON(1);
+        WARN_ON(o.ctx != (void *)~0UL);
+
+        /* mutex_lock_killable (and *_nested) */
+        o.ctx = (void *)~0UL;
+        ret = mutex_lock_killable(&o.base);
+        if (!ret)
+                mutex_unlock(&o.base);
+        else
+                WARN_ON(1);
+        WARN_ON(o.ctx != (void *)~0UL);
+
+        /* trylock, succeeding */
+        o.ctx = (void *)~0UL;
+        ret = mutex_trylock(&o.base);
+        WARN_ON(!ret);
+        if (ret)
+                mutex_unlock(&o.base);
+        else
+                WARN_ON(1);
+        WARN_ON(o.ctx != (void *)~0UL);
+
+        /* trylock, failing */
+        o.ctx = (void *)~0UL;
+        mutex_lock(&o.base);
+        ret = mutex_trylock(&o.base);
+        WARN_ON(ret);
+        mutex_unlock(&o.base);
+        WARN_ON(o.ctx != (void *)~0UL);
+
+        /* nest_lock */
+        o.ctx = (void *)~0UL;
+        mutex_lock_nest_lock(&o.base, &t);
+        mutex_unlock(&o.base);
+        WARN_ON(o.ctx != (void *)~0UL);
+}
+
+static void ww_test_two_contexts(void)
+{
+        WWAI(&t);
+        WWAI(&t2);
+}
+
+static void ww_test_diff_class(void)
+{
+        WWAI(&t);
+#ifdef CONFIG_DEBUG_MUTEXES
+        t.ww_class = NULL;
+#endif
+        WWL(&o, &t);
+}
+
+static void ww_test_context_done_twice(void)
+{
+        WWAI(&t);
+        WWAD(&t);
+        WWAD(&t);
+        WWAF(&t);
+}
+
+static void ww_test_context_unlock_twice(void)
+{
+        WWAI(&t);
+        WWAD(&t);
+        WWAF(&t);
+        WWAF(&t);
+}
+
+static void ww_test_context_fini_early(void)
+{
+        WWAI(&t);
+        WWL(&o, &t);
+        WWAD(&t);
+        WWAF(&t);
+}
+
+static void ww_test_context_lock_after_done(void)
+{
+        WWAI(&t);
+        WWAD(&t);
+        WWL(&o, &t);
+}
+
+static void ww_test_object_unlock_twice(void)
+{
+        WWL1(&o);
+        WWU(&o);
+        WWU(&o);
+}
+
+static void ww_test_object_lock_unbalanced(void)
+{
+        WWAI(&t);
+        WWL(&o, &t);
+        t.acquired = 0;
+        WWU(&o);
+        WWAF(&t);
+}
+
+static void ww_test_object_lock_stale_context(void)
+{
+        WWAI(&t);
+        o.ctx = &t2;
+        WWL(&o, &t);
+}
+
+static void ww_test_edeadlk_normal(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        o2.ctx = &t2;
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        o2.ctx = NULL;
+        mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
+        mutex_unlock(&o2.base);
+        WWU(&o);
+
+        WWL(&o2, &t);
+}
+
+static void ww_test_edeadlk_normal_slow(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        o2.ctx = NULL;
+        mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
+        mutex_unlock(&o2.base);
+        WWU(&o);
+
+        ww_mutex_lock_slow(&o2, &t);
+}
+
+static void ww_test_edeadlk_no_unlock(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        o2.ctx = &t2;
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        o2.ctx = NULL;
+        mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
+        mutex_unlock(&o2.base);
+
+        WWL(&o2, &t);
+}
+
+static void ww_test_edeadlk_no_unlock_slow(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        o2.ctx = NULL;
+        mutex_acquire(&o2.base.dep_map, 0, 1, _THIS_IP_);
+        mutex_unlock(&o2.base);
+
+        ww_mutex_lock_slow(&o2, &t);
+}
+
+static void ww_test_edeadlk_acquire_more(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        ret = WWL(&o3, &t);
+}
+
+static void ww_test_edeadlk_acquire_more_slow(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        ww_mutex_lock_slow(&o3, &t);
+}
+
+static void ww_test_edeadlk_acquire_more_edeadlk(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        mutex_lock(&o3.base);
+        mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
+        o3.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        ret = WWL(&o3, &t);
+        WARN_ON(ret != -EDEADLK);
+}
+
+static void ww_test_edeadlk_acquire_more_edeadlk_slow(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        mutex_lock(&o3.base);
+        mutex_release(&o3.base.dep_map, 1, _THIS_IP_);
+        o3.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+
+        ww_mutex_lock_slow(&o3, &t);
+}
+
+static void ww_test_edeadlk_acquire_wrong(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+        if (!ret)
+                WWU(&o2);
+
+        WWU(&o);
+
+        ret = WWL(&o3, &t);
+}
+
+static void ww_test_edeadlk_acquire_wrong_slow(void)
+{
+        int ret;
+
+        mutex_lock(&o2.base);
+        mutex_release(&o2.base.dep_map, 1, _THIS_IP_);
+        o2.ctx = &t2;
+
+        WWAI(&t);
+        t2 = t;
+        t2.stamp--;
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret != -EDEADLK);
+        if (!ret)
+                WWU(&o2);
+
+        WWU(&o);
+
+        ww_mutex_lock_slow(&o3, &t);
+}
+
+static void ww_test_spin_nest_unlocked(void)
+{
+        raw_spin_lock_nest_lock(&lock_A, &o.base);
+        U(A);
+}
+
+static void ww_test_unneeded_slow(void)
+{
+        WWAI(&t);
+
+        ww_mutex_lock_slow(&o, &t);
+}
+
+static void ww_test_context_block(void)
+{
+        int ret;
+
+        WWAI(&t);
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+        WWL1(&o2);
+}
+
+static void ww_test_context_try(void)
+{
+        int ret;
+
+        WWAI(&t);
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWT(&o2);
+        WARN_ON(!ret);
+        WWU(&o2);
+        WWU(&o);
+}
+
+static void ww_test_context_context(void)
+{
+        int ret;
+
+        WWAI(&t);
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret);
+
+        WWU(&o2);
+        WWU(&o);
+}
+
+static void ww_test_try_block(void)
+{
+        bool ret;
+
+        ret = WWT(&o);
+        WARN_ON(!ret);
+
+        WWL1(&o2);
+        WWU(&o2);
+        WWU(&o);
+}
+
+static void ww_test_try_try(void)
+{
+        bool ret;
+
+        ret = WWT(&o);
+        WARN_ON(!ret);
+        ret = WWT(&o2);
+        WARN_ON(!ret);
+        WWU(&o2);
+        WWU(&o);
+}
+
+static void ww_test_try_context(void)
+{
+        int ret;
+
+        ret = WWT(&o);
+        WARN_ON(!ret);
+
+        WWAI(&t);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret);
+}
+
+static void ww_test_block_block(void)
+{
+        WWL1(&o);
+        WWL1(&o2);
+}
+
+static void ww_test_block_try(void)
+{
+        bool ret;
+
+        WWL1(&o);
+        ret = WWT(&o2);
+        WARN_ON(!ret);
+}
+
+static void ww_test_block_context(void)
+{
+        int ret;
+
+        WWL1(&o);
+        WWAI(&t);
+
+        ret = WWL(&o2, &t);
+        WARN_ON(ret);
+}
+
+static void ww_test_spin_block(void)
+{
+        L(A);
+        U(A);
+
+        WWL1(&o);
+        L(A);
+        U(A);
+        WWU(&o);
+
+        L(A);
+        WWL1(&o);
+        WWU(&o);
+        U(A);
+}
+
+static void ww_test_spin_try(void)
+{
+        bool ret;
+
+        L(A);
+        U(A);
+
+        ret = WWT(&o);
+        WARN_ON(!ret);
+        L(A);
+        U(A);
+        WWU(&o);
+
+        L(A);
+        ret = WWT(&o);
+        WARN_ON(!ret);
+        WWU(&o);
+        U(A);
+}
+
+static void ww_test_spin_context(void)
+{
+        int ret;
+
+        L(A);
+        U(A);
+
+        WWAI(&t);
+
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+        L(A);
+        U(A);
+        WWU(&o);
+
+        L(A);
+        ret = WWL(&o, &t);
+        WARN_ON(ret);
+        WWU(&o);
+        U(A);
+}
+
+static void ww_tests(void)
+{
+        printk("  --------------------------------------------------------------------------\n");
+        printk("  | Wound/wait tests |\n");
+        printk("  ---------------------\n");
+
+        print_testname("ww api failures");
+        dotest(ww_test_fail_acquire, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_normal, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_unneeded_slow, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("ww contexts mixing");
+        dotest(ww_test_two_contexts, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_diff_class, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("finishing ww context");
+        dotest(ww_test_context_done_twice, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_context_unlock_twice, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_context_fini_early, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_context_lock_after_done, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("locking mismatches");
+        dotest(ww_test_object_unlock_twice, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_object_lock_unbalanced, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_object_lock_stale_context, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("EDEADLK handling");
+        dotest(ww_test_edeadlk_normal, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_normal_slow, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_no_unlock, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_no_unlock_slow, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_more, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_more_slow, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_more_edeadlk, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_more_edeadlk_slow, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_wrong, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_edeadlk_acquire_wrong_slow, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("spinlock nest unlocked");
+        dotest(ww_test_spin_nest_unlocked, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        printk("  -----------------------------------------------------\n");
+        printk("                                 |block | try  |context|\n");
+        printk("  -----------------------------------------------------\n");
+
+        print_testname("context");
+        dotest(ww_test_context_block, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_context_try, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_context_context, SUCCESS, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("try");
+        dotest(ww_test_try_block, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_try_try, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_try_context, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("block");
+        dotest(ww_test_block_block, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_block_try, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_block_context, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+
+        print_testname("spinlock");
+        dotest(ww_test_spin_block, FAILURE, LOCKTYPE_WW);
+        dotest(ww_test_spin_try, SUCCESS, LOCKTYPE_WW);
+        dotest(ww_test_spin_context, FAILURE, LOCKTYPE_WW);
+        printk("\n");
+}
 
 void locking_selftest(void)
 {
@@ -1188,6 +1870,8 @@ void locking_selftest(void)
         DO_TESTCASE_6x2("irq read-recursion", irq_read_recursion);
 //      DO_TESTCASE_6x2B("irq read-recursion #2", irq_read_recursion2);
 
+        ww_tests();
+
         if (unexpected_testcase_failures) {
                 printk("-----------------------------------------------------------------\n");
                 debug_locks = 0;
diff --git a/lib/net_utils.c b/lib/net_utils.c
new file mode 100644
index 000000000000..2e3c52c8d050
--- /dev/null
+++ b/lib/net_utils.c
@@ -0,0 +1,26 @@
+#include <linux/string.h>
+#include <linux/if_ether.h>
+#include <linux/ctype.h>
+#include <linux/kernel.h>
+
+int mac_pton(const char *s, u8 *mac)
+{
+        int i;
+
+        /* XX:XX:XX:XX:XX:XX */
+        if (strlen(s) < 3 * ETH_ALEN - 1)
+                return 0;
+
+        /* Don't dirty result unless string is valid MAC. */
+        for (i = 0; i < ETH_ALEN; i++) {
+                if (!isxdigit(s[i * 3]) || !isxdigit(s[i * 3 + 1]))
+                        return 0;
+                if (i != ETH_ALEN - 1 && s[i * 3 + 2] != ':')
+                        return 0;
+        }
+        for (i = 0; i < ETH_ALEN; i++) {
+                mac[i] = (hex_to_bin(s[i * 3]) << 4) | hex_to_bin(s[i * 3 + 1]);
+        }
+        return 1;
+}
+EXPORT_SYMBOL(mac_pton);
diff --git a/lib/percpu-refcount.c b/lib/percpu-refcount.c
new file mode 100644
index 000000000000..7deeb6297a48
--- /dev/null
+++ b/lib/percpu-refcount.c
@@ -0,0 +1,158 @@
+#define pr_fmt(fmt) "%s: " fmt "\n", __func__
+
+#include <linux/kernel.h>
+#include <linux/percpu-refcount.h>
+
+/*
+ * Initially, a percpu refcount is just a set of percpu counters. Initially, we
+ * don't try to detect the ref hitting 0 - which means that get/put can just
+ * increment or decrement the local counter. Note that the counter on a
+ * particular cpu can (and will) wrap - this is fine, when we go to shutdown the
+ * percpu counters will all sum to the correct value
+ *
+ * (More precisely: because moduler arithmatic is commutative the sum of all the
+ * pcpu_count vars will be equal to what it would have been if all the gets and
+ * puts were done to a single integer, even if some of the percpu integers
+ * overflow or underflow).
+ *
+ * The real trick to implementing percpu refcounts is shutdown. We can't detect
+ * the ref hitting 0 on every put - this would require global synchronization
+ * and defeat the whole purpose of using percpu refs.
+ *
+ * What we do is require the user to keep track of the initial refcount; we know
+ * the ref can't hit 0 before the user drops the initial ref, so as long as we
+ * convert to non percpu mode before the initial ref is dropped everything
+ * works.
+ *
+ * Converting to non percpu mode is done with some RCUish stuff in
+ * percpu_ref_kill. Additionally, we need a bias value so that the atomic_t
+ * can't hit 0 before we've added up all the percpu refs.
+ */
+
+#define PCPU_COUNT_BIAS         (1U << 31)
+
+/**
+ * percpu_ref_init - initialize a percpu refcount
+ * @ref: percpu_ref to initialize
+ * @release: function which will be called when refcount hits 0
+ *
+ * Initializes the refcount in single atomic counter mode with a refcount of 1;
+ * analagous to atomic_set(ref, 1).
+ *
+ * Note that @release must not sleep - it may potentially be called from RCU
+ * callback context by percpu_ref_kill().
+ */
+int percpu_ref_init(struct percpu_ref *ref, percpu_ref_func_t *release)
+{
+        atomic_set(&ref->count, 1 + PCPU_COUNT_BIAS);
+
+        ref->pcpu_count = alloc_percpu(unsigned);
+        if (!ref->pcpu_count)
+                return -ENOMEM;
+
+        ref->release = release;
+        return 0;
+}
+
+/**
+ * percpu_ref_cancel_init - cancel percpu_ref_init()
+ * @ref: percpu_ref to cancel init for
+ *
+ * Once a percpu_ref is initialized, its destruction is initiated by
+ * percpu_ref_kill() and completes asynchronously, which can be painful to
+ * do when destroying a half-constructed object in init failure path.
+ *
+ * This function destroys @ref without invoking @ref->release and the
+ * memory area containing it can be freed immediately on return.  To
+ * prevent accidental misuse, it's required that @ref has finished
+ * percpu_ref_init(), whether successful or not, but never used.
+ *
+ * The weird name and usage restriction are to prevent people from using
+ * this function by mistake for normal shutdown instead of
+ * percpu_ref_kill().
+ */
+void percpu_ref_cancel_init(struct percpu_ref *ref)
+{
+        unsigned __percpu *pcpu_count = ref->pcpu_count;
+        int cpu;
+
+        WARN_ON_ONCE(atomic_read(&ref->count) != 1 + PCPU_COUNT_BIAS);
+
+        if (pcpu_count) {
+                for_each_possible_cpu(cpu)
+                        WARN_ON_ONCE(*per_cpu_ptr(pcpu_count, cpu));
+                free_percpu(ref->pcpu_count);
+        }
+}
+
+static void percpu_ref_kill_rcu(struct rcu_head *rcu)
+{
+        struct percpu_ref *ref = container_of(rcu, struct percpu_ref, rcu);
+        unsigned __percpu *pcpu_count = ref->pcpu_count;
+        unsigned count = 0;
+        int cpu;
+
+        /* Mask out PCPU_REF_DEAD */
+        pcpu_count = (unsigned __percpu *)
+                (((unsigned long) pcpu_count) & ~PCPU_STATUS_MASK);
+
+        for_each_possible_cpu(cpu)
+                count += *per_cpu_ptr(pcpu_count, cpu);
+
+        free_percpu(pcpu_count);
+
+        pr_debug("global %i pcpu %i", atomic_read(&ref->count), (int) count);
+
+        /*
+         * It's crucial that we sum the percpu counters _before_ adding the sum
+         * to &ref->count; since gets could be happening on one cpu while puts
+         * happen on another, adding a single cpu's count could cause
+         * @ref->count to hit 0 before we've got a consistent value - but the
+         * sum of all the counts will be consistent and correct.
+         *
+         * Subtracting the bias value then has to happen _after_ adding count to
+         * &ref->count; we need the bias value to prevent &ref->count from
+         * reaching 0 before we add the percpu counts. But doing it at the same
+         * time is equivalent and saves us atomic operations:
+         */
+
+        atomic_add((int) count - PCPU_COUNT_BIAS, &ref->count);
+
+        /* @ref is viewed as dead on all CPUs, send out kill confirmation */
+        if (ref->confirm_kill)
+                ref->confirm_kill(ref);
+
+        /*
+         * Now we're in single atomic_t mode with a consistent refcount, so it's
+         * safe to drop our initial ref:
+         */
+        percpu_ref_put(ref);
+}
+
+/**
+ * percpu_ref_kill_and_confirm - drop the initial ref and schedule confirmation
+ * @ref: percpu_ref to kill
+ * @confirm_kill: optional confirmation callback
+ *
+ * Equivalent to percpu_ref_kill() but also schedules kill confirmation if
+ * @confirm_kill is not NULL.  @confirm_kill, which may not block, will be
+ * called after @ref is seen as dead from all CPUs - all further
+ * invocations of percpu_ref_tryget() will fail.  See percpu_ref_tryget()
+ * for more details.
+ *
+ * Due to the way percpu_ref is implemented, @confirm_kill will be called
+ * after at least one full RCU grace period has passed but this is an
+ * implementation detail and callers must not depend on it.
+ */
+void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
+                                 percpu_ref_func_t *confirm_kill)
+{
+        WARN_ONCE(REF_STATUS(ref->pcpu_count) == PCPU_REF_DEAD,
+                  "percpu_ref_kill() called more than once!\n");
+
+        ref->pcpu_count = (unsigned __percpu *)
+                (((unsigned long) ref->pcpu_count)|PCPU_REF_DEAD);
+        ref->confirm_kill = confirm_kill;
+
+        call_rcu_sched(&ref->rcu, percpu_ref_kill_rcu);
+}