5 files changed, 342 insertions, 75 deletions

diff --git a/lib/dynamic_queue_limits.c b/lib/dynamic_queue_limits.c
index da4672a50a54..e659a027036e 100644
--- a/lib/dynamic_queue_limits.c
+++ b/lib/dynamic_queue_limits.c
@@ -128,12 +128,11 @@ void dql_reset(struct dql *dql)
 }
 EXPORT_SYMBOL(dql_reset);
 
-int dql_init(struct dql *dql, unsigned hold_time)
+void dql_init(struct dql *dql, unsigned int hold_time)
 {
         dql->max_limit = DQL_MAX_LIMIT;
         dql->min_limit = 0;
         dql->slack_hold_time = hold_time;
         dql_reset(dql);
-        return 0;
 }
 EXPORT_SYMBOL(dql_init);
diff --git a/lib/kobject_uevent.c b/lib/kobject_uevent.c
index f237a09a5862..c3e84edc47c9 100644
--- a/lib/kobject_uevent.c
+++ b/lib/kobject_uevent.c
@@ -294,6 +294,55 @@ static void cleanup_uevent_env(struct subprocess_info *info)
 }
 #endif
 
+static int kobject_uevent_net_broadcast(struct kobject *kobj,
+                                        struct kobj_uevent_env *env,
+                                        const char *action_string,
+                                        const char *devpath)
+{
+        int retval = 0;
+#if defined(CONFIG_NET)
+        struct sk_buff *skb = NULL;
+        struct uevent_sock *ue_sk;
+
+        /* send netlink message */
+        list_for_each_entry(ue_sk, &uevent_sock_list, list) {
+                struct sock *uevent_sock = ue_sk->sk;
+
+                if (!netlink_has_listeners(uevent_sock, 1))
+                        continue;
+
+                if (!skb) {
+                        /* allocate message with the maximum possible size */
+                        size_t len = strlen(action_string) + strlen(devpath) + 2;
+                        char *scratch;
+
+                        retval = -ENOMEM;
+                        skb = alloc_skb(len + env->buflen, GFP_KERNEL);
+                        if (!skb)
+                                continue;
+
+                        /* add header */
+                        scratch = skb_put(skb, len);
+                        sprintf(scratch, "%s@%s", action_string, devpath);
+
+                        skb_put_data(skb, env->buf, env->buflen);
+
+                        NETLINK_CB(skb).dst_group = 1;
+                }
+
+                retval = netlink_broadcast_filtered(uevent_sock, skb_get(skb),
+                                                    0, 1, GFP_KERNEL,
+                                                    kobj_bcast_filter,
+                                                    kobj);
+                /* ENOBUFS should be handled in userspace */
+                if (retval == -ENOBUFS || retval == -ESRCH)
+                        retval = 0;
+        }
+        consume_skb(skb);
+#endif
+        return retval;
+}
+
 static void zap_modalias_env(struct kobj_uevent_env *env)
 {
         static const char modalias_prefix[] = "MODALIAS=";
@@ -336,9 +385,6 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
         const struct kset_uevent_ops *uevent_ops;
         int i = 0;
         int retval = 0;
-#ifdef CONFIG_NET
-        struct uevent_sock *ue_sk;
-#endif
 
         pr_debug("kobject: '%s' (%p): %s\n",
                  kobject_name(kobj), kobj, __func__);
@@ -460,46 +506,8 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                 mutex_unlock(&uevent_sock_mutex);
                 goto exit;
         }
-
-#if defined(CONFIG_NET)
-        /* send netlink message */
-        list_for_each_entry(ue_sk, &uevent_sock_list, list) {
-                struct sock *uevent_sock = ue_sk->sk;
-                struct sk_buff *skb;
-                size_t len;
-
-                if (!netlink_has_listeners(uevent_sock, 1))
-                        continue;
-
-                /* allocate message with the maximum possible size */
-                len = strlen(action_string) + strlen(devpath) + 2;
-                skb = alloc_skb(len + env->buflen, GFP_KERNEL);
-                if (skb) {
-                        char *scratch;
-
-                        /* add header */
-                        scratch = skb_put(skb, len);
-                        sprintf(scratch, "%s@%s", action_string, devpath);
-
-                        /* copy keys to our continuous event payload buffer */
-                        for (i = 0; i < env->envp_idx; i++) {
-                                len = strlen(env->envp[i]) + 1;
-                                scratch = skb_put(skb, len);
-                                strcpy(scratch, env->envp[i]);
-                        }
-
-                        NETLINK_CB(skb).dst_group = 1;
-                        retval = netlink_broadcast_filtered(uevent_sock, skb,
-                                                            0, 1, GFP_KERNEL,
-                                                            kobj_bcast_filter,
-                                                            kobj);
-                        /* ENOBUFS should be handled in userspace */
-                        if (retval == -ENOBUFS || retval == -ESRCH)
-                                retval = 0;
-                } else
-                        retval = -ENOMEM;
-        }
-#endif
+        retval = kobject_uevent_net_broadcast(kobj, env, action_string,
+                                              devpath);
         mutex_unlock(&uevent_sock_mutex);
 
 #ifdef CONFIG_UEVENT_HELPER
diff --git a/lib/nlattr.c b/lib/nlattr.c
index 3d8295c85505..8bf78b4b78f0 100644
--- a/lib/nlattr.c
+++ b/lib/nlattr.c
@@ -15,19 +15,23 @@
 #include <linux/types.h>
 #include <net/netlink.h>
 
-static const u8 nla_attr_minlen[NLA_TYPE_MAX+1] = {
+/* for these data types attribute length must be exactly given size */
+static const u8 nla_attr_len[NLA_TYPE_MAX+1] = {
         [NLA_U8]        = sizeof(u8),
         [NLA_U16]       = sizeof(u16),
         [NLA_U32]       = sizeof(u32),
         [NLA_U64]       = sizeof(u64),
-        [NLA_MSECS]     = sizeof(u64),
-        [NLA_NESTED]    = NLA_HDRLEN,
         [NLA_S8]        = sizeof(s8),
         [NLA_S16]       = sizeof(s16),
         [NLA_S32]       = sizeof(s32),
         [NLA_S64]       = sizeof(s64),
 };
 
+static const u8 nla_attr_minlen[NLA_TYPE_MAX+1] = {
+        [NLA_MSECS]     = sizeof(u64),
+        [NLA_NESTED]    = NLA_HDRLEN,
+};
+
 static int validate_nla_bitfield32(const struct nlattr *nla,
                                    u32 *valid_flags_allowed)
 {
@@ -65,6 +69,13 @@ static int validate_nla(const struct nlattr *nla, int maxtype,
 
         BUG_ON(pt->type > NLA_TYPE_MAX);
 
+        /* for data types NLA_U* and NLA_S* require exact length */
+        if (nla_attr_len[pt->type]) {
+                if (attrlen != nla_attr_len[pt->type])
+                        return -ERANGE;
+                return 0;
+        }
+
         switch (pt->type) {
         case NLA_FLAG:
                 if (attrlen > 0)
@@ -191,6 +202,8 @@ nla_policy_len(const struct nla_policy *p, int n)
         for (i = 0; i < n; i++, p++) {
                 if (p->len)
                         len += nla_total_size(p->len);
+                else if (nla_attr_len[p->type])
+                        len += nla_total_size(nla_attr_len[p->type]);
                 else if (nla_attr_minlen[p->type])
                         len += nla_total_size(nla_attr_minlen[p->type]);
         }
diff --git a/lib/once.c b/lib/once.c
index bfb7420d0de3..8b7d6235217e 100644
--- a/lib/once.c
+++ b/lib/once.c
@@ -6,7 +6,7 @@
 
 struct once_work {
         struct work_struct work;
-        struct static_key *key;
+        struct static_key_true *key;
 };
 
 static void once_deferred(struct work_struct *w)
@@ -15,11 +15,11 @@ static void once_deferred(struct work_struct *w)
 
         work = container_of(w, struct once_work, work);
         BUG_ON(!static_key_enabled(work->key));
-        static_key_slow_dec(work->key);
+        static_branch_disable(work->key);
         kfree(work);
 }
 
-static void once_disable_jump(struct static_key *key)
+static void once_disable_jump(struct static_key_true *key)
 {
         struct once_work *w;
 
@@ -52,7 +52,7 @@ bool __do_once_start(bool *done, unsigned long *flags)
 }
 EXPORT_SYMBOL(__do_once_start);
 
-void __do_once_done(bool *done, struct static_key *once_key,
+void __do_once_done(bool *done, struct static_key_true *once_key,
                     unsigned long *flags)
         __releases(once_lock)
 {
diff --git a/lib/test_rhashtable.c b/lib/test_rhashtable.c
index 0ffca990a833..8e83cbdc049c 100644
--- a/lib/test_rhashtable.c
+++ b/lib/test_rhashtable.c
@@ -23,14 +23,15 @@
 #include <linux/semaphore.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/random.h>
 #include <linux/vmalloc.h>
 
 #define MAX_ENTRIES     1000000
 #define TEST_INSERT_FAIL INT_MAX
 
-static int entries = 50000;
-module_param(entries, int, 0);
-MODULE_PARM_DESC(entries, "Number of entries to add (default: 50000)");
+static int parm_entries = 50000;
+module_param(parm_entries, int, 0);
+MODULE_PARM_DESC(parm_entries, "Number of entries to add (default: 50000)");
 
 static int runs = 4;
 module_param(runs, int, 0);
@@ -66,14 +67,18 @@ struct test_obj {
         struct rhash_head       node;
 };
 
+struct test_obj_rhl {
+        struct test_obj_val     value;
+        struct rhlist_head      list_node;
+};
+
 struct thread_data {
+        unsigned int entries;
         int id;
         struct task_struct *task;
         struct test_obj *objs;
 };
 
-static struct test_obj array[MAX_ENTRIES];
-
 static struct rhashtable_params test_rht_params = {
         .head_offset = offsetof(struct test_obj, node),
         .key_offset = offsetof(struct test_obj, value),
@@ -85,7 +90,7 @@ static struct rhashtable_params test_rht_params = {
 static struct semaphore prestart_sem;
 static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);
 
-static int insert_retry(struct rhashtable *ht, struct rhash_head *obj,
+static int insert_retry(struct rhashtable *ht, struct test_obj *obj,
                         const struct rhashtable_params params)
 {
         int err, retries = -1, enomem_retries = 0;
@@ -93,7 +98,7 @@ static int insert_retry(struct rhashtable *ht, struct rhash_head *obj,
         do {
                 retries++;
                 cond_resched();
-                err = rhashtable_insert_fast(ht, obj, params);
+                err = rhashtable_insert_fast(ht, &obj->node, params);
                 if (err == -ENOMEM && enomem_retry) {
                         enomem_retries++;
                         err = -EBUSY;
@@ -107,11 +112,12 @@ static int insert_retry(struct rhashtable *ht, struct rhash_head *obj,
         return err ? : retries;
 }
 
-static int __init test_rht_lookup(struct rhashtable *ht)
+static int __init test_rht_lookup(struct rhashtable *ht, struct test_obj *array,
+                                  unsigned int entries)
 {
         unsigned int i;
 
-        for (i = 0; i < entries * 2; i++) {
+        for (i = 0; i < entries; i++) {
                 struct test_obj *obj;
                 bool expected = !(i % 2);
                 struct test_obj_val key = {
@@ -144,7 +150,7 @@ static int __init test_rht_lookup(struct rhashtable *ht)
         return 0;
 }
 
-static void test_bucket_stats(struct rhashtable *ht)
+static void test_bucket_stats(struct rhashtable *ht, unsigned int entries)
 {
         unsigned int err, total = 0, chain_len = 0;
         struct rhashtable_iter hti;
@@ -186,7 +192,8 @@ static void test_bucket_stats(struct rhashtable *ht)
                 pr_warn("Test failed: Total count mismatch ^^^");
 }
 
-static s64 __init test_rhashtable(struct rhashtable *ht)
+static s64 __init test_rhashtable(struct rhashtable *ht, struct test_obj *array,
+                                  unsigned int entries)
 {
         struct test_obj *obj;
         int err;
@@ -203,7 +210,7 @@ static s64 __init test_rhashtable(struct rhashtable *ht)
                 struct test_obj *obj = &array[i];
 
                 obj->value.id = i * 2;
-                err = insert_retry(ht, &obj->node, test_rht_params);
+                err = insert_retry(ht, obj, test_rht_params);
                 if (err > 0)
                         insert_retries += err;
                 else if (err)
@@ -214,12 +221,12 @@ static s64 __init test_rhashtable(struct rhashtable *ht)
                 pr_info("  %u insertions retried due to memory pressure\n",
                         insert_retries);
 
-        test_bucket_stats(ht);
+        test_bucket_stats(ht, entries);
         rcu_read_lock();
-        test_rht_lookup(ht);
+        test_rht_lookup(ht, array, entries);
         rcu_read_unlock();
 
-        test_bucket_stats(ht);
+        test_bucket_stats(ht, entries);
 
         pr_info("  Deleting %d keys\n", entries);
         for (i = 0; i < entries; i++) {
@@ -244,9 +251,227 @@ static s64 __init test_rhashtable(struct rhashtable *ht)
 }
 
 static struct rhashtable ht;
+static struct rhltable rhlt;
+
+static int __init test_rhltable(unsigned int entries)
+{
+        struct test_obj_rhl *rhl_test_objects;
+        unsigned long *obj_in_table;
+        unsigned int i, j, k;
+        int ret, err;
+
+        if (entries == 0)
+                entries = 1;
+
+        rhl_test_objects = vzalloc(sizeof(*rhl_test_objects) * entries);
+        if (!rhl_test_objects)
+                return -ENOMEM;
+
+        ret = -ENOMEM;
+        obj_in_table = vzalloc(BITS_TO_LONGS(entries) * sizeof(unsigned long));
+        if (!obj_in_table)
+                goto out_free;
+
+        /* nulls_base not supported in rhlist interface */
+        test_rht_params.nulls_base = 0;
+        err = rhltable_init(&rhlt, &test_rht_params);
+        if (WARN_ON(err))
+                goto out_free;
+
+        k = prandom_u32();
+        ret = 0;
+        for (i = 0; i < entries; i++) {
+                rhl_test_objects[i].value.id = k;
+                err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
+                                      test_rht_params);
+                if (WARN(err, "error %d on element %d\n", err, i))
+                        break;
+                if (err == 0)
+                        set_bit(i, obj_in_table);
+        }
+
+        if (err)
+                ret = err;
+
+        pr_info("test %d add/delete pairs into rhlist\n", entries);
+        for (i = 0; i < entries; i++) {
+                struct rhlist_head *h, *pos;
+                struct test_obj_rhl *obj;
+                struct test_obj_val key = {
+                        .id = k,
+                };
+                bool found;
+
+                rcu_read_lock();
+                h = rhltable_lookup(&rhlt, &key, test_rht_params);
+                if (WARN(!h, "key not found during iteration %d of %d", i, entries)) {
+                        rcu_read_unlock();
+                        break;
+                }
+
+                if (i) {
+                        j = i - 1;
+                        rhl_for_each_entry_rcu(obj, pos, h, list_node) {
+                                if (WARN(pos == &rhl_test_objects[j].list_node, "old element found, should be gone"))
+                                        break;
+                        }
+                }
+
+                cond_resched_rcu();
+
+                found = false;
+
+                rhl_for_each_entry_rcu(obj, pos, h, list_node) {
+                        if (pos == &rhl_test_objects[i].list_node) {
+                                found = true;
+                                break;
+                        }
+                }
+
+                rcu_read_unlock();
+
+                if (WARN(!found, "element %d not found", i))
+                        break;
+
+                err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                WARN(err, "rhltable_remove: err %d for iteration %d\n", err, i);
+                if (err == 0)
+                        clear_bit(i, obj_in_table);
+        }
+
+        if (ret == 0 && err)
+                ret = err;
+
+        for (i = 0; i < entries; i++) {
+                WARN(test_bit(i, obj_in_table), "elem %d allegedly still present", i);
+
+                err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,
+                                      test_rht_params);
+                if (WARN(err, "error %d on element %d\n", err, i))
+                        break;
+                if (err == 0)
+                        set_bit(i, obj_in_table);
+        }
+
+        pr_info("test %d random rhlist add/delete operations\n", entries);
+        for (j = 0; j < entries; j++) {
+                u32 i = prandom_u32_max(entries);
+                u32 prand = prandom_u32();
+
+                cond_resched();
+
+                if (prand == 0)
+                        prand = prandom_u32();
+
+                if (prand & 1) {
+                        prand >>= 1;
+                        continue;
+                }
+
+                err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                if (test_bit(i, obj_in_table)) {
+                        clear_bit(i, obj_in_table);
+                        if (WARN(err, "cannot remove element at slot %d", i))
+                                continue;
+                } else {
+                        if (WARN(err != -ENOENT, "removed non-existant element %d, error %d not %d",
+                             i, err, -ENOENT))
+                                continue;
+                }
+
+                if (prand & 1) {
+                        prand >>= 1;
+                        continue;
+                }
+
+                err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                if (err == 0) {
+                        if (WARN(test_and_set_bit(i, obj_in_table), "succeeded to insert same object %d", i))
+                                continue;
+                } else {
+                        if (WARN(!test_bit(i, obj_in_table), "failed to insert object %d", i))
+                                continue;
+                }
+
+                if (prand & 1) {
+                        prand >>= 1;
+                        continue;
+                }
+
+                i = prandom_u32_max(entries);
+                if (test_bit(i, obj_in_table)) {
+                        err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                        WARN(err, "cannot remove element at slot %d", i);
+                        if (err == 0)
+                                clear_bit(i, obj_in_table);
+                } else {
+                        err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                        WARN(err, "failed to insert object %d", i);
+                        if (err == 0)
+                                set_bit(i, obj_in_table);
+                }
+        }
+
+        for (i = 0; i < entries; i++) {
+                cond_resched();
+                err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
+                if (test_bit(i, obj_in_table)) {
+                        if (WARN(err, "cannot remove element at slot %d", i))
+                                continue;
+                } else {
+                        if (WARN(err != -ENOENT, "removed non-existant element, error %d not %d",
+                                 err, -ENOENT))
+                        continue;
+                }
+        }
+
+        rhltable_destroy(&rhlt);
+out_free:
+        vfree(rhl_test_objects);
+        vfree(obj_in_table);
+        return ret;
+}
+
+static int __init test_rhashtable_max(struct test_obj *array,
+                                      unsigned int entries)
+{
+        unsigned int i, insert_retries = 0;
+        int err;
+
+        test_rht_params.max_size = roundup_pow_of_two(entries / 8);
+        err = rhashtable_init(&ht, &test_rht_params);
+        if (err)
+                return err;
+
+        for (i = 0; i < ht.max_elems; i++) {
+                struct test_obj *obj = &array[i];
+
+                obj->value.id = i * 2;
+                err = insert_retry(&ht, obj, test_rht_params);
+                if (err > 0)
+                        insert_retries += err;
+                else if (err)
+                        return err;
+        }
+
+        err = insert_retry(&ht, &array[ht.max_elems], test_rht_params);
+        if (err == -E2BIG) {
+                err = 0;
+        } else {
+                pr_info("insert element %u should have failed with %d, got %d\n",
+                                ht.max_elems, -E2BIG, err);
+                if (err == 0)
+                        err = -1;
+        }
+
+        rhashtable_destroy(&ht);
+
+        return err;
+}
 
 static int thread_lookup_test(struct thread_data *tdata)
 {
+        unsigned int entries = tdata->entries;
         int i, err = 0;
 
         for (i = 0; i < entries; i++) {
@@ -283,10 +508,10 @@ static int threadfunc(void *data)
         if (down_interruptible(&startup_sem))
                 pr_err("  thread[%d]: down_interruptible failed\n", tdata->id);
 
-        for (i = 0; i < entries; i++) {
+        for (i = 0; i < tdata->entries; i++) {
                 tdata->objs[i].value.id = i;
                 tdata->objs[i].value.tid = tdata->id;
-                err = insert_retry(&ht, &tdata->objs[i].node, test_rht_params);
+                err = insert_retry(&ht, &tdata->objs[i], test_rht_params);
                 if (err > 0) {
                         insert_retries += err;
                 } else if (err) {
@@ -307,7 +532,7 @@ static int threadfunc(void *data)
         }
 
         for (step = 10; step > 0; step--) {
-                for (i = 0; i < entries; i += step) {
+                for (i = 0; i < tdata->entries; i += step) {
                         if (tdata->objs[i].value.id == TEST_INSERT_FAIL)
                                 continue;
                         err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
@@ -338,17 +563,25 @@ out:
 
 static int __init test_rht_init(void)
 {
+        unsigned int entries;
         int i, err, started_threads = 0, failed_threads = 0;
         u64 total_time = 0;
         struct thread_data *tdata;
         struct test_obj *objs;
 
-        entries = min(entries, MAX_ENTRIES);
+        if (parm_entries < 0)
+                parm_entries = 1;
+
+        entries = min(parm_entries, MAX_ENTRIES);
 
         test_rht_params.automatic_shrinking = shrinking;
         test_rht_params.max_size = max_size ? : roundup_pow_of_two(entries);
         test_rht_params.nelem_hint = size;
 
+        objs = vzalloc((test_rht_params.max_size + 1) * sizeof(struct test_obj));
+        if (!objs)
+                return -ENOMEM;
+
         pr_info("Running rhashtable test nelem=%d, max_size=%d, shrinking=%d\n",
                 size, max_size, shrinking);
 
@@ -356,7 +589,8 @@ static int __init test_rht_init(void)
                 s64 time;
 
                 pr_info("Test %02d:\n", i);
-                memset(&array, 0, sizeof(array));
+                memset(objs, 0, test_rht_params.max_size * sizeof(struct test_obj));
+
                 err = rhashtable_init(&ht, &test_rht_params);
                 if (err < 0) {
                         pr_warn("Test failed: Unable to initialize hashtable: %d\n",
@@ -364,9 +598,10 @@ static int __init test_rht_init(void)
                         continue;
                 }
 
-                time = test_rhashtable(&ht);
+                time = test_rhashtable(&ht, objs, entries);
                 rhashtable_destroy(&ht);
                 if (time < 0) {
+                        vfree(objs);
                         pr_warn("Test failed: return code %lld\n", time);
                         return -EINVAL;
                 }
@@ -374,6 +609,11 @@ static int __init test_rht_init(void)
                 total_time += time;
         }
 
+        pr_info("test if its possible to exceed max_size %d: %s\n",
+                        test_rht_params.max_size, test_rhashtable_max(objs, entries) == 0 ?
+                        "no, ok" : "YES, failed");
+        vfree(objs);
+
         do_div(total_time, runs);
         pr_info("Average test time: %llu\n", total_time);
 
@@ -404,6 +644,7 @@ static int __init test_rht_init(void)
         }
         for (i = 0; i < tcount; i++) {
                 tdata[i].id = i;
+                tdata[i].entries = entries;
                 tdata[i].objs = objs + i * entries;
                 tdata[i].task = kthread_run(threadfunc, &tdata[i],
                                             "rhashtable_thrad[%d]", i);
@@ -425,11 +666,17 @@ static int __init test_rht_init(void)
                         failed_threads++;
                 }
         }
-        pr_info("Started %d threads, %d failed\n",
-                started_threads, failed_threads);
         rhashtable_destroy(&ht);
         vfree(tdata);
         vfree(objs);
+
+        /*
+         * rhltable_remove is very expensive, default values can cause test
+         * to run for 2 minutes or more,  use a smaller number instead.
+         */
+        err = test_rhltable(entries / 16);
+        pr_info("Started %d threads, %d failed, rhltable test returns %d\n",
+                started_threads, failed_threads, err);
         return 0;
 }