Merge git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/sysctl

Pull sysctl updates from Eric Biederman:

 - Rewrite of sysctl for speed and clarity.

   Insert/remove/Lookup in sysctl are all now O(NlogN) operations, and
   are no longer bottlenecks in the process of adding and removing
   network devices.

   sysctl is now focused on being a filesystem instead of system call
   and the code can all be found in fs/proc/proc_sysctl.c.  Hopefully
   this means the code is now approachable.

   Much thanks is owed to Lucian Grinjincu for keeping at this until
   something was found that was usable.

 - The recent proc_sys_poll oops found by the fuzzer during hibernation
   is fixed.

* git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/sysctl: (36 commits)
  sysctl: protect poll() in entries that may go away
  sysctl: Don't call sysctl_follow_link unless we are a link.
  sysctl: Comments to make the code clearer.
  sysctl: Correct error return from get_subdir
  sysctl: An easier to read version of find_subdir
  sysctl: fix memset parameters in setup_sysctl_set()
  sysctl: remove an unused variable
  sysctl: Add register_sysctl for normal sysctl users
  sysctl: Index sysctl directories with rbtrees.
  sysctl: Make the header lists per directory.
  sysctl: Move sysctl_check_dups into insert_header
  sysctl: Modify __register_sysctl_paths to take a set instead of a root and an nsproxy
  sysctl: Replace root_list with links between sysctl_table_sets.
  sysctl: Add sysctl_print_dir and use it in get_subdir
  sysctl: Stop requiring explicit management of sysctl directories
  sysctl: Add a root pointer to ctl_table_set
  sysctl: Rewrite proc_sys_readdir in terms of first_entry and next_entry
  sysctl: Rewrite proc_sys_lookup introducing find_entry and lookup_entry.
  sysctl: Normalize the root_table data structure.
  sysctl: Factor out insert_header and erase_header
  ...

8 files changed, 1280 insertions, 797 deletions

diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index c44efe19798f..5f79bb8b4c60 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -10,12 +10,15 @@
  */
 
 #include <linux/proc_fs.h>
+struct  ctl_table_header;
 
 extern struct proc_dir_entry proc_root;
 #ifdef CONFIG_PROC_SYSCTL
 extern int proc_sys_init(void);
+extern void sysctl_head_put(struct ctl_table_header *head);
 #else
 static inline void proc_sys_init(void) { }
+static inline void sysctl_head_put(struct ctl_table_header *head) { }
 #endif
 #ifdef CONFIG_NET
 extern int proc_net_init(void);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 67bbf6e4e197..21d836f40292 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -9,6 +9,7 @@
 #include <linux/sched.h>
 #include <linux/namei.h>
 #include <linux/mm.h>
+#include <linux/module.h>
 #include "internal.h"
 
 static const struct dentry_operations proc_sys_dentry_operations;
@@ -26,6 +27,371 @@ void proc_sys_poll_notify(struct ctl_table_poll *poll)
         wake_up_interruptible(&poll->wait);
 }
 
+static struct ctl_table root_table[] = {
+        {
+                .procname = "",
+                .mode = S_IFDIR|S_IRUGO|S_IXUGO,
+        },
+        { }
+};
+static struct ctl_table_root sysctl_table_root = {
+        .default_set.dir.header = {
+                {{.count = 1,
+                  .nreg = 1,
+                  .ctl_table = root_table }},
+                .ctl_table_arg = root_table,
+                .root = &sysctl_table_root,
+                .set = &sysctl_table_root.default_set,
+        },
+};
+
+static DEFINE_SPINLOCK(sysctl_lock);
+
+static void drop_sysctl_table(struct ctl_table_header *header);
+static int sysctl_follow_link(struct ctl_table_header **phead,
+        struct ctl_table **pentry, struct nsproxy *namespaces);
+static int insert_links(struct ctl_table_header *head);
+static void put_links(struct ctl_table_header *header);
+
+static void sysctl_print_dir(struct ctl_dir *dir)
+{
+        if (dir->header.parent)
+                sysctl_print_dir(dir->header.parent);
+        printk(KERN_CONT "%s/", dir->header.ctl_table[0].procname);
+}
+
+static int namecmp(const char *name1, int len1, const char *name2, int len2)
+{
+        int minlen;
+        int cmp;
+
+        minlen = len1;
+        if (minlen > len2)
+                minlen = len2;
+
+        cmp = memcmp(name1, name2, minlen);
+        if (cmp == 0)
+                cmp = len1 - len2;
+        return cmp;
+}
+
+/* Called under sysctl_lock */
+static struct ctl_table *find_entry(struct ctl_table_header **phead,
+        struct ctl_dir *dir, const char *name, int namelen)
+{
+        struct ctl_table_header *head;
+        struct ctl_table *entry;
+        struct rb_node *node = dir->root.rb_node;
+
+        while (node)
+        {
+                struct ctl_node *ctl_node;
+                const char *procname;
+                int cmp;
+
+                ctl_node = rb_entry(node, struct ctl_node, node);
+                head = ctl_node->header;
+                entry = &head->ctl_table[ctl_node - head->node];
+                procname = entry->procname;
+
+                cmp = namecmp(name, namelen, procname, strlen(procname));
+                if (cmp < 0)
+                        node = node->rb_left;
+                else if (cmp > 0)
+                        node = node->rb_right;
+                else {
+                        *phead = head;
+                        return entry;
+                }
+        }
+        return NULL;
+}
+
+static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry)
+{
+        struct rb_node *node = &head->node[entry - head->ctl_table].node;
+        struct rb_node **p = &head->parent->root.rb_node;
+        struct rb_node *parent = NULL;
+        const char *name = entry->procname;
+        int namelen = strlen(name);
+
+        while (*p) {
+                struct ctl_table_header *parent_head;
+                struct ctl_table *parent_entry;
+                struct ctl_node *parent_node;
+                const char *parent_name;
+                int cmp;
+
+                parent = *p;
+                parent_node = rb_entry(parent, struct ctl_node, node);
+                parent_head = parent_node->header;
+                parent_entry = &parent_head->ctl_table[parent_node - parent_head->node];
+                parent_name = parent_entry->procname;
+
+                cmp = namecmp(name, namelen, parent_name, strlen(parent_name));
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else if (cmp > 0)
+                        p = &(*p)->rb_right;
+                else {
+                        printk(KERN_ERR "sysctl duplicate entry: ");
+                        sysctl_print_dir(head->parent);
+                        printk(KERN_CONT "/%s\n", entry->procname);
+                        return -EEXIST;
+                }
+        }
+
+        rb_link_node(node, parent, p);
+        return 0;
+}
+
+static void erase_entry(struct ctl_table_header *head, struct ctl_table *entry)
+{
+        struct rb_node *node = &head->node[entry - head->ctl_table].node;
+
+        rb_erase(node, &head->parent->root);
+}
+
+static void init_header(struct ctl_table_header *head,
+        struct ctl_table_root *root, struct ctl_table_set *set,
+        struct ctl_node *node, struct ctl_table *table)
+{
+        head->ctl_table = table;
+        head->ctl_table_arg = table;
+        head->used = 0;
+        head->count = 1;
+        head->nreg = 1;
+        head->unregistering = NULL;
+        head->root = root;
+        head->set = set;
+        head->parent = NULL;
+        head->node = node;
+        if (node) {
+                struct ctl_table *entry;
+                for (entry = table; entry->procname; entry++, node++) {
+                        rb_init_node(&node->node);
+                        node->header = head;