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>

1 files changed, 0 insertions, 464 deletions

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())
-                mode >>= 6;
-        else if (in_egroup_p(0))
-                mode >>= 3;
-        if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
-                return 0;
-        return -EACCES;
-}
-
-int sysctl_perm(struct ctl_table_root *root, struct ctl_table *table, int op)
-{
-        int mode;
-
-        if (root->permissions)
-                mode = root->permissions(root, current->nsproxy, table);
-        else
-                mode = table->mode;
-
-        return test_perm(mode, op);
-}
-
-static void sysctl_set_parent(struct ctl_table *parent, struct ctl_table *table)
-{
-        for (; table->procname; table++) {
-                table->parent = parent;
-                if (table->child)
-                        sysctl_set_parent(table, table->child);
-        }
-}
-
 int __init sysctl_init(void)
 {
         register_sysctl_table(sysctl_base_table);
         return 0;
 }
 
-static struct ctl_table *is_branch_in(struct ctl_table *branch,
-                                      struct ctl_table *table)
-{
-        struct ctl_table *p;
-        const char *s = branch->procname;
-
-        /* branch should have named subdirectory as its first element */
-        if (!s || !branch->child)
-                return NULL;
-
-        /* ... and nothing else */
-        if (branch[1].procname)
-                return NULL;
-
-        /* table should contain subdirectory with the same name */
-        for (p = table; p->procname; p++) {
-                if (!p->child)
-                        continue;
-                if (p->procname && strcmp(p->procname, s) == 0)
-                        return p;
-        }
-        return NULL;
-}
-
-/* see if attaching q to p would be an improvement */
-static void try_attach(struct ctl_table_header *p, struct ctl_table_header *q)
-{
-        struct ctl_table *to = p->ctl_table, *by = q->ctl_table;
-        struct ctl_table *next;
-        int is_better = 0;
-        int not_in_parent = !p->attached_by;
-
-        while ((next = is_branch_in(by, to)) != NULL) {
-                if (by == q->attached_by)
-                        is_better = 1;
-                if (to == p->attached_by)
-                        not_in_parent = 1;
-                by = by->child;
-                to = next->child;
-        }
-
-        if (is_better && not_in_parent) {
-                q->attached_by = by;
-                q->attached_to = to;
-                q->parent = p;
-        }
-}
-
-/**
- * __register_sysctl_paths - register a sysctl hierarchy
- * @root: List of sysctl headers to register on
- * @namespaces: Data to compute which lists of sysctl entries are visible
- * @path: The path to the directory the sysctl table is in.
- * @table: the top-level table structure
- *
- * Register a sysctl table hierarchy. @table should be a filled in ctl_table
- * array. A completely 0 filled entry terminates the table.
- *
- * The members of the &struct ctl_table structure are used as follows:
- *
- * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
- *            enter a sysctl file
- *
- * data - a pointer to data for use by proc_handler
- *
- * maxlen - the maximum size in bytes of the data
- *
- * mode - the file permissions for the /proc/sys file, and for sysctl(2)
- *
- * child - a pointer to the child sysctl table if this entry is a directory, or
- *         %NULL.
- *
- * proc_handler - the text handler routine (described below)
- *
- * de - for internal use by the sysctl routines
- *
- * extra1, extra2 - extra pointers usable by the proc handler routines
- *
- * Leaf nodes in the sysctl tree will be represented by a single file
- * under /proc; non-leaf nodes will be represented by directories.
- *
- * sysctl(2) can automatically manage read and write requests through
- * the sysctl table.  The data and maxlen fields of the ctl_table
- * struct enable minimal validation of the values being written to be
- * performed, and the mode field allows minimal authentication.
- *
- * There must be a proc_handler routine for any terminal nodes
- * mirrored under /proc/sys (non-terminals are handled by a built-in
- * directory handler).  Several default handlers are available to
- * cover common cases -
- *
- * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
- * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(), 
- * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
- *
- * It is the handler's job to read the input buffer from user memory
- * and process it. The handler should return 0 on success.
- *
- * This routine returns %NULL on a failure to register, and a pointer
- * to the table header on success.
- */
-struct ctl_table_header *__register_sysctl_paths(
-        struct ctl_table_root *root,
-        struct nsproxy *namespaces,
-        const struct ctl_path *path, struct ctl_table *table)
-{
-        struct ctl_table_header *header;
-        struct ctl_table *new, **prevp;
-        unsigned int n, npath;
-        struct ctl_table_set *set;
-
-        /* Count the path components */
-        for (npath = 0; path[npath].procname; ++npath)
-                ;
-
-        /*
-         * For each path component, allocate a 2-element ctl_table array.
-         * The first array element will be filled with the sysctl entry
-         * for this, the second will be the sentinel (procname == 0).
-         *
-         * We allocate everything in one go so that we don't have to
-         * worry about freeing additional memory in unregister_sysctl_table.
-         */
-        header = kzalloc(sizeof(struct ctl_table_header) +
-                         (2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
-        if (!header)
-                return NULL;
-
-        new = (struct ctl_table *) (header + 1);
-
-        /* Now connect the dots */
-        prevp = &header->ctl_table;
-        for (n = 0; n < npath; ++n, ++path) {
-                /* Copy the procname */
-                new->procname = path->procname;
-                new->mode     = 0555;
-
-                *prevp = new;
-                prevp = &new->child;
-
-                new += 2;
-        }
-        *prevp = table;
-        header->ctl_table_arg = table;
-
-        INIT_LIST_HEAD(&header->ctl_entry);
-        header->used = 0;
-        header->unregistering = NULL;
-        header->root = root;
-        sysctl_set_parent(NULL, header->ctl_table);
-        header->count = 1;
-#ifdef CONFIG_SYSCTL_SYSCALL_CHECK
-        if (sysctl_check_table(namespaces, header->ctl_table)) {
-                kfree(header);
-                return NULL;
-        }
-#endif
-        spin_lock(&sysctl_lock);
-        header->set = lookup_header_set(root, namespaces);
-        header->attached_by = header->ctl_table;
-        header->attached_to = root_table;
-        header->parent = &root_table_header;
-        for (set = header->set; set; set = set->parent) {
-                struct ctl_table_header *p;
-                list_for_each_entry(p, &set->list, ctl_entry) {
-                        if (p->unregistering)
-                                continue;
-                        try_attach(p, header);
-                }
-        }
-        header->parent->count++;
-        list_add_tail(&header->ctl_entry, &header->set->list);
-        spin_unlock(&sysctl_lock);
-
-        return header;
-}
-
-/**
- * register_sysctl_table_path - register a sysctl table hierarchy
- * @path: The path to the directory the sysctl table is in.
- * @table: the top-level table structure
- *
- * Register a sysctl table hierarchy. @table should be a filled in ctl_table
- * array. A completely 0 filled entry terminates the table.
- *
- * See __register_sysctl_paths for more details.
- */
-struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
-                                                struct ctl_table *table)
-{
-        return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,
-                                        path, table);
-}
-
-/**
- * register_sysctl_table - register a sysctl table hierarchy
- * @table: the top-level table structure
- *
- * Register a sysctl table hierarchy. @table should be a filled in ctl_table
- * array. A completely 0 filled entry terminates the table.
- *
- * See register_sysctl_paths for more details.
- */
-struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
-{
-        static const struct ctl_path null_path[] = { {} };
-
-        return register_sysctl_paths(null_path, table);
-}
-
-/**
- * unregister_sysctl_table - unregister a sysctl table hierarchy
- * @header: the header returned from register_sysctl_table
- *
- * Unregisters the sysctl table and all children. proc entries may not
- * actually be removed until they are no longer used by anyone.
- */
-void unregister_sysctl_table(struct ctl_table_header * header)
-{
-        might_sleep();
-
-        if (header == NULL)
-                return;
-
-        spin_lock(&sysctl_lock);
-        start_unregistering(header);
-        if (!--header->parent->count) {
-                WARN_ON(1);
-                kfree_rcu(header->parent, rcu);
-        }
-        if (!--header->count)
-                kfree_rcu(header, rcu);
-        spin_unlock(&sysctl_lock);
-}
-
-int sysctl_is_seen(struct ctl_table_header *p)
-{
-        struct ctl_table_set *set = p->set;
-        int res;
-        spin_lock(&sysctl_lock);
-        if (p->unregistering)
-                res = 0;
-        else if (!set->is_seen)
-                res = 1;
-        else
-                res = set->is_seen(set);
-        spin_unlock(&sysctl_lock);
-        return res;
-}
-
-void setup_sysctl_set(struct ctl_table_set *p,
-        struct ctl_table_set *parent,
-        int (*is_seen)(struct ctl_table_set *))
-{
-        INIT_LIST_HEAD(&p->list);
-        p->parent = parent ? parent : &sysctl_table_root.default_set;
-        p->is_seen = is_seen;
-}
-
 #endif /* CONFIG_SYSCTL */
 
 /*
@@ -2977,6 +2516,3 @@ EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
 EXPORT_SYMBOL(proc_dostring);
 EXPORT_SYMBOL(proc_doulongvec_minmax);
 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
-EXPORT_SYMBOL(register_sysctl_table);
-EXPORT_SYMBOL(register_sysctl_paths);
-EXPORT_SYMBOL(unregister_sysctl_table);