sysctl: Move the implementation into fs/proc/proc_sysctl.c

Move the core sysctl code from kernel/sysctl.c and kernel/sysctl_check.c
into fs/proc/proc_sysctl.c.

Currently sysctl maintenance is hampered by the sysctl implementation
being split across 3 files with artificial layering between them.
Consolidate the entire sysctl implementation into 1 file so that
it is easier to see what is going on and hopefully allowing for
simpler maintenance.

For functions that are now only used in fs/proc/proc_sysctl.c remove
their declarations from sysctl.h and make them static in fs/proc/proc_sysctl.c

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>

3 files changed, 0 insertions, 625 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 2d9de86b7e76..cb41b9547c9f 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -27,7 +27,6 @@ obj-y += power/
 
 obj-$(CONFIG_FREEZER) += freezer.o
 obj-$(CONFIG_PROFILING) += profile.o
-obj-$(CONFIG_SYSCTL_SYSCALL_CHECK) += sysctl_check.o
 obj-$(CONFIG_STACKTRACE) += stacktrace.o
 obj-y += time/
 obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index ad460248acc7..b774909ed46c 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -192,20 +192,6 @@ static int sysrq_sysctl_handler(ctl_table *table, int write,
 
 #endif
 
-static struct ctl_table root_table[1];
-static struct ctl_table_root sysctl_table_root;
-static struct ctl_table_header root_table_header = {
-        {{.count = 1,
-        .ctl_table = root_table,
-        .ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),}},
-        .root = &sysctl_table_root,
-        .set = &sysctl_table_root.default_set,
-};
-static struct ctl_table_root sysctl_table_root = {
-        .root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
-        .default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
-};
-
 static struct ctl_table kern_table[];
 static struct ctl_table vm_table[];
 static struct ctl_table fs_table[];
@@ -1559,459 +1545,12 @@ static struct ctl_table dev_table[] = {
         { }
 };
 
-static DEFINE_SPINLOCK(sysctl_lock);
-
-/* called under sysctl_lock */
-static int use_table(struct ctl_table_header *p)
-{
-        if (unlikely(p->unregistering))
-                return 0;
-        p->used++;
-        return 1;
-}
-
-/* called under sysctl_lock */
-static void unuse_table(struct ctl_table_header *p)
-{
-        if (!--p->used)
-                if (unlikely(p->unregistering))
-                        complete(p->unregistering);
-}
-
-/* called under sysctl_lock, will reacquire if has to wait */
-static void start_unregistering(struct ctl_table_header *p)
-{
-        /*
-         * if p->used is 0, nobody will ever touch that entry again;
-         * we'll eliminate all paths to it before dropping sysctl_lock
-         */
-        if (unlikely(p->used)) {
-                struct completion wait;
-                init_completion(&wait);
-                p->unregistering = &wait;
-                spin_unlock(&sysctl_lock);
-                wait_for_completion(&wait);
-                spin_lock(&sysctl_lock);
-        } else {
-                /* anything non-NULL; we'll never dereference it */
-                p->unregistering = ERR_PTR(-EINVAL);
-        }
-        /*
-         * do not remove from the list until nobody holds it; walking the
-         * list in do_sysctl() relies on that.
-         */
-        list_del_init(&p->ctl_entry);
-}
-
-void sysctl_head_get(struct ctl_table_header *head)
-{
-        spin_lock(&sysctl_lock);
-        head->count++;
-        spin_unlock(&sysctl_lock);
-}
-
-void sysctl_head_put(struct ctl_table_header *head)
-{
-        spin_lock(&sysctl_lock);
-        if (!--head->count)
-                kfree_rcu(head, rcu);
-        spin_unlock(&sysctl_lock);
-}
-
-struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
-{
-        if (!head)
-                BUG();
-        spin_lock(&sysctl_lock);
-        if (!use_table(head))
-                head = ERR_PTR(-ENOENT);
-        spin_unlock(&sysctl_lock);
-        return head;
-}
-
-void sysctl_head_finish(struct ctl_table_header *head)
-{
-        if (!head)
-                return;
-        spin_lock(&sysctl_lock);
-        unuse_table(head);
-        spin_unlock(&sysctl_lock);
-}
-
-static struct ctl_table_set *
-lookup_header_set(struct ctl_table_root *root, struct nsproxy *namespaces)
-{
-        struct ctl_table_set *set = &root->default_set;
-        if (root->lookup)
-                set = root->lookup(root, namespaces);
-        return set;
-}
-
-static struct list_head *
-lookup_header_list(struct ctl_table_root *root, struct nsproxy *namespaces)
-{
-        struct ctl_table_set *set = lookup_header_set(root, namespaces);
-        return &set->list;
-}
-
-struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
-                                            struct ctl_table_header *prev)
-{
-        struct ctl_table_root *root;
-        struct list_head *header_list;
-        struct ctl_table_header *head;
-        struct list_head *tmp;
-
-        spin_lock(&sysctl_lock);
-        if (prev) {
-                head = prev;
-                tmp = &prev->ctl_entry;
-                unuse_table(prev);
-                goto next;
-        }
-        tmp = &root_table_header.ctl_entry;
-        for (;;) {
-                head = list_entry(tmp, struct ctl_table_header, ctl_entry);
-
-                if (!use_table(head))
-                        goto next;
-                spin_unlock(&sysctl_lock);
-                return head;
-        next:
-                root = head->root;
-                tmp = tmp->next;
-                header_list = lookup_header_list(root, namespaces);
-                if (tmp != header_list)
-                        continue;
-
-                do {
-                        root = list_entry(root->root_list.next,
-                                        struct ctl_table_root, root_list);
-                        if (root == &sysctl_table_root)
-                                goto out;
-                        header_list = lookup_header_list(root, namespaces);
-                } while (list_empty(header_list));
-                tmp = header_list->next;
-        }
-out:
-        spin_unlock(&sysctl_lock);
-        return NULL;
-}
-
-struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev)
-{
-        return __sysctl_head_next(current->nsproxy, prev);
-}
-
-void register_sysctl_root(struct ctl_table_root *root)
-{
-        spin_lock(&sysctl_lock);
-        list_add_tail(&root->root_list, &sysctl_table_root.root_list);
-        spin_unlock(&sysctl_lock);
-}
-
-/*
- * sysctl_perm does NOT grant the superuser all rights automatically, because
- * some sysctl variables are readonly even to root.
- */
-
-static int test_perm(int mode, int op)
-{
-        if (!current_euid())