Merge branch 'akpm' (patches from Andrew)

Merge more updates from Andrew Morton:

 - a few block updates that fell in my lap

 - lib/ updates

 - checkpatch

 - autofs

 - ipc

 - a ton of misc other things

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (100 commits)
  mm: split gfp_mask and mapping flags into separate fields
  fs: use mapping_set_error instead of opencoded set_bit
  treewide: remove redundant #include <linux/kconfig.h>
  hung_task: allow hung_task_panic when hung_task_warnings is 0
  kthread: add kerneldoc for kthread_create()
  kthread: better support freezable kthread workers
  kthread: allow to modify delayed kthread work
  kthread: allow to cancel kthread work
  kthread: initial support for delayed kthread work
  kthread: detect when a kthread work is used by more workers
  kthread: add kthread_destroy_worker()
  kthread: add kthread_create_worker*()
  kthread: allow to call __kthread_create_on_node() with va_list args
  kthread/smpboot: do not park in kthread_create_on_cpu()
  kthread: kthread worker API cleanup
  kthread: rename probe_kthread_data() to kthread_probe_data()
  scripts/tags.sh: enable code completion in VIM
  mm: kmemleak: avoid using __va() on addresses that don't have a lowmem mapping
  kdump, vmcoreinfo: report memory sections virtual addresses
  ipc/sem.c: add cond_resched in exit_sme
  ...

6 files changed, 185 insertions, 3 deletions

diff --git a/tools/testing/nvdimm/config_check.c b/tools/testing/nvdimm/config_check.c
index 878daf3429e8..7dc5a0af9b54 100644
--- a/tools/testing/nvdimm/config_check.c
+++ b/tools/testing/nvdimm/config_check.c
@@ -1,4 +1,3 @@
-#include <linux/kconfig.h>
 #include <linux/bug.h>
 
 void check(void)
diff --git a/tools/testing/radix-tree/Makefile b/tools/testing/radix-tree/Makefile
index 9d0919ed52a4..f2e07f2fd4b4 100644
--- a/tools/testing/radix-tree/Makefile
+++ b/tools/testing/radix-tree/Makefile
@@ -3,7 +3,8 @@ CFLAGS += -I. -g -O2 -Wall -D_LGPL_SOURCE
 LDFLAGS += -lpthread -lurcu
 TARGETS = main
 OFILES = main.o radix-tree.o linux.o test.o tag_check.o find_next_bit.o \
-         regression1.o regression2.o regression3.o multiorder.o
+         regression1.o regression2.o regression3.o multiorder.o \
+         iteration_check.o
 
 targets: $(TARGETS)
 
diff --git a/tools/testing/radix-tree/iteration_check.c b/tools/testing/radix-tree/iteration_check.c
new file mode 100644
index 000000000000..9adb8e7415a6
--- /dev/null
+++ b/tools/testing/radix-tree/iteration_check.c
@@ -0,0 +1,180 @@
+/*
+ * iteration_check.c: test races having to do with radix tree iteration
+ * Copyright (c) 2016 Intel Corporation
+ * Author: Ross Zwisler <ross.zwisler@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include <linux/radix-tree.h>
+#include <pthread.h>
+#include "test.h"
+
+#define NUM_THREADS 4
+#define TAG 0
+static pthread_mutex_t tree_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_t threads[NUM_THREADS];
+RADIX_TREE(tree, GFP_KERNEL);
+bool test_complete;
+
+/* relentlessly fill the tree with tagged entries */
+static void *add_entries_fn(void *arg)
+{
+        int pgoff;
+
+        while (!test_complete) {
+                for (pgoff = 0; pgoff < 100; pgoff++) {
+                        pthread_mutex_lock(&tree_lock);
+                        if (item_insert(&tree, pgoff) == 0)
+                                item_tag_set(&tree, pgoff, TAG);
+                        pthread_mutex_unlock(&tree_lock);
+                }
+        }
+
+        return NULL;
+}
+
+/*
+ * Iterate over the tagged entries, doing a radix_tree_iter_retry() as we find
+ * things that have been removed and randomly resetting our iteration to the
+ * next chunk with radix_tree_iter_next().  Both radix_tree_iter_retry() and
+ * radix_tree_iter_next() cause radix_tree_next_slot() to be called with a
+ * NULL 'slot' variable.
+ */
+static void *tagged_iteration_fn(void *arg)
+{
+        struct radix_tree_iter iter;
+        void **slot;
+
+        while (!test_complete) {
+                rcu_read_lock();
+                radix_tree_for_each_tagged(slot, &tree, &iter, 0, TAG) {
+                        void *entry;
+                        int i;
+
+                        /* busy wait to let removals happen */
+                        for (i = 0; i < 1000000; i++)
+                                ;
+
+                        entry = radix_tree_deref_slot(slot);
+                        if (unlikely(!entry))
+                                continue;
+
+                        if (radix_tree_deref_retry(entry)) {
+                                slot = radix_tree_iter_retry(&iter);
+                                continue;
+                        }
+
+                        if (rand() % 50 == 0)
+                                slot = radix_tree_iter_next(&iter);
+                }
+                rcu_read_unlock();
+        }
+
+        return NULL;
+}
+
+/*
+ * Iterate over the entries, doing a radix_tree_iter_retry() as we find things
+ * that have been removed and randomly resetting our iteration to the next
+ * chunk with radix_tree_iter_next().  Both radix_tree_iter_retry() and
+ * radix_tree_iter_next() cause radix_tree_next_slot() to be called with a
+ * NULL 'slot' variable.
+ */
+static void *untagged_iteration_fn(void *arg)
+{
+        struct radix_tree_iter iter;
+        void **slot;
+
+        while (!test_complete) {
+                rcu_read_lock();
+                radix_tree_for_each_slot(slot, &tree, &iter, 0) {
+                        void *entry;
+                        int i;
+
+                        /* busy wait to let removals happen */
+                        for (i = 0; i < 1000000; i++)
+                                ;
+
+                        entry = radix_tree_deref_slot(slot);
+                        if (unlikely(!entry))
+                                continue;
+
+                        if (radix_tree_deref_retry(entry)) {
+                                slot = radix_tree_iter_retry(&iter);
+                                continue;
+                        }
+
+                        if (rand() % 50 == 0)
+                                slot = radix_tree_iter_next(&iter);
+                }
+                rcu_read_unlock();
+        }
+
+        return NULL;
+}
+
+/*
+ * Randomly remove entries to help induce radix_tree_iter_retry() calls in the
+ * two iteration functions.
+ */
+static void *remove_entries_fn(void *arg)
+{
+        while (!test_complete) {
+                int pgoff;
+
+                pgoff = rand() % 100;
+
+                pthread_mutex_lock(&tree_lock);
+                item_delete(&tree, pgoff);
+                pthread_mutex_unlock(&tree_lock);
+        }
+
+        return NULL;
+}
+
+/* This is a unit test for a bug found by the syzkaller tester */
+void iteration_test(void)
+{
+        int i;
+
+        printf("Running iteration tests for 10 seconds\n");
+
+        srand(time(0));
+        test_complete = false;
+
+        if (pthread_create(&threads[0], NULL, tagged_iteration_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[1], NULL, untagged_iteration_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[2], NULL, add_entries_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[3], NULL, remove_entries_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+
+        sleep(10);
+        test_complete = true;
+
+        for (i = 0; i < NUM_THREADS; i++) {
+                if (pthread_join(threads[i], NULL)) {
+                        perror("pthread_join");
+                        exit(1);
+                }
+        }
+
+        item_kill_tree(&tree);
+}
diff --git a/tools/testing/radix-tree/main.c b/tools/testing/radix-tree/main.c
index b7619ff3b552..daa9010693e8 100644
--- a/tools/testing/radix-tree/main.c
+++ b/tools/testing/radix-tree/main.c
@@ -332,6 +332,7 @@ int main(int argc, char **argv)
         regression1_test();
         regression2_test();
         regression3_test();
+        iteration_test();
         single_thread_tests(long_run);
 
         sleep(1);
diff --git a/tools/testing/radix-tree/regression1.c b/tools/testing/radix-tree/regression1.c
index 2d03a63bb79c..0d6813a61b37 100644
--- a/tools/testing/radix-tree/regression1.c
+++ b/tools/testing/radix-tree/regression1.c
@@ -43,7 +43,7 @@
 #include "regression.h"
 
 static RADIX_TREE(mt_tree, GFP_KERNEL);
-static pthread_mutex_t mt_lock;
+static pthread_mutex_t mt_lock = PTHREAD_MUTEX_INITIALIZER;
 
 struct page {
         pthread_mutex_t lock;
diff --git a/tools/testing/radix-tree/test.h b/tools/testing/radix-tree/test.h
index e85131369723..217fb2403f09 100644
--- a/tools/testing/radix-tree/test.h
+++ b/tools/testing/radix-tree/test.h
@@ -27,6 +27,7 @@ void item_kill_tree(struct radix_tree_root *root);
 
 void tag_check(void);
 void multiorder_checks(void);
+void iteration_test(void);
 
 struct item *
 item_tag_set(struct radix_tree_root *root, unsigned long index, int tag);