Commit b8cbc085 authored by Joel Granados's avatar Joel Granados Committed by Luis Chamberlain
Browse files

sysctl: Remove register_sysctl_table 



This is part of the general push to deprecate register_sysctl_paths and
register_sysctl_table. After removing all the calling functions, we
remove both the register_sysctl_table function and the documentation
check that appeared in check-sysctl-docs awk script.

We save 595 bytes with this change:

./scripts/bloat-o-meter vmlinux.1.refactor-base-paths vmlinux.2.remove-sysctl-table
add/remove: 2/8 grow/shrink: 1/0 up/down: 1154/-1749 (-595)
Function                                     old     new   delta
count_subheaders                               -     983    +983
unregister_sysctl_table                       29     184    +155
__pfx_count_subheaders                         -      16     +16
__pfx_unregister_sysctl_table.part            16       -     -16
__pfx_register_leaf_sysctl_tables.constprop   16       -     -16
__pfx_count_subheaders.part                   16       -     -16
__pfx___register_sysctl_base                  16       -     -16
unregister_sysctl_table.part                 136       -    -136
__register_sysctl_base                       478       -    -478
register_leaf_sysctl_tables.constprop        524       -    -524
count_subheaders.part                        547       -    -547
Total: Before=21257652, After=21257057, chg -0.00%

[mcgrof: remove register_leaf_sysctl_tables and append_path too and
 add bloat-o-meter stats]

Signed-off-by: default avatarJoel Granados <j.granados@samsung.com>
Signed-off-by: default avatarLuis Chamberlain <mcgrof@kernel.org>
Acked-by: default avatarChristian Brauner <brauner@kernel.org>
parent 2f5edd03

fs/proc/proc_sysctl.c

+0 −159
Original line number Diff line number Diff line
@@ -1466,19 +1466,6 @@ void __init __register_sysctl_init(const char *path, struct ctl_table *table, 
	kmemleak_not_leak(hdr);

}



static char *append_path(const char *path, char *pos, const char *name)

{

	int namelen;

	namelen = strlen(name);

	if (((pos - path) + namelen + 2) >= PATH_MAX)

		return NULL;

	memcpy(pos, name, namelen);

	pos[namelen] = '/';

	pos[namelen + 1] = '\0';

	pos += namelen + 1;

	return pos;

}



static int count_subheaders(struct ctl_table *table)

{

	int has_files = 0;
@@ -1498,152 +1485,6 @@ static int count_subheaders(struct ctl_table *table) 
	return nr_subheaders + has_files;

}



static int register_leaf_sysctl_tables(const char *path, char *pos,

	struct ctl_table_header ***subheader, struct ctl_table_set *set,

	struct ctl_table *table)

{

	struct ctl_table *ctl_table_arg = NULL;

	struct ctl_table *entry, *files;

	int nr_files = 0;

	int nr_dirs = 0;

	int err = -ENOMEM;



	list_for_each_table_entry(entry, table) {

		if (entry->child)

			nr_dirs++;

		else

			nr_files++;

	}



	files = table;

	/* If there are mixed files and directories we need a new table */

	if (nr_dirs && nr_files) {

		struct ctl_table *new;

		files = kcalloc(nr_files + 1, sizeof(struct ctl_table),

				GFP_KERNEL);

		if (!files)

			goto out;



		ctl_table_arg = files;

		new = files;



		list_for_each_table_entry(entry, table) {

			if (entry->child)

				continue;

			*new = *entry;

			new++;

		}

	}



	/* Register everything except a directory full of subdirectories */

	if (nr_files || !nr_dirs) {

		struct ctl_table_header *header;

		header = __register_sysctl_table(set, path, files);

		if (!header) {

			kfree(ctl_table_arg);

			goto out;

		}



		/* Remember if we need to free the file table */

		header->ctl_table_arg = ctl_table_arg;

		**subheader = header;

		(*subheader)++;

	}



	/* Recurse into the subdirectories. */

	list_for_each_table_entry(entry, table) {

		char *child_pos;



		if (!entry->child)

			continue;



		err = -ENAMETOOLONG;

		child_pos = append_path(path, pos, entry->procname);

		if (!child_pos)

			goto out;



		err = register_leaf_sysctl_tables(path, child_pos, subheader,

						  set, entry->child);

		pos[0] = '\0';

		if (err)

			goto out;

	}

	err = 0;

out:

	/* On failure our caller will unregister all registered subheaders */

	return err;

}



/**

 * 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.

 * We are slowly deprecating this call so avoid its use.

 */

static struct ctl_table_header *register_sysctl_table(struct ctl_table *table)

{

	struct ctl_table *ctl_table_arg = table;

	int nr_subheaders = count_subheaders(table);

	struct ctl_table_header *header = NULL, **subheaders, **subheader;

	char *new_path, *pos;



	pos = new_path = kmalloc(PATH_MAX, GFP_KERNEL);

	if (!new_path)

		return NULL;



	pos[0] = '\0';

	while (table->procname && table->child && !table[1].procname) {

		pos = append_path(new_path, pos, table->procname);

		if (!pos)

			goto out;

		table = table->child;

	}

	if (nr_subheaders == 1) {

		header = __register_sysctl_table(&sysctl_table_root.default_set, new_path, table);

		if (header)

			header->ctl_table_arg = ctl_table_arg;

	} else {

		header = kzalloc(sizeof(*header) +

				 sizeof(*subheaders)*nr_subheaders, GFP_KERNEL);

		if (!header)

			goto out;



		subheaders = (struct ctl_table_header **) (header + 1);

		subheader = subheaders;

		header->ctl_table_arg = ctl_table_arg;



		if (register_leaf_sysctl_tables(new_path, pos, &subheader,

						&sysctl_table_root.default_set, table))

			goto err_register_leaves;

	}



out:

	kfree(new_path);

	return header;



err_register_leaves:

	while (subheader > subheaders) {

		struct ctl_table_header *subh = *(--subheader);

		struct ctl_table *table = subh->ctl_table_arg;

		unregister_sysctl_table(subh);

		kfree(table);

	}

	kfree(header);

	header = NULL;

	goto out;

}



int __register_sysctl_base(struct ctl_table *base_table)

{

	struct ctl_table_header *hdr;



	hdr = register_sysctl_table(base_table);

	kmemleak_not_leak(hdr);

	return 0;

}



static void put_links(struct ctl_table_header *header)

{

	struct ctl_table_set *root_set = &sysctl_table_root.default_set;

scripts/check-sysctl-docs

+0 −10
Original line number Diff line number Diff line
@@ -146,16 +146,6 @@ curtable && /\.procname[\t ]*=[\t ]*".+"/ { 
    children[curtable][curentry] = child

}



/register_sysctl_table\(.*\)/ {

    match($0, /register_sysctl_table\(([^)]+)\)/, tables)

    if (debug) print "Registering table " tables[1]

    if (children[tables[1]][table]) {

	for (entry in entries[children[tables[1]][table]]) {

	    printentry(entry)

	}

    }

}



END {

    for (entry in documented) {

	if (!seen[entry]) {