6 files changed, 59 insertions, 35 deletions

diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 98fe715522e8..c617b9d1d6cb 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -798,6 +798,13 @@ config HARDLOCKUP_DETECTOR_PERF
         select SOFTLOCKUP_DETECTOR
 
 #
+# Enables a timestamp based low pass filter to compensate for perf based
+# hard lockup detection which runs too fast due to turbo modes.
+#
+config HARDLOCKUP_CHECK_TIMESTAMP
+        bool
+
+#
 # arch/ can define HAVE_HARDLOCKUP_DETECTOR_ARCH to provide their own hard
 # lockup detector rather than the perf based detector.
 #
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
index 7d315fdb9f13..cf7b129b0b2b 100644
--- a/lib/fault-inject.c
+++ b/lib/fault-inject.c
@@ -110,10 +110,12 @@ bool should_fail(struct fault_attr *attr, ssize_t size)
         if (in_task()) {
                 unsigned int fail_nth = READ_ONCE(current->fail_nth);
 
-                if (fail_nth && !WRITE_ONCE(current->fail_nth, fail_nth - 1))
-                        goto fail;
+                if (fail_nth) {
+                        if (!WRITE_ONCE(current->fail_nth, fail_nth - 1))
+                                goto fail;
 
-                return false;
+                        return false;
+                }
         }
 
         /* No need to check any other properties if the probability is 0 */
diff --git a/lib/mpi/mpicoder.c b/lib/mpi/mpicoder.c
index 5a0f75a3bf01..eead4b339466 100644
--- a/lib/mpi/mpicoder.c
+++ b/lib/mpi/mpicoder.c
@@ -364,11 +364,11 @@ MPI mpi_read_raw_from_sgl(struct scatterlist *sgl, unsigned int nbytes)
         }
 
         miter.consumed = lzeros;
-        sg_miter_stop(&miter);
 
         nbytes -= lzeros;
         nbits = nbytes * 8;
         if (nbits > MAX_EXTERN_MPI_BITS) {
+                sg_miter_stop(&miter);
                 pr_info("MPI: mpi too large (%u bits)\n", nbits);
                 return NULL;
         }
@@ -376,6 +376,8 @@ MPI mpi_read_raw_from_sgl(struct scatterlist *sgl, unsigned int nbytes)
         if (nbytes > 0)
                 nbits -= count_leading_zeros(*buff) - (BITS_PER_LONG - 8);
 
+        sg_miter_stop(&miter);
+
         nlimbs = DIV_ROUND_UP(nbytes, BYTES_PER_MPI_LIMB);
         val = mpi_alloc(nlimbs);
         if (!val)
diff --git a/lib/test_kmod.c b/lib/test_kmod.c
index 6c1d678bcf8b..ff9148969b92 100644
--- a/lib/test_kmod.c
+++ b/lib/test_kmod.c
@@ -485,7 +485,7 @@ static ssize_t config_show(struct device *dev,
                                 config->test_driver);
         else
                 len += snprintf(buf+len, PAGE_SIZE - len,
-                                "driver:\tEMTPY\n");
+                                "driver:\tEMPTY\n");
 
         if (config->test_fs)
                 len += snprintf(buf+len, PAGE_SIZE - len,
@@ -493,7 +493,7 @@ static ssize_t config_show(struct device *dev,
                                 config->test_fs);
         else
                 len += snprintf(buf+len, PAGE_SIZE - len,
-                                "fs:\tEMTPY\n");
+                                "fs:\tEMPTY\n");
 
         mutex_unlock(&test_dev->config_mutex);
 
@@ -746,11 +746,11 @@ static int trigger_config_run_type(struct kmod_test_device *test_dev,
                                                       strlen(test_str));
                 break;
         case TEST_KMOD_FS_TYPE:
-                break;
                 kfree_const(config->test_fs);
                 config->test_driver = NULL;
                 copied = config_copy_test_fs(config, test_str,
                                              strlen(test_str));
+                break;
         default:
                 mutex_unlock(&test_dev->config_mutex);
                 return -EINVAL;
@@ -880,10 +880,10 @@ static int test_dev_config_update_uint_sync(struct kmod_test_device *test_dev,
                                             int (*test_sync)(struct kmod_test_device *test_dev))
 {
         int ret;
-        long new;
+        unsigned long new;
         unsigned int old_val;
 
-        ret = kstrtol(buf, 10, &new);
+        ret = kstrtoul(buf, 10, &new);
         if (ret)
                 return ret;
 
@@ -918,9 +918,9 @@ static int test_dev_config_update_uint_range(struct kmod_test_device *test_dev,
                                              unsigned int max)
 {
         int ret;
-        long new;
+        unsigned long new;
 
-        ret = kstrtol(buf, 10, &new);
+        ret = kstrtoul(buf, 10, &new);
         if (ret)
                 return ret;
 
@@ -1146,7 +1146,7 @@ static struct kmod_test_device *register_test_dev_kmod(void)
         struct kmod_test_device *test_dev = NULL;
         int ret;
 
-        mutex_unlock(&reg_dev_mutex);
+        mutex_lock(&reg_dev_mutex);
 
         /* int should suffice for number of devices, test for wrap */
         if (unlikely(num_test_devs + 1) < 0) {
diff --git a/lib/test_rhashtable.c b/lib/test_rhashtable.c
index 64e899b63337..0ffca990a833 100644
--- a/lib/test_rhashtable.c
+++ b/lib/test_rhashtable.c
@@ -56,8 +56,13 @@ static bool enomem_retry = false;
 module_param(enomem_retry, bool, 0);
 MODULE_PARM_DESC(enomem_retry, "Retry insert even if -ENOMEM was returned (default: off)");
 
+struct test_obj_val {
+        int     id;
+        int     tid;
+};
+
 struct test_obj {
-        int                     value;
+        struct test_obj_val     value;
         struct rhash_head       node;
 };
 
@@ -72,7 +77,7 @@ 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),
-        .key_len = sizeof(int),
+        .key_len = sizeof(struct test_obj_val),
         .hashfn = jhash,
         .nulls_base = (3U << RHT_BASE_SHIFT),
 };
@@ -109,24 +114,26 @@ static int __init test_rht_lookup(struct rhashtable *ht)
         for (i = 0; i < entries * 2; i++) {
                 struct test_obj *obj;
                 bool expected = !(i % 2);
-                u32 key = i;
+                struct test_obj_val key = {
+                        .id = i,
+                };
 
-                if (array[i / 2].value == TEST_INSERT_FAIL)
+                if (array[i / 2].value.id == TEST_INSERT_FAIL)
                         expected = false;
 
                 obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
 
                 if (expected && !obj) {
-                        pr_warn("Test failed: Could not find key %u\n", key);
+                        pr_warn("Test failed: Could not find key %u\n", key.id);
                         return -ENOENT;
                 } else if (!expected && obj) {
                         pr_warn("Test failed: Unexpected entry found for key %u\n",
-                                key);
+                                key.id);
                         return -EEXIST;
                 } else if (expected && obj) {
-                        if (obj->value != i) {
+                        if (obj->value.id != i) {
                                 pr_warn("Test failed: Lookup value mismatch %u!=%u\n",
-                                        obj->value, i);
+                                        obj->value.id, i);
                                 return -EINVAL;
                         }
                 }
@@ -195,7 +202,7 @@ static s64 __init test_rhashtable(struct rhashtable *ht)
         for (i = 0; i < entries; i++) {
                 struct test_obj *obj = &array[i];
 
-                obj->value = i * 2;
+                obj->value.id = i * 2;
                 err = insert_retry(ht, &obj->node, test_rht_params);
                 if (err > 0)
                         insert_retries += err;
@@ -216,9 +223,11 @@ static s64 __init test_rhashtable(struct rhashtable *ht)
 
         pr_info("  Deleting %d keys\n", entries);
         for (i = 0; i < entries; i++) {
-                u32 key = i * 2;
+                struct test_obj_val key = {
+                        .id = i * 2,
+                };
 
-                if (array[i].value != TEST_INSERT_FAIL) {
+                if (array[i].value.id != TEST_INSERT_FAIL) {
                         obj = rhashtable_lookup_fast(ht, &key, test_rht_params);
                         BUG_ON(!obj);
 
@@ -242,18 +251,21 @@ static int thread_lookup_test(struct thread_data *tdata)
 
         for (i = 0; i < entries; i++) {
                 struct test_obj *obj;
-                int key = (tdata->id << 16) | i;
+                struct test_obj_val key = {
+                        .id = i,
+                        .tid = tdata->id,
+                };
 
                 obj = rhashtable_lookup_fast(&ht, &key, test_rht_params);
-                if (obj && (tdata->objs[i].value == TEST_INSERT_FAIL)) {
-                        pr_err("  found unexpected object %d\n", key);
+                if (obj && (tdata->objs[i].value.id == TEST_INSERT_FAIL)) {
+                        pr_err("  found unexpected object %d-%d\n", key.tid, key.id);
                         err++;
-                } else if (!obj && (tdata->objs[i].value != TEST_INSERT_FAIL)) {
-                        pr_err("  object %d not found!\n", key);
+                } else if (!obj && (tdata->objs[i].value.id != TEST_INSERT_FAIL)) {
+                        pr_err("  object %d-%d not found!\n", key.tid, key.id);
                         err++;
-                } else if (obj && (obj->value != key)) {
-                        pr_err("  wrong object returned (got %d, expected %d)\n",
-                               obj->value, key);
+                } else if (obj && memcmp(&obj->value, &key, sizeof(key))) {
+                        pr_err("  wrong object returned (got %d-%d, expected %d-%d)\n",
+                               obj->value.tid, obj->value.id, key.tid, key.id);
                         err++;
                 }
 
@@ -272,7 +284,8 @@ static int threadfunc(void *data)
                 pr_err("  thread[%d]: down_interruptible failed\n", tdata->id);
 
         for (i = 0; i < entries; i++) {
-                tdata->objs[i].value = (tdata->id << 16) | 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);
                 if (err > 0) {
                         insert_retries += err;
@@ -295,7 +308,7 @@ static int threadfunc(void *data)
 
         for (step = 10; step > 0; step--) {
                 for (i = 0; i < entries; i += step) {
-                        if (tdata->objs[i].value == TEST_INSERT_FAIL)
+                        if (tdata->objs[i].value.id == TEST_INSERT_FAIL)
                                 continue;
                         err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
                                                      test_rht_params);
@@ -304,7 +317,7 @@ static int threadfunc(void *data)
                                        tdata->id);
                                 goto out;
                         }
-                        tdata->objs[i].value = TEST_INSERT_FAIL;
+                        tdata->objs[i].value.id = TEST_INSERT_FAIL;
 
                         cond_resched();
                 }
diff --git a/lib/test_uuid.c b/lib/test_uuid.c
index 478c049630b5..cd819c397dc7 100644
--- a/lib/test_uuid.c
+++ b/lib/test_uuid.c
@@ -82,7 +82,7 @@ static void __init test_uuid_test(const struct test_uuid_data *data)
                 test_uuid_failed("conversion", false, true, data->uuid, NULL);
 
         total_tests++;
-        if (uuid_equal(&data->be, &be)) {
+        if (!uuid_equal(&data->be, &be)) {
                 sprintf(buf, "%pUb", &be);
                 test_uuid_failed("cmp", false, true, data->uuid, buf);
         }