1/*
   2 * /proc/sys support
   3 */
   4#include <linux/init.h>
   5#include <linux/sysctl.h>
   6#include <linux/poll.h>
   7#include <linux/proc_fs.h>
   8#include <linux/printk.h>
   9#include <linux/security.h>
  10#include <linux/sched.h>
  11#include <linux/namei.h>
  12#include <linux/mm.h>
  13#include <linux/module.h>
  14#include "internal.h"
  15
  16static const struct dentry_operations proc_sys_dentry_operations;
  17static const struct file_operations proc_sys_file_operations;
  18static const struct inode_operations proc_sys_inode_operations;
  19static const struct file_operations proc_sys_dir_file_operations;
  20static const struct inode_operations proc_sys_dir_operations;
  21
  22/* Support for permanently empty directories */
  23
  24struct ctl_table sysctl_mount_point[] = {
  25	{ }
  26};
  27
  28static bool is_empty_dir(struct ctl_table_header *head)
  29{
  30	return head->ctl_table[0].child == sysctl_mount_point;
  31}
  32
  33static void set_empty_dir(struct ctl_dir *dir)
  34{
  35	dir->header.ctl_table[0].child = sysctl_mount_point;
  36}
  37
  38static void clear_empty_dir(struct ctl_dir *dir)
  39
  40{
  41	dir->header.ctl_table[0].child = NULL;
  42}
  43
  44void proc_sys_poll_notify(struct ctl_table_poll *poll)
  45{
  46	if (!poll)
  47		return;
  48
  49	atomic_inc(&poll->event);
  50	wake_up_interruptible(&poll->wait);
  51}
  52
  53static struct ctl_table root_table[] = {
  54	{
  55		.procname = "",
  56		.mode = S_IFDIR|S_IRUGO|S_IXUGO,
  57	},
  58	{ }
  59};
  60static struct ctl_table_root sysctl_table_root = {
  61	.default_set.dir.header = {
  62		{{.count = 1,
  63		  .nreg = 1,
  64		  .ctl_table = root_table }},
  65		.ctl_table_arg = root_table,
  66		.root = &sysctl_table_root,
  67		.set = &sysctl_table_root.default_set,
  68	},
  69};
  70
  71static DEFINE_SPINLOCK(sysctl_lock);
  72
  73static void drop_sysctl_table(struct ctl_table_header *header);
  74static int sysctl_follow_link(struct ctl_table_header **phead,
  75	struct ctl_table **pentry);
  76static int insert_links(struct ctl_table_header *head);
  77static void put_links(struct ctl_table_header *header);
  78
  79static void sysctl_print_dir(struct ctl_dir *dir)
  80{
  81	if (dir->header.parent)
  82		sysctl_print_dir(dir->header.parent);
  83	pr_cont("%s/", dir->header.ctl_table[0].procname);
  84}
  85
  86static int namecmp(const char *name1, int len1, const char *name2, int len2)
  87{
  88	int minlen;
  89	int cmp;
  90
  91	minlen = len1;
  92	if (minlen > len2)
  93		minlen = len2;
  94
  95	cmp = memcmp(name1, name2, minlen);
  96	if (cmp == 0)
  97		cmp = len1 - len2;
  98	return cmp;
  99}
 100
 101/* Called under sysctl_lock */
 102static struct ctl_table *find_entry(struct ctl_table_header **phead,
 103	struct ctl_dir *dir, const char *name, int namelen)
 104{
 105	struct ctl_table_header *head;
 106	struct ctl_table *entry;
 107	struct rb_node *node = dir->root.rb_node;
 108
 109	while (node)
 110	{
 111		struct ctl_node *ctl_node;
 112		const char *procname;
 113		int cmp;
 114
 115		ctl_node = rb_entry(node, struct ctl_node, node);
 116		head = ctl_node->header;
 117		entry = &head->ctl_table[ctl_node - head->node];
 118		procname = entry->procname;
 119
 120		cmp = namecmp(name, namelen, procname, strlen(procname));
 121		if (cmp < 0)
 122			node = node->rb_left;
 123		else if (cmp > 0)
 124			node = node->rb_right;
 125		else {
 126			*phead = head;
 127			return entry;
 128		}
 129	}
 130	return NULL;
 131}
 132
 133static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry)
 134{
 135	struct rb_node *node = &head->node[entry - head->ctl_table].node;
 136	struct rb_node **p = &head->parent->root.rb_node;
 137	struct rb_node *parent = NULL;
 138	const char *name = entry->procname;
 139	int namelen = strlen(name);
 140
 141	while (*p) {
 142		struct ctl_table_header *parent_head;
 143		struct ctl_table *parent_entry;
 144		struct ctl_node *parent_node;
 145		const char *parent_name;
 146		int cmp;
 147
 148		parent = *p;
 149		parent_node = rb_entry(parent, struct ctl_node, node);
 150		parent_head = parent_node->header;
 151		parent_entry = &parent_head->ctl_table[parent_node - parent_head->node];
 152		parent_name = parent_entry->procname;
 153
 154		cmp = namecmp(name, namelen, parent_name, strlen(parent_name));
 155		if (cmp < 0)
 156			p = &(*p)->rb_left;
 157		else if (cmp > 0)
 158			p = &(*p)->rb_right;
 159		else {
 160			pr_err("sysctl duplicate entry: ");
 161			sysctl_print_dir(head->parent);
 162			pr_cont("/%s\n", entry->procname);
 163			return -EEXIST;
 164		}
 165	}
 166
 167	rb_link_node(node, parent, p);
 168	rb_insert_color(node, &head->parent->root);
 169	return 0;
 170}
 171
 172static void erase_entry(struct ctl_table_header *head, struct ctl_table *entry)
 173{
 174	struct rb_node *node = &head->node[entry - head->ctl_table].node;
 175
 176	rb_erase(node, &head->parent->root);
 177}
 178
 179static void init_header(struct ctl_table_header *head,
 180	struct ctl_table_root *root, struct ctl_table_set *set,
 181	struct ctl_node *node, struct ctl_table *table)
 182{
 183	head->ctl_table = table;
 184	head->ctl_table_arg = table;
 185	head->used = 0;
 186	head->count = 1;
 187	head->nreg = 1;
 188	head->unregistering = NULL;
 189	head->root = root;
 190	head->set = set;
 191	head->parent = NULL;
 192	head->node = node;
 193	if (node) {
 194		struct ctl_table *entry;
 195		for (entry = table; entry->procname; entry++, node++)
 
 196			node->header = head;
 
 197	}
 198}
 199
 200static void erase_header(struct ctl_table_header *head)
 201{
 202	struct ctl_table *entry;
 203	for (entry = head->ctl_table; entry->procname; entry++)
 204		erase_entry(head, entry);
 205}
 206
 207static int insert_header(struct ctl_dir *dir, struct ctl_table_header *header)
 208{
 209	struct ctl_table *entry;
 210	int err;
 211
 212	/* Is this a permanently empty directory? */
 213	if (is_empty_dir(&dir->header))
 214		return -EROFS;
 215
 216	/* Am I creating a permanently empty directory? */
 217	if (header->ctl_table == sysctl_mount_point) {
 218		if (!RB_EMPTY_ROOT(&dir->root))
 219			return -EINVAL;
 220		set_empty_dir(dir);
 221	}
 222
 223	dir->header.nreg++;
 224	header->parent = dir;
 225	err = insert_links(header);
 226	if (err)
 227		goto fail_links;
 228	for (entry = header->ctl_table; entry->procname; entry++) {
 229		err = insert_entry(header, entry);
 230		if (err)
 231			goto fail;
 232	}
 233	return 0;
 234fail:
 235	erase_header(header);
 236	put_links(header);
 237fail_links:
 238	if (header->ctl_table == sysctl_mount_point)
 239		clear_empty_dir(dir);
 240	header->parent = NULL;
 241	drop_sysctl_table(&dir->header);
 242	return err;
 243}
 244
 245/* called under sysctl_lock */
 246static int use_table(struct ctl_table_header *p)
 247{
 248	if (unlikely(p->unregistering))
 249		return 0;
 250	p->used++;
 251	return 1;
 252}
 253
 254/* called under sysctl_lock */
 255static void unuse_table(struct ctl_table_header *p)
 256{
 257	if (!--p->used)
 258		if (unlikely(p->unregistering))
 259			complete(p->unregistering);
 260}
 261
 262/* called under sysctl_lock, will reacquire if has to wait */
 263static void start_unregistering(struct ctl_table_header *p)
 264{
 265	/*
 266	 * if p->used is 0, nobody will ever touch that entry again;
 267	 * we'll eliminate all paths to it before dropping sysctl_lock
 268	 */
 269	if (unlikely(p->used)) {
 270		struct completion wait;
 271		init_completion(&wait);
 272		p->unregistering = &wait;
 273		spin_unlock(&sysctl_lock);
 274		wait_for_completion(&wait);
 275		spin_lock(&sysctl_lock);
 276	} else {
 277		/* anything non-NULL; we'll never dereference it */
 278		p->unregistering = ERR_PTR(-EINVAL);
 279	}
 280	/*
 281	 * do not remove from the list until nobody holds it; walking the
 282	 * list in do_sysctl() relies on that.
 283	 */
 284	erase_header(p);
 285}
 286
 287static void sysctl_head_get(struct ctl_table_header *head)
 288{
 289	spin_lock(&sysctl_lock);
 290	head->count++;
 291	spin_unlock(&sysctl_lock);
 292}
 293
 294void sysctl_head_put(struct ctl_table_header *head)
 295{
 296	spin_lock(&sysctl_lock);
 297	if (!--head->count)
 298		kfree_rcu(head, rcu);
 299	spin_unlock(&sysctl_lock);
 300}
 301
 302static struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
 303{
 304	BUG_ON(!head);
 
 305	spin_lock(&sysctl_lock);
 306	if (!use_table(head))
 307		head = ERR_PTR(-ENOENT);
 308	spin_unlock(&sysctl_lock);
 309	return head;
 310}
 311
 312static void sysctl_head_finish(struct ctl_table_header *head)
 313{
 314	if (!head)
 315		return;
 316	spin_lock(&sysctl_lock);
 317	unuse_table(head);
 318	spin_unlock(&sysctl_lock);
 319}
 320
 321static struct ctl_table_set *
 322lookup_header_set(struct ctl_table_root *root)
 323{
 324	struct ctl_table_set *set = &root->default_set;
 325	if (root->lookup)
 326		set = root->lookup(root);
 327	return set;
 328}
 329
 330static struct ctl_table *lookup_entry(struct ctl_table_header **phead,
 331				      struct ctl_dir *dir,
 332				      const char *name, int namelen)
 333{
 334	struct ctl_table_header *head;
 335	struct ctl_table *entry;
 336
 337	spin_lock(&sysctl_lock);
 338	entry = find_entry(&head, dir, name, namelen);
 339	if (entry && use_table(head))
 340		*phead = head;
 341	else
 342		entry = NULL;
 343	spin_unlock(&sysctl_lock);
 344	return entry;
 345}
 346
 347static struct ctl_node *first_usable_entry(struct rb_node *node)
 348{
 349	struct ctl_node *ctl_node;
 350
 351	for (;node; node = rb_next(node)) {
 352		ctl_node = rb_entry(node, struct ctl_node, node);
 353		if (use_table(ctl_node->header))
 354			return ctl_node;
 355	}
 356	return NULL;
 357}
 358
 359static void first_entry(struct ctl_dir *dir,
 360	struct ctl_table_header **phead, struct ctl_table **pentry)
 361{
 362	struct ctl_table_header *head = NULL;
 363	struct ctl_table *entry = NULL;
 364	struct ctl_node *ctl_node;
 365
 366	spin_lock(&sysctl_lock);
 367	ctl_node = first_usable_entry(rb_first(&dir->root));
 368	spin_unlock(&sysctl_lock);
 369	if (ctl_node) {
 370		head = ctl_node->header;
 371		entry = &head->ctl_table[ctl_node - head->node];
 372	}
 373	*phead = head;
 374	*pentry = entry;
 375}
 376
 377static void next_entry(struct ctl_table_header **phead, struct ctl_table **pentry)
 378{
 379	struct ctl_table_header *head = *phead;
 380	struct ctl_table *entry = *pentry;
 381	struct ctl_node *ctl_node = &head->node[entry - head->ctl_table];
 382
 383	spin_lock(&sysctl_lock);
 384	unuse_table(head);
 385
 386	ctl_node = first_usable_entry(rb_next(&ctl_node->node));
 387	spin_unlock(&sysctl_lock);
 388	head = NULL;
 389	if (ctl_node) {
 390		head = ctl_node->header;
 391		entry = &head->ctl_table[ctl_node - head->node];
 392	}
 393	*phead = head;
 394	*pentry = entry;
 395}
 396
 397void register_sysctl_root(struct ctl_table_root *root)
 398{
 399}
 400
 401/*
 402 * sysctl_perm does NOT grant the superuser all rights automatically, because
 403 * some sysctl variables are readonly even to root.
 404 */
 405
 406static int test_perm(int mode, int op)
 407{
 408	if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
 409		mode >>= 6;
 410	else if (in_egroup_p(GLOBAL_ROOT_GID))
 411		mode >>= 3;
 412	if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
 413		return 0;
 414	return -EACCES;
 415}
 416
 417static int sysctl_perm(struct ctl_table_header *head, struct ctl_table *table, int op)
 418{
 419	struct ctl_table_root *root = head->root;
 420	int mode;
 421
 422	if (root->permissions)
 423		mode = root->permissions(head, table);
 424	else
 425		mode = table->mode;
 426
 427	return test_perm(mode, op);
 428}
 429
 430static struct inode *proc_sys_make_inode(struct super_block *sb,
 431		struct ctl_table_header *head, struct ctl_table *table)
 432{
 433	struct ctl_table_root *root = head->root;
 434	struct inode *inode;
 435	struct proc_inode *ei;
 436
 437	inode = new_inode(sb);
 438	if (!inode)
 439		goto out;
 440
 441	inode->i_ino = get_next_ino();
 442
 443	sysctl_head_get(head);
 444	ei = PROC_I(inode);
 445	ei->sysctl = head;
 446	ei->sysctl_entry = table;
 447
 448	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
 449	inode->i_mode = table->mode;
 450	if (!S_ISDIR(table->mode)) {
 451		inode->i_mode |= S_IFREG;
 452		inode->i_op = &proc_sys_inode_operations;
 453		inode->i_fop = &proc_sys_file_operations;
 454	} else {
 455		inode->i_mode |= S_IFDIR;
 456		inode->i_op = &proc_sys_dir_operations;
 457		inode->i_fop = &proc_sys_dir_file_operations;
 458		if (is_empty_dir(head))
 459			make_empty_dir_inode(inode);
 460	}
 461
 462	if (root->set_ownership)
 463		root->set_ownership(head, table, &inode->i_uid, &inode->i_gid);
 464
 465out:
 466	return inode;
 467}
 468
 469static struct ctl_table_header *grab_header(struct inode *inode)
 470{
 471	struct ctl_table_header *head = PROC_I(inode)->sysctl;
 472	if (!head)
 473		head = &sysctl_table_root.default_set.dir.header;
 474	return sysctl_head_grab(head);
 475}
 476
 477static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
 478					unsigned int flags)
 479{
 480	struct ctl_table_header *head = grab_header(dir);
 481	struct ctl_table_header *h = NULL;
 482	const struct qstr *name = &dentry->d_name;
 483	struct ctl_table *p;
 484	struct inode *inode;
 485	struct dentry *err = ERR_PTR(-ENOENT);
 486	struct ctl_dir *ctl_dir;
 487	int ret;
 488
 489	if (IS_ERR(head))
 490		return ERR_CAST(head);
 491
 492	ctl_dir = container_of(head, struct ctl_dir, header);
 493
 494	p = lookup_entry(&h, ctl_dir, name->name, name->len);
 495	if (!p)
 496		goto out;
 497
 498	if (S_ISLNK(p->mode)) {
 499		ret = sysctl_follow_link(&h, &p);
 500		err = ERR_PTR(ret);
 501		if (ret)
 502			goto out;
 503	}
 504
 505	err = ERR_PTR(-ENOMEM);
 506	inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
 507	if (!inode)
 508		goto out;
 509
 510	err = NULL;
 511	d_set_d_op(dentry, &proc_sys_dentry_operations);
 512	d_add(dentry, inode);
 513
 514out:
 515	if (h)
 516		sysctl_head_finish(h);
 517	sysctl_head_finish(head);
 518	return err;
 519}
 520
 521static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
 522		size_t count, loff_t *ppos, int write)
 523{
 524	struct inode *inode = file_inode(filp);
 525	struct ctl_table_header *head = grab_header(inode);
 526	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 527	ssize_t error;
 528	size_t res;
 529
 530	if (IS_ERR(head))
 531		return PTR_ERR(head);
 532
 533	/*
 534	 * At this point we know that the sysctl was not unregistered
 535	 * and won't be until we finish.
 536	 */
 537	error = -EPERM;
 538	if (sysctl_perm(head, table, write ? MAY_WRITE : MAY_READ))
 539		goto out;
 540
 541	/* if that can happen at all, it should be -EINVAL, not -EISDIR */
 542	error = -EINVAL;
 543	if (!table->proc_handler)
 544		goto out;
 545
 546	/* careful: calling conventions are nasty here */
 547	res = count;
 548	error = table->proc_handler(table, write, buf, &res, ppos);
 549	if (!error)
 550		error = res;
 551out:
 552	sysctl_head_finish(head);
 553
 554	return error;
 555}
 556
 557static ssize_t proc_sys_read(struct file *filp, char __user *buf,
 558				size_t count, loff_t *ppos)
 559{
 560	return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
 561}
 562
 563static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
 564				size_t count, loff_t *ppos)
 565{
 566	return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
 567}
 568
 569static int proc_sys_open(struct inode *inode, struct file *filp)
 570{
 571	struct ctl_table_header *head = grab_header(inode);
 572	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 573
 574	/* sysctl was unregistered */
 575	if (IS_ERR(head))
 576		return PTR_ERR(head);
 577
 578	if (table->poll)
 579		filp->private_data = proc_sys_poll_event(table->poll);
 580
 581	sysctl_head_finish(head);
 582
 583	return 0;
 584}
 585
 586static unsigned int proc_sys_poll(struct file *filp, poll_table *wait)
 587{
 588	struct inode *inode = file_inode(filp);
 589	struct ctl_table_header *head = grab_header(inode);
 590	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 591	unsigned int ret = DEFAULT_POLLMASK;
 592	unsigned long event;
 593
 594	/* sysctl was unregistered */
 595	if (IS_ERR(head))
 596		return POLLERR | POLLHUP;
 597
 598	if (!table->proc_handler)
 599		goto out;
 600
 601	if (!table->poll)
 602		goto out;
 603
 604	event = (unsigned long)filp->private_data;
 605	poll_wait(filp, &table->poll->wait, wait);
 606
 607	if (event != atomic_read(&table->poll->event)) {
 608		filp->private_data = proc_sys_poll_event(table->poll);
 609		ret = POLLIN | POLLRDNORM | POLLERR | POLLPRI;
 610	}
 611
 612out:
 613	sysctl_head_finish(head);
 614
 615	return ret;
 616}
 617
 618static bool proc_sys_fill_cache(struct file *file,
 619				struct dir_context *ctx,
 620				struct ctl_table_header *head,
 621				struct ctl_table *table)
 622{
 623	struct dentry *child, *dir = file->f_path.dentry;
 624	struct inode *inode;
 625	struct qstr qname;
 626	ino_t ino = 0;
 627	unsigned type = DT_UNKNOWN;
 628
 629	qname.name = table->procname;
 630	qname.len  = strlen(table->procname);
 631	qname.hash = full_name_hash(dir, qname.name, qname.len);
 632
 633	child = d_lookup(dir, &qname);
 634	if (!child) {
 635		DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
 636		child = d_alloc_parallel(dir, &qname, &wq);
 637		if (IS_ERR(child))
 638			return false;
 639		if (d_in_lookup(child)) {
 640			inode = proc_sys_make_inode(dir->d_sb, head, table);
 641			if (!inode) {
 642				d_lookup_done(child);
 643				dput(child);
 644				return false;
 
 
 
 645			}
 646			d_set_d_op(child, &proc_sys_dentry_operations);
 647			d_add(child, inode);
 648		}
 649	}
 650	inode = d_inode(child);
 651	ino  = inode->i_ino;
 652	type = inode->i_mode >> 12;
 653	dput(child);
 654	return dir_emit(ctx, qname.name, qname.len, ino, type);
 655}
 656
 657static bool proc_sys_link_fill_cache(struct file *file,
 658				    struct dir_context *ctx,
 659				    struct ctl_table_header *head,
 660				    struct ctl_table *table)
 661{
 662	bool ret = true;
 663	head = sysctl_head_grab(head);
 664
 665	if (S_ISLNK(table->mode)) {
 666		/* It is not an error if we can not follow the link ignore it */
 667		int err = sysctl_follow_link(&head, &table);
 668		if (err)
 669			goto out;
 670	}
 671
 672	ret = proc_sys_fill_cache(file, ctx, head, table);
 673out:
 674	sysctl_head_finish(head);
 675	return ret;
 676}
 677
 678static int scan(struct ctl_table_header *head, struct ctl_table *table,
 679		unsigned long *pos, struct file *file,
 680		struct dir_context *ctx)
 681{
 682	bool res;
 683
 684	if ((*pos)++ < ctx->pos)
 685		return true;
 686
 687	if (unlikely(S_ISLNK(table->mode)))
 688		res = proc_sys_link_fill_cache(file, ctx, head, table);
 689	else
 690		res = proc_sys_fill_cache(file, ctx, head, table);
 691
 692	if (res)
 693		ctx->pos = *pos;
 694
 695	return res;
 696}
 697
 698static int proc_sys_readdir(struct file *file, struct dir_context *ctx)
 699{
 700	struct ctl_table_header *head = grab_header(file_inode(file));
 
 
 701	struct ctl_table_header *h = NULL;
 702	struct ctl_table *entry;
 703	struct ctl_dir *ctl_dir;
 704	unsigned long pos;
 
 705
 706	if (IS_ERR(head))
 707		return PTR_ERR(head);
 708
 709	ctl_dir = container_of(head, struct ctl_dir, header);
 710
 711	if (!dir_emit_dots(file, ctx))
 712		goto out;
 713
 
 
 
 
 
 
 
 
 
 
 
 714	pos = 2;
 715
 716	for (first_entry(ctl_dir, &h, &entry); h; next_entry(&h, &entry)) {
 717		if (!scan(h, entry, &pos, file, ctx)) {
 
 718			sysctl_head_finish(h);
 719			break;
 720		}
 721	}
 
 722out:
 723	sysctl_head_finish(head);
 724	return 0;
 725}
 726
 727static int proc_sys_permission(struct inode *inode, int mask)
 728{
 729	/*
 730	 * sysctl entries that are not writeable,
 731	 * are _NOT_ writeable, capabilities or not.
 732	 */
 733	struct ctl_table_header *head;
 734	struct ctl_table *table;
 735	int error;
 736
 737	/* Executable files are not allowed under /proc/sys/ */
 738	if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
 739		return -EACCES;
 740
 741	head = grab_header(inode);
 742	if (IS_ERR(head))
 743		return PTR_ERR(head);
 744
 745	table = PROC_I(inode)->sysctl_entry;
 746	if (!table) /* global root - r-xr-xr-x */
 747		error = mask & MAY_WRITE ? -EACCES : 0;
 748	else /* Use the permissions on the sysctl table entry */
 749		error = sysctl_perm(head, table, mask & ~MAY_NOT_BLOCK);
 750
 751	sysctl_head_finish(head);
 752	return error;
 753}
 754
 755static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 756{
 757	struct inode *inode = d_inode(dentry);
 758	int error;
 759
 760	if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
 761		return -EPERM;
 762
 763	error = setattr_prepare(dentry, attr);
 764	if (error)
 765		return error;
 766
 
 
 
 
 
 
 
 767	setattr_copy(inode, attr);
 768	mark_inode_dirty(inode);
 769	return 0;
 770}
 771
 772static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 773{
 774	struct inode *inode = d_inode(dentry);
 775	struct ctl_table_header *head = grab_header(inode);
 776	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 777
 778	if (IS_ERR(head))
 779		return PTR_ERR(head);
 780
 781	generic_fillattr(inode, stat);
 782	if (table)
 783		stat->mode = (stat->mode & S_IFMT) | table->mode;
 784
 785	sysctl_head_finish(head);
 786	return 0;
 787}
 788
 789static const struct file_operations proc_sys_file_operations = {
 790	.open		= proc_sys_open,
 791	.poll		= proc_sys_poll,
 792	.read		= proc_sys_read,
 793	.write		= proc_sys_write,
 794	.llseek		= default_llseek,
 795};
 796
 797static const struct file_operations proc_sys_dir_file_operations = {
 798	.read		= generic_read_dir,
 799	.iterate_shared	= proc_sys_readdir,
 800	.llseek		= generic_file_llseek,
 801};
 802
 803static const struct inode_operations proc_sys_inode_operations = {
 804	.permission	= proc_sys_permission,
 805	.setattr	= proc_sys_setattr,
 806	.getattr	= proc_sys_getattr,
 807};
 808
 809static const struct inode_operations proc_sys_dir_operations = {
 810	.lookup		= proc_sys_lookup,
 811	.permission	= proc_sys_permission,
 812	.setattr	= proc_sys_setattr,
 813	.getattr	= proc_sys_getattr,
 814};
 815
 816static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
 817{
 818	if (flags & LOOKUP_RCU)
 819		return -ECHILD;
 820	return !PROC_I(d_inode(dentry))->sysctl->unregistering;
 821}
 822
 823static int proc_sys_delete(const struct dentry *dentry)
 824{
 825	return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
 826}
 827
 828static int sysctl_is_seen(struct ctl_table_header *p)
 829{
 830	struct ctl_table_set *set = p->set;
 831	int res;
 832	spin_lock(&sysctl_lock);
 833	if (p->unregistering)
 834		res = 0;
 835	else if (!set->is_seen)
 836		res = 1;
 837	else
 838		res = set->is_seen(set);
 839	spin_unlock(&sysctl_lock);
 840	return res;
 841}
 842
 843static int proc_sys_compare(const struct dentry *dentry,
 
 
 844		unsigned int len, const char *str, const struct qstr *name)
 845{
 846	struct ctl_table_header *head;
 847	struct inode *inode;
 848
 849	/* Although proc doesn't have negative dentries, rcu-walk means
 850	 * that inode here can be NULL */
 851	/* AV: can it, indeed? */
 852	inode = d_inode_rcu(dentry);
 853	if (!inode)
 854		return 1;
 855	if (name->len != len)
 856		return 1;
 857	if (memcmp(name->name, str, len))
 858		return 1;
 859	head = rcu_dereference(PROC_I(inode)->sysctl);
 860	return !head || !sysctl_is_seen(head);
 861}
 862
 863static const struct dentry_operations proc_sys_dentry_operations = {
 864	.d_revalidate	= proc_sys_revalidate,
 865	.d_delete	= proc_sys_delete,
 866	.d_compare	= proc_sys_compare,
 867};
 868
 869static struct ctl_dir *find_subdir(struct ctl_dir *dir,
 870				   const char *name, int namelen)
 871{
 872	struct ctl_table_header *head;
 873	struct ctl_table *entry;
 874
 875	entry = find_entry(&head, dir, name, namelen);
 876	if (!entry)
 877		return ERR_PTR(-ENOENT);
 878	if (!S_ISDIR(entry->mode))
 879		return ERR_PTR(-ENOTDIR);
 880	return container_of(head, struct ctl_dir, header);
 881}
 882
 883static struct ctl_dir *new_dir(struct ctl_table_set *set,
 884			       const char *name, int namelen)
 885{
 886	struct ctl_table *table;
 887	struct ctl_dir *new;
 888	struct ctl_node *node;
 889	char *new_name;
 890
 891	new = kzalloc(sizeof(*new) + sizeof(struct ctl_node) +
 892		      sizeof(struct ctl_table)*2 +  namelen + 1,
 893		      GFP_KERNEL);
 894	if (!new)
 895		return NULL;
 896
 897	node = (struct ctl_node *)(new + 1);
 898	table = (struct ctl_table *)(node + 1);
 899	new_name = (char *)(table + 2);
 900	memcpy(new_name, name, namelen);
 901	new_name[namelen] = '\0';
 902	table[0].procname = new_name;
 903	table[0].mode = S_IFDIR|S_IRUGO|S_IXUGO;
 904	init_header(&new->header, set->dir.header.root, set, node, table);
 905
 906	return new;
 907}
 908
 909/**
 910 * get_subdir - find or create a subdir with the specified name.
 911 * @dir:  Directory to create the subdirectory in
 912 * @name: The name of the subdirectory to find or create
 913 * @namelen: The length of name
 914 *
 915 * Takes a directory with an elevated reference count so we know that
 916 * if we drop the lock the directory will not go away.  Upon success
 917 * the reference is moved from @dir to the returned subdirectory.
 918 * Upon error an error code is returned and the reference on @dir is
 919 * simply dropped.
 920 */
 921static struct ctl_dir *get_subdir(struct ctl_dir *dir,
 922				  const char *name, int namelen)
 923{
 924	struct ctl_table_set *set = dir->header.set;
 925	struct ctl_dir *subdir, *new = NULL;
 926	int err;
 927
 928	spin_lock(&sysctl_lock);
 929	subdir = find_subdir(dir, name, namelen);
 930	if (!IS_ERR(subdir))
 931		goto found;
 932	if (PTR_ERR(subdir) != -ENOENT)
 933		goto failed;
 934
 935	spin_unlock(&sysctl_lock);
 936	new = new_dir(set, name, namelen);
 937	spin_lock(&sysctl_lock);
 938	subdir = ERR_PTR(-ENOMEM);
 939	if (!new)
 940		goto failed;
 941
 942	/* Was the subdir added while we dropped the lock? */
 943	subdir = find_subdir(dir, name, namelen);
 944	if (!IS_ERR(subdir))
 945		goto found;
 946	if (PTR_ERR(subdir) != -ENOENT)
 947		goto failed;
 948
 949	/* Nope.  Use the our freshly made directory entry. */
 950	err = insert_header(dir, &new->header);
 951	subdir = ERR_PTR(err);
 952	if (err)
 953		goto failed;
 954	subdir = new;
 955found:
 956	subdir->header.nreg++;
 957failed:
 958	if (IS_ERR(subdir)) {
 959		pr_err("sysctl could not get directory: ");
 960		sysctl_print_dir(dir);
 961		pr_cont("/%*.*s %ld\n",
 962			namelen, namelen, name, PTR_ERR(subdir));
 963	}
 964	drop_sysctl_table(&dir->header);
 965	if (new)
 966		drop_sysctl_table(&new->header);
 967	spin_unlock(&sysctl_lock);
 968	return subdir;
 969}
 970
 971static struct ctl_dir *xlate_dir(struct ctl_table_set *set, struct ctl_dir *dir)
 972{
 973	struct ctl_dir *parent;
 974	const char *procname;
 975	if (!dir->header.parent)
 976		return &set->dir;
 977	parent = xlate_dir(set, dir->header.parent);
 978	if (IS_ERR(parent))
 979		return parent;
 980	procname = dir->header.ctl_table[0].procname;
 981	return find_subdir(parent, procname, strlen(procname));
 982}
 983
 984static int sysctl_follow_link(struct ctl_table_header **phead,
 985	struct ctl_table **pentry)
 986{
 987	struct ctl_table_header *head;
 988	struct ctl_table_root *root;
 989	struct ctl_table_set *set;
 990	struct ctl_table *entry;
 991	struct ctl_dir *dir;
 992	int ret;
 993
 994	ret = 0;
 995	spin_lock(&sysctl_lock);
 996	root = (*pentry)->data;
 997	set = lookup_header_set(root);
 998	dir = xlate_dir(set, (*phead)->parent);
 999	if (IS_ERR(dir))
1000		ret = PTR_ERR(dir);
1001	else {
1002		const char *procname = (*pentry)->procname;
1003		head = NULL;
1004		entry = find_entry(&head, dir, procname, strlen(procname));
1005		ret = -ENOENT;
1006		if (entry && use_table(head)) {
1007			unuse_table(*phead);
1008			*phead = head;
1009			*pentry = entry;
1010			ret = 0;
1011		}
1012	}
1013
1014	spin_unlock(&sysctl_lock);
1015	return ret;
1016}
1017
1018static int sysctl_err(const char *path, struct ctl_table *table, char *fmt, ...)
1019{
1020	struct va_format vaf;
1021	va_list args;
1022
1023	va_start(args, fmt);
1024	vaf.fmt = fmt;
1025	vaf.va = &args;
1026
1027	pr_err("sysctl table check failed: %s/%s %pV\n",
1028	       path, table->procname, &vaf);
1029
1030	va_end(args);
1031	return -EINVAL;
1032}
1033
1034static int sysctl_check_table(const char *path, struct ctl_table *table)
1035{
1036	int err = 0;
1037	for (; table->procname; table++) {
1038		if (table->child)
1039			err = sysctl_err(path, table, "Not a file");
1040
1041		if ((table->proc_handler == proc_dostring) ||
1042		    (table->proc_handler == proc_dointvec) ||
1043		    (table->proc_handler == proc_dointvec_minmax) ||
1044		    (table->proc_handler == proc_dointvec_jiffies) ||
1045		    (table->proc_handler == proc_dointvec_userhz_jiffies) ||
1046		    (table->proc_handler == proc_dointvec_ms_jiffies) ||
1047		    (table->proc_handler == proc_doulongvec_minmax) ||
1048		    (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
1049			if (!table->data)
1050				err = sysctl_err(path, table, "No data");
1051			if (!table->maxlen)
1052				err = sysctl_err(path, table, "No maxlen");
1053		}
1054		if (!table->proc_handler)
1055			err = sysctl_err(path, table, "No proc_handler");
1056
1057		if ((table->mode & (S_IRUGO|S_IWUGO)) != table->mode)
1058			err = sysctl_err(path, table, "bogus .mode 0%o",
1059				table->mode);
1060	}
1061	return err;
1062}
1063
1064static struct ctl_table_header *new_links(struct ctl_dir *dir, struct ctl_table *table,
1065	struct ctl_table_root *link_root)
1066{
1067	struct ctl_table *link_table, *entry, *link;
1068	struct ctl_table_header *links;
1069	struct ctl_node *node;
1070	char *link_name;
1071	int nr_entries, name_bytes;
1072
1073	name_bytes = 0;
1074	nr_entries = 0;
1075	for (entry = table; entry->procname; entry++) {
1076		nr_entries++;
1077		name_bytes += strlen(entry->procname) + 1;
1078	}
1079
1080	links = kzalloc(sizeof(struct ctl_table_header) +
1081			sizeof(struct ctl_node)*nr_entries +
1082			sizeof(struct ctl_table)*(nr_entries + 1) +
1083			name_bytes,
1084			GFP_KERNEL);
1085
1086	if (!links)
1087		return NULL;
1088
1089	node = (struct ctl_node *)(links + 1);
1090	link_table = (struct ctl_table *)(node + nr_entries);
1091	link_name = (char *)&link_table[nr_entries + 1];
1092
1093	for (link = link_table, entry = table; entry->procname; link++, entry++) {
1094		int len = strlen(entry->procname) + 1;
1095		memcpy(link_name, entry->procname, len);
1096		link->procname = link_name;
1097		link->mode = S_IFLNK|S_IRWXUGO;
1098		link->data = link_root;
1099		link_name += len;
1100	}
1101	init_header(links, dir->header.root, dir->header.set, node, link_table);
1102	links->nreg = nr_entries;
1103
1104	return links;
1105}
1106
1107static bool get_links(struct ctl_dir *dir,
1108	struct ctl_table *table, struct ctl_table_root *link_root)
1109{
1110	struct ctl_table_header *head;
1111	struct ctl_table *entry, *link;
1112
1113	/* Are there links available for every entry in table? */
1114	for (entry = table; entry->procname; entry++) {
1115		const char *procname = entry->procname;
1116		link = find_entry(&head, dir, procname, strlen(procname));
1117		if (!link)
1118			return false;
1119		if (S_ISDIR(link->mode) && S_ISDIR(entry->mode))
1120			continue;
1121		if (S_ISLNK(link->mode) && (link->data == link_root))
1122			continue;
1123		return false;
1124	}
1125
1126	/* The checks passed.  Increase the registration count on the links */
1127	for (entry = table; entry->procname; entry++) {
1128		const char *procname = entry->procname;
1129		link = find_entry(&head, dir, procname, strlen(procname));
1130		head->nreg++;
1131	}
1132	return true;
1133}
1134
1135static int insert_links(struct ctl_table_header *head)
1136{
1137	struct ctl_table_set *root_set = &sysctl_table_root.default_set;
1138	struct ctl_dir *core_parent = NULL;
1139	struct ctl_table_header *links;
1140	int err;
1141
1142	if (head->set == root_set)
1143		return 0;
1144
1145	core_parent = xlate_dir(root_set, head->parent);
1146	if (IS_ERR(core_parent))
1147		return 0;
1148
1149	if (get_links(core_parent, head->ctl_table, head->root))
1150		return 0;
1151
1152	core_parent->header.nreg++;
1153	spin_unlock(&sysctl_lock);
1154
1155	links = new_links(core_parent, head->ctl_table, head->root);
1156
1157	spin_lock(&sysctl_lock);
1158	err = -ENOMEM;
1159	if (!links)
1160		goto out;
1161
1162	err = 0;
1163	if (get_links(core_parent, head->ctl_table, head->root)) {
1164		kfree(links);
1165		goto out;
1166	}
1167
1168	err = insert_header(core_parent, links);
1169	if (err)
1170		kfree(links);
1171out:
1172	drop_sysctl_table(&core_parent->header);
1173	return err;
1174}
1175
1176/**
1177 * __register_sysctl_table - register a leaf sysctl table
1178 * @set: Sysctl tree to register on
1179 * @path: The path to the directory the sysctl table is in.
1180 * @table: the top-level table structure
1181 *
1182 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1183 * array. A completely 0 filled entry terminates the table.
1184 *
1185 * The members of the &struct ctl_table structure are used as follows:
1186 *
1187 * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1188 *            enter a sysctl file
1189 *
1190 * data - a pointer to data for use by proc_handler
1191 *
1192 * maxlen - the maximum size in bytes of the data
1193 *
1194 * mode - the file permissions for the /proc/sys file
1195 *
1196 * child - must be %NULL.
1197 *
1198 * proc_handler - the text handler routine (described below)
1199 *
1200 * extra1, extra2 - extra pointers usable by the proc handler routines
1201 *
1202 * Leaf nodes in the sysctl tree will be represented by a single file
1203 * under /proc; non-leaf nodes will be represented by directories.
1204 *
1205 * There must be a proc_handler routine for any terminal nodes.
1206 * Several default handlers are available to cover common cases -
1207 *
1208 * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
1209 * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
1210 * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
1211 *
1212 * It is the handler's job to read the input buffer from user memory
1213 * and process it. The handler should return 0 on success.
1214 *
1215 * This routine returns %NULL on a failure to register, and a pointer
1216 * to the table header on success.
1217 */
1218struct ctl_table_header *__register_sysctl_table(
1219	struct ctl_table_set *set,
1220	const char *path, struct ctl_table *table)
1221{
1222	struct ctl_table_root *root = set->dir.header.root;
1223	struct ctl_table_header *header;
1224	const char *name, *nextname;
1225	struct ctl_dir *dir;
1226	struct ctl_table *entry;
1227	struct ctl_node *node;
1228	int nr_entries = 0;
1229
1230	for (entry = table; entry->procname; entry++)
1231		nr_entries++;
1232
1233	header = kzalloc(sizeof(struct ctl_table_header) +
1234			 sizeof(struct ctl_node)*nr_entries, GFP_KERNEL);
1235	if (!header)
1236		return NULL;
1237
1238	node = (struct ctl_node *)(header + 1);
1239	init_header(header, root, set, node, table);
1240	if (sysctl_check_table(path, table))
1241		goto fail;
1242
1243	spin_lock(&sysctl_lock);
1244	dir = &set->dir;
1245	/* Reference moved down the diretory tree get_subdir */
1246	dir->header.nreg++;
1247	spin_unlock(&sysctl_lock);
1248
1249	/* Find the directory for the ctl_table */
1250	for (name = path; name; name = nextname) {
1251		int namelen;
1252		nextname = strchr(name, '/');
1253		if (nextname) {
1254			namelen = nextname - name;
1255			nextname++;
1256		} else {
1257			namelen = strlen(name);
1258		}
1259		if (namelen == 0)
1260			continue;
1261
1262		dir = get_subdir(dir, name, namelen);
1263		if (IS_ERR(dir))
1264			goto fail;
1265	}
1266
1267	spin_lock(&sysctl_lock);
1268	if (insert_header(dir, header))
1269		goto fail_put_dir_locked;
1270
1271	drop_sysctl_table(&dir->header);
1272	spin_unlock(&sysctl_lock);
1273
1274	return header;
1275
1276fail_put_dir_locked:
1277	drop_sysctl_table(&dir->header);
1278	spin_unlock(&sysctl_lock);
1279fail:
1280	kfree(header);
1281	dump_stack();
1282	return NULL;
1283}
1284
1285/**
1286 * register_sysctl - register a sysctl table
1287 * @path: The path to the directory the sysctl table is in.
1288 * @table: the table structure
1289 *
1290 * Register a sysctl table. @table should be a filled in ctl_table
1291 * array. A completely 0 filled entry terminates the table.
1292 *
1293 * See __register_sysctl_table for more details.
1294 */
1295struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table)
1296{
1297	return __register_sysctl_table(&sysctl_table_root.default_set,
1298					path, table);
1299}
1300EXPORT_SYMBOL(register_sysctl);
1301
1302static char *append_path(const char *path, char *pos, const char *name)
1303{
1304	int namelen;
1305	namelen = strlen(name);
1306	if (((pos - path) + namelen + 2) >= PATH_MAX)
1307		return NULL;
1308	memcpy(pos, name, namelen);
1309	pos[namelen] = '/';
1310	pos[namelen + 1] = '\0';
1311	pos += namelen + 1;
1312	return pos;
1313}
1314
1315static int count_subheaders(struct ctl_table *table)
1316{
1317	int has_files = 0;
1318	int nr_subheaders = 0;
1319	struct ctl_table *entry;
1320
1321	/* special case: no directory and empty directory */
1322	if (!table || !table->procname)
1323		return 1;
1324
1325	for (entry = table; entry->procname; entry++) {
1326		if (entry->child)
1327			nr_subheaders += count_subheaders(entry->child);
1328		else
1329			has_files = 1;
1330	}
1331	return nr_subheaders + has_files;
1332}
1333
1334static int register_leaf_sysctl_tables(const char *path, char *pos,
1335	struct ctl_table_header ***subheader, struct ctl_table_set *set,
1336	struct ctl_table *table)
1337{
1338	struct ctl_table *ctl_table_arg = NULL;
1339	struct ctl_table *entry, *files;
1340	int nr_files = 0;
1341	int nr_dirs = 0;
1342	int err = -ENOMEM;
1343
1344	for (entry = table; entry->procname; entry++) {
1345		if (entry->child)
1346			nr_dirs++;
1347		else
1348			nr_files++;
1349	}
1350
1351	files = table;
1352	/* If there are mixed files and directories we need a new table */
1353	if (nr_dirs && nr_files) {
1354		struct ctl_table *new;
1355		files = kzalloc(sizeof(struct ctl_table) * (nr_files + 1),
1356				GFP_KERNEL);
1357		if (!files)
1358			goto out;
1359
1360		ctl_table_arg = files;
1361		for (new = files, entry = table; entry->procname; entry++) {
1362			if (entry->child)
1363				continue;
1364			*new = *entry;
1365			new++;
1366		}
1367	}
1368
1369	/* Register everything except a directory full of subdirectories */
1370	if (nr_files || !nr_dirs) {
1371		struct ctl_table_header *header;
1372		header = __register_sysctl_table(set, path, files);
1373		if (!header) {
1374			kfree(ctl_table_arg);
1375			goto out;
1376		}
1377
1378		/* Remember if we need to free the file table */
1379		header->ctl_table_arg = ctl_table_arg;
1380		**subheader = header;
1381		(*subheader)++;
1382	}
1383
1384	/* Recurse into the subdirectories. */
1385	for (entry = table; entry->procname; entry++) {
1386		char *child_pos;
1387
1388		if (!entry->child)
1389			continue;
1390
1391		err = -ENAMETOOLONG;
1392		child_pos = append_path(path, pos, entry->procname);
1393		if (!child_pos)
1394			goto out;
1395
1396		err = register_leaf_sysctl_tables(path, child_pos, subheader,
1397						  set, entry->child);
1398		pos[0] = '\0';
1399		if (err)
1400			goto out;
1401	}
1402	err = 0;
1403out:
1404	/* On failure our caller will unregister all registered subheaders */
1405	return err;
1406}
1407
1408/**
1409 * __register_sysctl_paths - register a sysctl table hierarchy
1410 * @set: Sysctl tree to register on
1411 * @path: The path to the directory the sysctl table is in.
1412 * @table: the top-level table structure
1413 *
1414 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1415 * array. A completely 0 filled entry terminates the table.
1416 *
1417 * See __register_sysctl_table for more details.
1418 */
1419struct ctl_table_header *__register_sysctl_paths(
1420	struct ctl_table_set *set,
1421	const struct ctl_path *path, struct ctl_table *table)
1422{
1423	struct ctl_table *ctl_table_arg = table;
1424	int nr_subheaders = count_subheaders(table);
1425	struct ctl_table_header *header = NULL, **subheaders, **subheader;
1426	const struct ctl_path *component;
1427	char *new_path, *pos;
1428
1429	pos = new_path = kmalloc(PATH_MAX, GFP_KERNEL);
1430	if (!new_path)
1431		return NULL;
1432
1433	pos[0] = '\0';
1434	for (component = path; component->procname; component++) {
1435		pos = append_path(new_path, pos, component->procname);
1436		if (!pos)
1437			goto out;
1438	}
1439	while (table->procname && table->child && !table[1].procname) {
1440		pos = append_path(new_path, pos, table->procname);
1441		if (!pos)
1442			goto out;
1443		table = table->child;
1444	}
1445	if (nr_subheaders == 1) {
1446		header = __register_sysctl_table(set, new_path, table);
1447		if (header)
1448			header->ctl_table_arg = ctl_table_arg;
1449	} else {
1450		header = kzalloc(sizeof(*header) +
1451				 sizeof(*subheaders)*nr_subheaders, GFP_KERNEL);
1452		if (!header)
1453			goto out;
1454
1455		subheaders = (struct ctl_table_header **) (header + 1);
1456		subheader = subheaders;
1457		header->ctl_table_arg = ctl_table_arg;
1458
1459		if (register_leaf_sysctl_tables(new_path, pos, &subheader,
1460						set, table))
1461			goto err_register_leaves;
1462	}
1463
1464out:
1465	kfree(new_path);
1466	return header;
1467
1468err_register_leaves:
1469	while (subheader > subheaders) {
1470		struct ctl_table_header *subh = *(--subheader);
1471		struct ctl_table *table = subh->ctl_table_arg;
1472		unregister_sysctl_table(subh);
1473		kfree(table);
1474	}
1475	kfree(header);
1476	header = NULL;
1477	goto out;
1478}
1479
1480/**
1481 * register_sysctl_table_path - register a sysctl table hierarchy
1482 * @path: The path to the directory the sysctl table is in.
1483 * @table: the top-level table structure
1484 *
1485 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1486 * array. A completely 0 filled entry terminates the table.
1487 *
1488 * See __register_sysctl_paths for more details.
1489 */
1490struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
1491						struct ctl_table *table)
1492{
1493	return __register_sysctl_paths(&sysctl_table_root.default_set,
1494					path, table);
1495}
1496EXPORT_SYMBOL(register_sysctl_paths);
1497
1498/**
1499 * register_sysctl_table - register a sysctl table hierarchy
1500 * @table: the top-level table structure
1501 *
1502 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1503 * array. A completely 0 filled entry terminates the table.
1504 *
1505 * See register_sysctl_paths for more details.
1506 */
1507struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
1508{
1509	static const struct ctl_path null_path[] = { {} };
1510
1511	return register_sysctl_paths(null_path, table);
1512}
1513EXPORT_SYMBOL(register_sysctl_table);
1514
1515static void put_links(struct ctl_table_header *header)
1516{
1517	struct ctl_table_set *root_set = &sysctl_table_root.default_set;
1518	struct ctl_table_root *root = header->root;
1519	struct ctl_dir *parent = header->parent;
1520	struct ctl_dir *core_parent;
1521	struct ctl_table *entry;
1522
1523	if (header->set == root_set)
1524		return;
1525
1526	core_parent = xlate_dir(root_set, parent);
1527	if (IS_ERR(core_parent))
1528		return;
1529
1530	for (entry = header->ctl_table; entry->procname; entry++) {
1531		struct ctl_table_header *link_head;
1532		struct ctl_table *link;
1533		const char *name = entry->procname;
1534
1535		link = find_entry(&link_head, core_parent, name, strlen(name));
1536		if (link &&
1537		    ((S_ISDIR(link->mode) && S_ISDIR(entry->mode)) ||
1538		     (S_ISLNK(link->mode) && (link->data == root)))) {
1539			drop_sysctl_table(link_head);
1540		}
1541		else {
1542			pr_err("sysctl link missing during unregister: ");
1543			sysctl_print_dir(parent);
1544			pr_cont("/%s\n", name);
1545		}
1546	}
1547}
1548
1549static void drop_sysctl_table(struct ctl_table_header *header)
1550{
1551	struct ctl_dir *parent = header->parent;
1552
1553	if (--header->nreg)
1554		return;
1555
1556	put_links(header);
1557	start_unregistering(header);
1558	if (!--header->count)
1559		kfree_rcu(header, rcu);
1560
1561	if (parent)
1562		drop_sysctl_table(&parent->header);
1563}
1564
1565/**
1566 * unregister_sysctl_table - unregister a sysctl table hierarchy
1567 * @header: the header returned from register_sysctl_table
1568 *
1569 * Unregisters the sysctl table and all children. proc entries may not
1570 * actually be removed until they are no longer used by anyone.
1571 */
1572void unregister_sysctl_table(struct ctl_table_header * header)
1573{
1574	int nr_subheaders;
1575	might_sleep();
1576
1577	if (header == NULL)
1578		return;
1579
1580	nr_subheaders = count_subheaders(header->ctl_table_arg);
1581	if (unlikely(nr_subheaders > 1)) {
1582		struct ctl_table_header **subheaders;
1583		int i;
1584
1585		subheaders = (struct ctl_table_header **)(header + 1);
1586		for (i = nr_subheaders -1; i >= 0; i--) {
1587			struct ctl_table_header *subh = subheaders[i];
1588			struct ctl_table *table = subh->ctl_table_arg;
1589			unregister_sysctl_table(subh);
1590			kfree(table);
1591		}
1592		kfree(header);
1593		return;
1594	}
1595
1596	spin_lock(&sysctl_lock);
1597	drop_sysctl_table(header);
1598	spin_unlock(&sysctl_lock);
1599}
1600EXPORT_SYMBOL(unregister_sysctl_table);
1601
1602void setup_sysctl_set(struct ctl_table_set *set,
1603	struct ctl_table_root *root,
1604	int (*is_seen)(struct ctl_table_set *))
1605{
1606	memset(set, 0, sizeof(*set));
1607	set->is_seen = is_seen;
1608	init_header(&set->dir.header, root, set, NULL, root_table);
1609}
1610
1611void retire_sysctl_set(struct ctl_table_set *set)
1612{
1613	WARN_ON(!RB_EMPTY_ROOT(&set->dir.root));
1614}
1615
1616int __init proc_sys_init(void)
1617{
1618	struct proc_dir_entry *proc_sys_root;
1619
1620	proc_sys_root = proc_mkdir("sys", NULL);
1621	proc_sys_root->proc_iops = &proc_sys_dir_operations;
1622	proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
1623	proc_sys_root->nlink = 0;
1624
1625	return sysctl_init();
1626}