proc_sysctl.c 39.0 KB
Newer Older
1 2 3
/*
 * /proc/sys support
 */
A
Alexey Dobriyan 已提交
4
#include <linux/init.h>
5
#include <linux/sysctl.h>
L
Lucas De Marchi 已提交
6
#include <linux/poll.h>
7 8
#include <linux/proc_fs.h>
#include <linux/security.h>
A
Al Viro 已提交
9
#include <linux/sched.h>
10
#include <linux/namei.h>
A
Al Viro 已提交
11
#include <linux/mm.h>
12
#include <linux/module.h>
13 14
#include "internal.h"

A
Al Viro 已提交
15
static const struct dentry_operations proc_sys_dentry_operations;
16
static const struct file_operations proc_sys_file_operations;
17
static const struct inode_operations proc_sys_inode_operations;
A
Al Viro 已提交
18 19
static const struct file_operations proc_sys_dir_file_operations;
static const struct inode_operations proc_sys_dir_operations;
20

L
Lucas De Marchi 已提交
21 22 23 24 25 26 27 28 29
void proc_sys_poll_notify(struct ctl_table_poll *poll)
{
	if (!poll)
		return;

	atomic_inc(&poll->event);
	wake_up_interruptible(&poll->wait);
}

30 31 32
static struct ctl_table root_table[] = {
	{
		.procname = "",
33
		.mode = S_IFDIR|S_IRUGO|S_IXUGO,
34 35 36
	},
	{ }
};
37 38
static struct ctl_table_root sysctl_table_root = {
	.default_set.dir.header = {
39 40
		{{.count = 1,
		  .nreg = 1,
41
		  .ctl_table = root_table }},
42
		.ctl_table_arg = root_table,
43 44 45
		.root = &sysctl_table_root,
		.set = &sysctl_table_root.default_set,
	},
46 47 48 49
};

static DEFINE_SPINLOCK(sysctl_lock);

50
static void drop_sysctl_table(struct ctl_table_header *header);
51 52 53 54
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);
55

56 57 58 59 60 61 62
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);
}

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
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;
}

78
/* Called under sysctl_lock */
79
static struct ctl_table *find_entry(struct ctl_table_header **phead,
80
	struct ctl_dir *dir, const char *name, int namelen)
81 82 83
{
	struct ctl_table_header *head;
	struct ctl_table *entry;
84
	struct rb_node *node = dir->root.rb_node;
85

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
	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;
105 106 107 108 109
		}
	}
	return NULL;
}

110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
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);
}

155 156
static void init_header(struct ctl_table_header *head,
	struct ctl_table_root *root, struct ctl_table_set *set,
157
	struct ctl_node *node, struct ctl_table *table)
158
{
159
	head->ctl_table = table;
160 161 162 163 164 165 166 167
	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;
168 169 170 171 172 173 174 175
	head->node = node;
	if (node) {
		struct ctl_table *entry;
		for (entry = table; entry->procname; entry++, node++) {
			rb_init_node(&node->node);
			node->header = head;
		}
	}
176 177
}

178 179
static void erase_header(struct ctl_table_header *head)
{
180 181 182
	struct ctl_table *entry;
	for (entry = head->ctl_table; entry->procname; entry++)
		erase_entry(head, entry);
183 184
}

185
static int insert_header(struct ctl_dir *dir, struct ctl_table_header *header)
186
{
187
	struct ctl_table *entry;
188 189 190
	int err;

	dir->header.nreg++;
191
	header->parent = dir;
192 193 194
	err = insert_links(header);
	if (err)
		goto fail_links;
195 196 197 198 199
	for (entry = header->ctl_table; entry->procname; entry++) {
		err = insert_entry(header, entry);
		if (err)
			goto fail;
	}
200
	return 0;
201 202 203
fail:
	erase_header(header);
	put_links(header);
204 205 206 207
fail_links:
	header->parent = NULL;
	drop_sysctl_table(&dir->header);
	return err;
208 209
}

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
/* 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.
	 */
249
	erase_header(p);
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
}

static 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);
}

static 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;
}

static 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;
}

296
static struct ctl_table *lookup_entry(struct ctl_table_header **phead,
297
				      struct ctl_dir *dir,
298 299 300 301 302 303
				      const char *name, int namelen)
{
	struct ctl_table_header *head;
	struct ctl_table *entry;

	spin_lock(&sysctl_lock);
304 305 306 307 308
	entry = find_entry(&head, dir, name, namelen);
	if (entry && use_table(head))
		*phead = head;
	else
		entry = NULL;
309 310 311 312
	spin_unlock(&sysctl_lock);
	return entry;
}

313
static struct ctl_node *first_usable_entry(struct rb_node *node)
314
{
315
	struct ctl_node *ctl_node;
316

317 318 319 320
	for (;node; node = rb_next(node)) {
		ctl_node = rb_entry(node, struct ctl_node, node);
		if (use_table(ctl_node->header))
			return ctl_node;
321 322 323 324
	}
	return NULL;
}

325
static void first_entry(struct ctl_dir *dir,
326 327
	struct ctl_table_header **phead, struct ctl_table **pentry)
{
328
	struct ctl_table_header *head = NULL;
329
	struct ctl_table *entry = NULL;
330
	struct ctl_node *ctl_node;
331 332

	spin_lock(&sysctl_lock);
333
	ctl_node = first_usable_entry(rb_first(&dir->root));
334
	spin_unlock(&sysctl_lock);
335 336 337 338
	if (ctl_node) {
		head = ctl_node->header;
		entry = &head->ctl_table[ctl_node - head->node];
	}
339 340 341 342
	*phead = head;
	*pentry = entry;
}

343
static void next_entry(struct ctl_table_header **phead, struct ctl_table **pentry)
344
{
345 346
	struct ctl_table_header *head = *phead;
	struct ctl_table *entry = *pentry;
347
	struct ctl_node *ctl_node = &head->node[entry - head->ctl_table];
348

349 350 351 352 353 354 355 356 357
	spin_lock(&sysctl_lock);
	unuse_table(head);

	ctl_node = first_usable_entry(rb_next(&ctl_node->node));
	spin_unlock(&sysctl_lock);
	head = NULL;
	if (ctl_node) {
		head = ctl_node->header;
		entry = &head->ctl_table[ctl_node - head->node];
358 359 360
	}
	*phead = head;
	*pentry = entry;
361 362 363 364 365 366 367 368 369 370 371 372 373
}

void register_sysctl_root(struct ctl_table_root *root)
{
}

/*
 * 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)
{
374
	if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
375
		mode >>= 6;
376
	else if (in_egroup_p(GLOBAL_ROOT_GID))
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
		mode >>= 3;
	if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
		return 0;
	return -EACCES;
}

static 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);
}

A
Al Viro 已提交
395 396
static struct inode *proc_sys_make_inode(struct super_block *sb,
		struct ctl_table_header *head, struct ctl_table *table)
397 398
{
	struct inode *inode;
A
Al Viro 已提交
399
	struct proc_inode *ei;
400

A
Al Viro 已提交
401
	inode = new_inode(sb);
402 403 404
	if (!inode)
		goto out;

405 406
	inode->i_ino = get_next_ino();

A
Al Viro 已提交
407
	sysctl_head_get(head);
408
	ei = PROC_I(inode);
A
Al Viro 已提交
409 410 411
	ei->sysctl = head;
	ei->sysctl_entry = table;

412
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
A
Al Viro 已提交
413
	inode->i_mode = table->mode;
414
	if (!S_ISDIR(table->mode)) {
A
Al Viro 已提交
415 416 417 418 419 420 421 422
		inode->i_mode |= S_IFREG;
		inode->i_op = &proc_sys_inode_operations;
		inode->i_fop = &proc_sys_file_operations;
	} else {
		inode->i_mode |= S_IFDIR;
		inode->i_op = &proc_sys_dir_operations;
		inode->i_fop = &proc_sys_dir_file_operations;
	}
423 424 425 426
out:
	return inode;
}

A
Adrian Bunk 已提交
427
static struct ctl_table_header *grab_header(struct inode *inode)
428
{
429 430
	struct ctl_table_header *head = PROC_I(inode)->sysctl;
	if (!head)
431
		head = &sysctl_table_root.default_set.dir.header;
432
	return sysctl_head_grab(head);
A
Al Viro 已提交
433
}
434

A
Al Viro 已提交
435 436 437 438 439 440 441 442 443
static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
					struct nameidata *nd)
{
	struct ctl_table_header *head = grab_header(dir);
	struct ctl_table_header *h = NULL;
	struct qstr *name = &dentry->d_name;
	struct ctl_table *p;
	struct inode *inode;
	struct dentry *err = ERR_PTR(-ENOENT);
444
	struct ctl_dir *ctl_dir;
445
	int ret;
446

A
Al Viro 已提交
447 448
	if (IS_ERR(head))
		return ERR_CAST(head);
449

450
	ctl_dir = container_of(head, struct ctl_dir, header);
451

452
	p = lookup_entry(&h, ctl_dir, name->name, name->len);
A
Al Viro 已提交
453
	if (!p)
454 455
		goto out;

456 457 458 459 460 461
	if (S_ISLNK(p->mode)) {
		ret = sysctl_follow_link(&h, &p, current->nsproxy);
		err = ERR_PTR(ret);
		if (ret)
			goto out;
	}
462

463
	err = ERR_PTR(-ENOMEM);
A
Al Viro 已提交
464 465 466 467
	inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
	if (h)
		sysctl_head_finish(h);

468 469 470 471
	if (!inode)
		goto out;

	err = NULL;
472
	d_set_d_op(dentry, &proc_sys_dentry_operations);
473 474 475 476 477 478 479
	d_add(dentry, inode);

out:
	sysctl_head_finish(head);
	return err;
}

480 481
static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
		size_t count, loff_t *ppos, int write)
482
{
A
Al Viro 已提交
483 484 485
	struct inode *inode = filp->f_path.dentry->d_inode;
	struct ctl_table_header *head = grab_header(inode);
	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
486 487
	ssize_t error;
	size_t res;
488

A
Al Viro 已提交
489 490
	if (IS_ERR(head))
		return PTR_ERR(head);
491 492 493 494 495 496

	/*
	 * At this point we know that the sysctl was not unregistered
	 * and won't be until we finish.
	 */
	error = -EPERM;
497
	if (sysctl_perm(head->root, table, write ? MAY_WRITE : MAY_READ))
498 499
		goto out;

A
Al Viro 已提交
500 501 502 503 504
	/* if that can happen at all, it should be -EINVAL, not -EISDIR */
	error = -EINVAL;
	if (!table->proc_handler)
		goto out;

505 506
	/* careful: calling conventions are nasty here */
	res = count;
507
	error = table->proc_handler(table, write, buf, &res, ppos);
508 509 510 511 512 513 514 515
	if (!error)
		error = res;
out:
	sysctl_head_finish(head);

	return error;
}

516
static ssize_t proc_sys_read(struct file *filp, char __user *buf,
517 518
				size_t count, loff_t *ppos)
{
519 520
	return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
}
521

522 523 524 525
static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
				size_t count, loff_t *ppos)
{
	return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
526 527
}

L
Lucas De Marchi 已提交
528 529
static int proc_sys_open(struct inode *inode, struct file *filp)
{
530
	struct ctl_table_header *head = grab_header(inode);
L
Lucas De Marchi 已提交
531 532
	struct ctl_table *table = PROC_I(inode)->sysctl_entry;

533 534 535 536
	/* sysctl was unregistered */
	if (IS_ERR(head))
		return PTR_ERR(head);

L
Lucas De Marchi 已提交
537 538 539
	if (table->poll)
		filp->private_data = proc_sys_poll_event(table->poll);

540 541
	sysctl_head_finish(head);

L
Lucas De Marchi 已提交
542 543 544 545 546 547
	return 0;
}

static unsigned int proc_sys_poll(struct file *filp, poll_table *wait)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
548
	struct ctl_table_header *head = grab_header(inode);
L
Lucas De Marchi 已提交
549 550
	struct ctl_table *table = PROC_I(inode)->sysctl_entry;
	unsigned int ret = DEFAULT_POLLMASK;
551 552 553 554 555
	unsigned long event;

	/* sysctl was unregistered */
	if (IS_ERR(head))
		return POLLERR | POLLHUP;
L
Lucas De Marchi 已提交
556 557 558 559 560 561 562

	if (!table->proc_handler)
		goto out;

	if (!table->poll)
		goto out;

563
	event = (unsigned long)filp->private_data;
L
Lucas De Marchi 已提交
564 565 566 567 568 569 570 571
	poll_wait(filp, &table->poll->wait, wait);

	if (event != atomic_read(&table->poll->event)) {
		filp->private_data = proc_sys_poll_event(table->poll);
		ret = POLLIN | POLLRDNORM | POLLERR | POLLPRI;
	}

out:
572 573
	sysctl_head_finish(head);

L
Lucas De Marchi 已提交
574 575
	return ret;
}
576 577

static int proc_sys_fill_cache(struct file *filp, void *dirent,
A
Al Viro 已提交
578 579 580
				filldir_t filldir,
				struct ctl_table_header *head,
				struct ctl_table *table)
581 582 583 584 585 586 587 588 589 590 591 592 593
{
	struct dentry *child, *dir = filp->f_path.dentry;
	struct inode *inode;
	struct qstr qname;
	ino_t ino = 0;
	unsigned type = DT_UNKNOWN;

	qname.name = table->procname;
	qname.len  = strlen(table->procname);
	qname.hash = full_name_hash(qname.name, qname.len);

	child = d_lookup(dir, &qname);
	if (!child) {
A
Al Viro 已提交
594 595 596 597 598 599 600
		child = d_alloc(dir, &qname);
		if (child) {
			inode = proc_sys_make_inode(dir->d_sb, head, table);
			if (!inode) {
				dput(child);
				return -ENOMEM;
			} else {
601
				d_set_d_op(child, &proc_sys_dentry_operations);
A
Al Viro 已提交
602
				d_add(child, inode);
603
			}
A
Al Viro 已提交
604 605
		} else {
			return -ENOMEM;
606 607 608
		}
	}
	inode = child->d_inode;
A
Al Viro 已提交
609 610
	ino  = inode->i_ino;
	type = inode->i_mode >> 12;
611
	dput(child);
A
Al Viro 已提交
612 613 614
	return !!filldir(dirent, qname.name, qname.len, filp->f_pos, ino, type);
}

615 616 617 618 619 620 621 622
static int proc_sys_link_fill_cache(struct file *filp, void *dirent,
				    filldir_t filldir,
				    struct ctl_table_header *head,
				    struct ctl_table *table)
{
	int err, ret = 0;
	head = sysctl_head_grab(head);

623 624 625 626 627 628
	if (S_ISLNK(table->mode)) {
		/* It is not an error if we can not follow the link ignore it */
		err = sysctl_follow_link(&head, &table, current->nsproxy);
		if (err)
			goto out;
	}
629 630 631 632 633 634 635

	ret = proc_sys_fill_cache(filp, dirent, filldir, head, table);
out:
	sysctl_head_finish(head);
	return ret;
}

A
Al Viro 已提交
636 637 638 639
static int scan(struct ctl_table_header *head, ctl_table *table,
		unsigned long *pos, struct file *file,
		void *dirent, filldir_t filldir)
{
640
	int res;
A
Al Viro 已提交
641

642 643
	if ((*pos)++ < file->f_pos)
		return 0;
A
Al Viro 已提交
644

645 646 647
	if (unlikely(S_ISLNK(table->mode)))
		res = proc_sys_link_fill_cache(file, dirent, filldir, head, table);
	else
A
Al Viro 已提交
648 649
		res = proc_sys_fill_cache(file, dirent, filldir, head, table);

650 651
	if (res == 0)
		file->f_pos = *pos;
A
Al Viro 已提交
652

653
	return res;
654 655 656 657
}

static int proc_sys_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
A
Al Viro 已提交
658
	struct dentry *dentry = filp->f_path.dentry;
659
	struct inode *inode = dentry->d_inode;
A
Al Viro 已提交
660 661
	struct ctl_table_header *head = grab_header(inode);
	struct ctl_table_header *h = NULL;
662
	struct ctl_table *entry;
663
	struct ctl_dir *ctl_dir;
664
	unsigned long pos;
A
Al Viro 已提交
665 666 667 668
	int ret = -EINVAL;

	if (IS_ERR(head))
		return PTR_ERR(head);
669

670
	ctl_dir = container_of(head, struct ctl_dir, header);
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687

	ret = 0;
	/* Avoid a switch here: arm builds fail with missing __cmpdi2 */
	if (filp->f_pos == 0) {
		if (filldir(dirent, ".", 1, filp->f_pos,
				inode->i_ino, DT_DIR) < 0)
			goto out;
		filp->f_pos++;
	}
	if (filp->f_pos == 1) {
		if (filldir(dirent, "..", 2, filp->f_pos,
				parent_ino(dentry), DT_DIR) < 0)
			goto out;
		filp->f_pos++;
	}
	pos = 2;

688
	for (first_entry(ctl_dir, &h, &entry); h; next_entry(&h, &entry)) {
689
		ret = scan(h, entry, &pos, filp, dirent, filldir);
A
Al Viro 已提交
690 691 692
		if (ret) {
			sysctl_head_finish(h);
			break;
693 694 695 696 697 698 699 700
		}
	}
	ret = 1;
out:
	sysctl_head_finish(head);
	return ret;
}

701
static int proc_sys_permission(struct inode *inode, int mask)
702 703 704 705 706
{
	/*
	 * sysctl entries that are not writeable,
	 * are _NOT_ writeable, capabilities or not.
	 */
707 708
	struct ctl_table_header *head;
	struct ctl_table *table;
709 710
	int error;

711 712 713 714 715
	/* Executable files are not allowed under /proc/sys/ */
	if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
		return -EACCES;

	head = grab_header(inode);
A
Al Viro 已提交
716 717
	if (IS_ERR(head))
		return PTR_ERR(head);
718

719
	table = PROC_I(inode)->sysctl_entry;
A
Al Viro 已提交
720 721 722
	if (!table) /* global root - r-xr-xr-x */
		error = mask & MAY_WRITE ? -EACCES : 0;
	else /* Use the permissions on the sysctl table entry */
723
		error = sysctl_perm(head->root, table, mask & ~MAY_NOT_BLOCK);
724 725 726 727 728 729 730 731 732 733 734 735 736 737

	sysctl_head_finish(head);
	return error;
}

static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
{
	struct inode *inode = dentry->d_inode;
	int error;

	if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
		return -EPERM;

	error = inode_change_ok(inode, attr);
C
Christoph Hellwig 已提交
738 739 740 741 742 743 744 745 746
	if (error)
		return error;

	if ((attr->ia_valid & ATTR_SIZE) &&
	    attr->ia_size != i_size_read(inode)) {
		error = vmtruncate(inode, attr->ia_size);
		if (error)
			return error;
	}
747

C
Christoph Hellwig 已提交
748 749 750
	setattr_copy(inode, attr);
	mark_inode_dirty(inode);
	return 0;
751 752
}

A
Al Viro 已提交
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
	struct inode *inode = dentry->d_inode;
	struct ctl_table_header *head = grab_header(inode);
	struct ctl_table *table = PROC_I(inode)->sysctl_entry;

	if (IS_ERR(head))
		return PTR_ERR(head);

	generic_fillattr(inode, stat);
	if (table)
		stat->mode = (stat->mode & S_IFMT) | table->mode;

	sysctl_head_finish(head);
	return 0;
}

770
static const struct file_operations proc_sys_file_operations = {
L
Lucas De Marchi 已提交
771 772
	.open		= proc_sys_open,
	.poll		= proc_sys_poll,
773 774
	.read		= proc_sys_read,
	.write		= proc_sys_write,
775
	.llseek		= default_llseek,
A
Al Viro 已提交
776 777 778
};

static const struct file_operations proc_sys_dir_file_operations = {
779
	.read		= generic_read_dir,
780
	.readdir	= proc_sys_readdir,
781
	.llseek		= generic_file_llseek,
782 783
};

784
static const struct inode_operations proc_sys_inode_operations = {
A
Al Viro 已提交
785 786 787 788 789 790
	.permission	= proc_sys_permission,
	.setattr	= proc_sys_setattr,
	.getattr	= proc_sys_getattr,
};

static const struct inode_operations proc_sys_dir_operations = {
791 792 793
	.lookup		= proc_sys_lookup,
	.permission	= proc_sys_permission,
	.setattr	= proc_sys_setattr,
A
Al Viro 已提交
794
	.getattr	= proc_sys_getattr,
795 796
};

797
static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
798
{
799
	if (flags & LOOKUP_RCU)
800
		return -ECHILD;
A
Al Viro 已提交
801 802 803
	return !PROC_I(dentry->d_inode)->sysctl->unregistering;
}

N
Nick Piggin 已提交
804
static int proc_sys_delete(const struct dentry *dentry)
A
Al Viro 已提交
805 806 807 808
{
	return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
static 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;
}

N
Nick Piggin 已提交
824 825 826 827
static int proc_sys_compare(const struct dentry *parent,
		const struct inode *pinode,
		const struct dentry *dentry, const struct inode *inode,
		unsigned int len, const char *str, const struct qstr *name)
A
Al Viro 已提交
828
{
A
Al Viro 已提交
829
	struct ctl_table_header *head;
N
Nick Piggin 已提交
830 831
	/* Although proc doesn't have negative dentries, rcu-walk means
	 * that inode here can be NULL */
A
Al Viro 已提交
832
	/* AV: can it, indeed? */
N
Nick Piggin 已提交
833
	if (!inode)
A
Al Viro 已提交
834
		return 1;
N
Nick Piggin 已提交
835
	if (name->len != len)
A
Al Viro 已提交
836
		return 1;
N
Nick Piggin 已提交
837
	if (memcmp(name->name, str, len))
A
Al Viro 已提交
838
		return 1;
A
Al Viro 已提交
839 840
	head = rcu_dereference(PROC_I(inode)->sysctl);
	return !head || !sysctl_is_seen(head);
841 842
}

A
Al Viro 已提交
843
static const struct dentry_operations proc_sys_dentry_operations = {
844
	.d_revalidate	= proc_sys_revalidate,
A
Al Viro 已提交
845 846
	.d_delete	= proc_sys_delete,
	.d_compare	= proc_sys_compare,
847 848
};

849 850
static struct ctl_dir *find_subdir(struct ctl_dir *dir,
				   const char *name, int namelen)
851
{
852 853
	struct ctl_table_header *head;
	struct ctl_table *entry;
854

855
	entry = find_entry(&head, dir, name, namelen);
856 857
	if (!entry)
		return ERR_PTR(-ENOENT);
858 859 860
	if (!S_ISDIR(entry->mode))
		return ERR_PTR(-ENOTDIR);
	return container_of(head, struct ctl_dir, header);
861 862 863
}

static struct ctl_dir *new_dir(struct ctl_table_set *set,
864
			       const char *name, int namelen)
865 866 867
{
	struct ctl_table *table;
	struct ctl_dir *new;
868
	struct ctl_node *node;
869
	char *new_name;
870

871 872 873
	new = kzalloc(sizeof(*new) + sizeof(struct ctl_node) +
		      sizeof(struct ctl_table)*2 +  namelen + 1,
		      GFP_KERNEL);
874
	if (!new)
875 876
		return NULL;

877 878
	node = (struct ctl_node *)(new + 1);
	table = (struct ctl_table *)(node + 1);
879 880 881 882 883
	new_name = (char *)(table + 2);
	memcpy(new_name, name, namelen);
	new_name[namelen] = '\0';
	table[0].procname = new_name;
	table[0].mode = S_IFDIR|S_IRUGO|S_IXUGO;
884
	init_header(&new->header, set->dir.header.root, set, node, table);
885 886

	return new;
887 888
}

889 890 891 892 893 894 895 896 897 898 899 900
/**
 * get_subdir - find or create a subdir with the specified name.
 * @dir:  Directory to create the subdirectory in
 * @name: The name of the subdirectory to find or create
 * @namelen: The length of name
 *
 * Takes a directory with an elevated reference count so we know that
 * if we drop the lock the directory will not go away.  Upon success
 * the reference is moved from @dir to the returned subdirectory.
 * Upon error an error code is returned and the reference on @dir is
 * simply dropped.
 */
901 902
static struct ctl_dir *get_subdir(struct ctl_dir *dir,
				  const char *name, int namelen)
903
{
904
	struct ctl_table_set *set = dir->header.set;
905
	struct ctl_dir *subdir, *new = NULL;
906
	int err;
907

908
	spin_lock(&sysctl_lock);
909
	subdir = find_subdir(dir, name, namelen);
910 911 912 913 914 915 916 917 918 919 920 921
	if (!IS_ERR(subdir))
		goto found;
	if (PTR_ERR(subdir) != -ENOENT)
		goto failed;

	spin_unlock(&sysctl_lock);
	new = new_dir(set, name, namelen);
	spin_lock(&sysctl_lock);
	subdir = ERR_PTR(-ENOMEM);
	if (!new)
		goto failed;

922
	/* Was the subdir added while we dropped the lock? */
923
	subdir = find_subdir(dir, name, namelen);
924 925 926 927 928
	if (!IS_ERR(subdir))
		goto found;
	if (PTR_ERR(subdir) != -ENOENT)
		goto failed;

929
	/* Nope.  Use the our freshly made directory entry. */
930 931 932
	err = insert_header(dir, &new->header);
	subdir = ERR_PTR(err);
	if (err)
933
		goto failed;
934 935 936 937 938
	subdir = new;
found:
	subdir->header.nreg++;
failed:
	if (unlikely(IS_ERR(subdir))) {
939 940 941
		printk(KERN_ERR "sysctl could not get directory: ");
		sysctl_print_dir(dir);
		printk(KERN_CONT "/%*.*s %ld\n",
942
			namelen, namelen, name, PTR_ERR(subdir));
943
	}
944 945 946 947 948
	drop_sysctl_table(&dir->header);
	if (new)
		drop_sysctl_table(&new->header);
	spin_unlock(&sysctl_lock);
	return subdir;
949 950
}

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
static struct ctl_dir *xlate_dir(struct ctl_table_set *set, struct ctl_dir *dir)
{
	struct ctl_dir *parent;
	const char *procname;
	if (!dir->header.parent)
		return &set->dir;
	parent = xlate_dir(set, dir->header.parent);
	if (IS_ERR(parent))
		return parent;
	procname = dir->header.ctl_table[0].procname;
	return find_subdir(parent, procname, strlen(procname));
}

static int sysctl_follow_link(struct ctl_table_header **phead,
	struct ctl_table **pentry, struct nsproxy *namespaces)
{
	struct ctl_table_header *head;
	struct ctl_table_root *root;
	struct ctl_table_set *set;
	struct ctl_table *entry;
	struct ctl_dir *dir;
	int ret;

	ret = 0;
	spin_lock(&sysctl_lock);
	root = (*pentry)->data;
	set = lookup_header_set(root, namespaces);
	dir = xlate_dir(set, (*phead)->parent);
	if (IS_ERR(dir))
		ret = PTR_ERR(dir);
	else {
		const char *procname = (*pentry)->procname;
		head = NULL;
		entry = find_entry(&head, dir, procname, strlen(procname));
		ret = -ENOENT;
		if (entry && use_table(head)) {
			unuse_table(*phead);
			*phead = head;
			*pentry = entry;
			ret = 0;
		}
	}

	spin_unlock(&sysctl_lock);
	return ret;
}

998
static int sysctl_err(const char *path, struct ctl_table *table, char *fmt, ...)
999
{
1000 1001
	struct va_format vaf;
	va_list args;
1002

1003 1004 1005 1006 1007 1008
	va_start(args, fmt);
	vaf.fmt = fmt;
	vaf.va = &args;

	printk(KERN_ERR "sysctl table check failed: %s/%s %pV\n",
		path, table->procname, &vaf);
1009

1010 1011
	va_end(args);
	return -EINVAL;
1012 1013
}

1014
static int sysctl_check_table(const char *path, struct ctl_table *table)
1015
{
1016
	int err = 0;
1017 1018
	for (; table->procname; table++) {
		if (table->child)
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
			err = sysctl_err(path, table, "Not a file");

		if ((table->proc_handler == proc_dostring) ||
		    (table->proc_handler == proc_dointvec) ||
		    (table->proc_handler == proc_dointvec_minmax) ||
		    (table->proc_handler == proc_dointvec_jiffies) ||
		    (table->proc_handler == proc_dointvec_userhz_jiffies) ||
		    (table->proc_handler == proc_dointvec_ms_jiffies) ||
		    (table->proc_handler == proc_doulongvec_minmax) ||
		    (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
			if (!table->data)
				err = sysctl_err(path, table, "No data");
			if (!table->maxlen)
				err = sysctl_err(path, table, "No maxlen");
		}
		if (!table->proc_handler)
			err = sysctl_err(path, table, "No proc_handler");

		if ((table->mode & (S_IRUGO|S_IWUGO)) != table->mode)
			err = sysctl_err(path, table, "bogus .mode 0%o",
				table->mode);
1040
	}
1041
	return err;
1042 1043
}

1044 1045 1046 1047 1048
static struct ctl_table_header *new_links(struct ctl_dir *dir, struct ctl_table *table,
	struct ctl_table_root *link_root)
{
	struct ctl_table *link_table, *entry, *link;
	struct ctl_table_header *links;
1049
	struct ctl_node *node;
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
	char *link_name;
	int nr_entries, name_bytes;

	name_bytes = 0;
	nr_entries = 0;
	for (entry = table; entry->procname; entry++) {
		nr_entries++;
		name_bytes += strlen(entry->procname) + 1;
	}

	links = kzalloc(sizeof(struct ctl_table_header) +
1061
			sizeof(struct ctl_node)*nr_entries +
1062 1063 1064 1065 1066 1067 1068
			sizeof(struct ctl_table)*(nr_entries + 1) +
			name_bytes,
			GFP_KERNEL);

	if (!links)
		return NULL;

1069 1070
	node = (struct ctl_node *)(links + 1);
	link_table = (struct ctl_table *)(node + nr_entries);
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
	link_name = (char *)&link_table[nr_entries + 1];

	for (link = link_table, entry = table; entry->procname; link++, entry++) {
		int len = strlen(entry->procname) + 1;
		memcpy(link_name, entry->procname, len);
		link->procname = link_name;
		link->mode = S_IFLNK|S_IRWXUGO;
		link->data = link_root;
		link_name += len;
	}
1081
	init_header(links, dir->header.root, dir->header.set, node, link_table);
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
	links->nreg = nr_entries;

	return links;
}

static bool get_links(struct ctl_dir *dir,
	struct ctl_table *table, struct ctl_table_root *link_root)
{
	struct ctl_table_header *head;
	struct ctl_table *entry, *link;

	/* Are there links available for every entry in table? */
	for (entry = table; entry->procname; entry++) {
		const char *procname = entry->procname;
		link = find_entry(&head, dir, procname, strlen(procname));
		if (!link)
			return false;
		if (S_ISDIR(link->mode) && S_ISDIR(entry->mode))
			continue;
		if (S_ISLNK(link->mode) && (link->data == link_root))
			continue;
		return false;
	}

	/* The checks passed.  Increase the registration count on the links */
	for (entry = table; entry->procname; entry++) {
		const char *procname = entry->procname;
		link = find_entry(&head, dir, procname, strlen(procname));
		head->nreg++;
	}
	return true;
}

static int insert_links(struct ctl_table_header *head)
{
	struct ctl_table_set *root_set = &sysctl_table_root.default_set;
	struct ctl_dir *core_parent = NULL;
	struct ctl_table_header *links;
	int err;

	if (head->set == root_set)
		return 0;

	core_parent = xlate_dir(root_set, head->parent);
	if (IS_ERR(core_parent))
		return 0;

	if (get_links(core_parent, head->ctl_table, head->root))
		return 0;

	core_parent->header.nreg++;
	spin_unlock(&sysctl_lock);

	links = new_links(core_parent, head->ctl_table, head->root);

	spin_lock(&sysctl_lock);
	err = -ENOMEM;
	if (!links)
		goto out;

	err = 0;
	if (get_links(core_parent, head->ctl_table, head->root)) {
		kfree(links);
		goto out;
	}

	err = insert_header(core_parent, links);
	if (err)
		kfree(links);
out:
	drop_sysctl_table(&core_parent->header);
	return err;
}

1156
/**
1157
 * __register_sysctl_table - register a leaf sysctl table
1158
 * @set: Sysctl tree to register on
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
 * @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
 *
1174
 * mode - the file permissions for the /proc/sys file
1175
 *
1176
 * child - must be %NULL.
1177 1178 1179 1180 1181 1182 1183 1184
 *
 * proc_handler - the text handler routine (described below)
 *
 * 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.
 *
1185 1186
 * There must be a proc_handler routine for any terminal nodes.
 * Several default handlers are available to cover common cases -
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
 *
 * 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.
 */
1198
struct ctl_table_header *__register_sysctl_table(
1199
	struct ctl_table_set *set,
1200
	const char *path, struct ctl_table *table)
1201
{
1202
	struct ctl_table_root *root = set->dir.header.root;
1203
	struct ctl_table_header *header;
1204
	const char *name, *nextname;
1205
	struct ctl_dir *dir;
1206 1207 1208 1209 1210 1211
	struct ctl_table *entry;
	struct ctl_node *node;
	int nr_entries = 0;

	for (entry = table; entry->procname; entry++)
		nr_entries++;
1212

1213 1214
	header = kzalloc(sizeof(struct ctl_table_header) +
			 sizeof(struct ctl_node)*nr_entries, GFP_KERNEL);
1215 1216 1217
	if (!header)
		return NULL;

1218 1219
	node = (struct ctl_node *)(header + 1);
	init_header(header, root, set, node, table);
1220 1221 1222 1223
	if (sysctl_check_table(path, table))
		goto fail;

	spin_lock(&sysctl_lock);
1224
	dir = &set->dir;
1225
	/* Reference moved down the diretory tree get_subdir */
1226 1227
	dir->header.nreg++;
	spin_unlock(&sysctl_lock);
1228

1229
	/* Find the directory for the ctl_table */
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
	for (name = path; name; name = nextname) {
		int namelen;
		nextname = strchr(name, '/');
		if (nextname) {
			namelen = nextname - name;
			nextname++;
		} else {
			namelen = strlen(name);
		}
		if (namelen == 0)
			continue;
1241

1242
		dir = get_subdir(dir, name, namelen);
1243 1244
		if (IS_ERR(dir))
			goto fail;
1245
	}
1246

1247
	spin_lock(&sysctl_lock);
1248
	if (insert_header(dir, header))
1249
		goto fail_put_dir_locked;
1250

1251
	drop_sysctl_table(&dir->header);
1252 1253 1254
	spin_unlock(&sysctl_lock);

	return header;
1255

1256 1257
fail_put_dir_locked:
	drop_sysctl_table(&dir->header);
1258 1259 1260 1261 1262
	spin_unlock(&sysctl_lock);
fail:
	kfree(header);
	dump_stack();
	return NULL;
1263 1264
}

1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
/**
 * register_sysctl - register a sysctl table
 * @path: The path to the directory the sysctl table is in.
 * @table: the table structure
 *
 * Register a sysctl table. @table should be a filled in ctl_table
 * array. A completely 0 filled entry terminates the table.
 *
 * See __register_sysctl_table for more details.
 */
struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table)
{
	return __register_sysctl_table(&sysctl_table_root.default_set,
					path, table);
}
EXPORT_SYMBOL(register_sysctl);

1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
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;
}

1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
static int count_subheaders(struct ctl_table *table)
{
	int has_files = 0;
	int nr_subheaders = 0;
	struct ctl_table *entry;

	/* special case: no directory and empty directory */
	if (!table || !table->procname)
		return 1;

	for (entry = table; entry->procname; entry++) {
		if (entry->child)
			nr_subheaders += count_subheaders(entry->child);
		else
			has_files = 1;
	}
	return nr_subheaders + has_files;
}

static int register_leaf_sysctl_tables(const char *path, char *pos,
1315
	struct ctl_table_header ***subheader, struct ctl_table_set *set,
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	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;

	for (entry = table; entry->procname; entry++) {
		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 = kzalloc(sizeof(struct ctl_table) * (nr_files + 1),
				GFP_KERNEL);
		if (!files)
			goto out;

		ctl_table_arg = files;
		for (new = files, entry = table; entry->procname; entry++) {
			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;
1352
		header = __register_sysctl_table(set, path, files);
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
		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. */
	for (entry = table; entry->procname; entry++) {
		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,
1377
						  set, entry->child);
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
		pos[0] = '\0';
		if (err)
			goto out;
	}
	err = 0;
out:
	/* On failure our caller will unregister all registered subheaders */
	return err;
}

1388 1389
/**
 * __register_sysctl_paths - register a sysctl table hierarchy
1390
 * @set: Sysctl tree to register on
1391 1392 1393 1394 1395 1396 1397 1398 1399
 * @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_table for more details.
 */
struct ctl_table_header *__register_sysctl_paths(
1400
	struct ctl_table_set *set,
1401 1402
	const struct ctl_path *path, struct ctl_table *table)
{
1403
	struct ctl_table *ctl_table_arg = table;
1404 1405
	int nr_subheaders = count_subheaders(table);
	struct ctl_table_header *header = NULL, **subheaders, **subheader;
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
	const struct ctl_path *component;
	char *new_path, *pos;

	pos = new_path = kmalloc(PATH_MAX, GFP_KERNEL);
	if (!new_path)
		return NULL;

	pos[0] = '\0';
	for (component = path; component->procname; component++) {
		pos = append_path(new_path, pos, component->procname);
		if (!pos)
			goto out;
	}
1419 1420 1421 1422 1423 1424
	while (table->procname && table->child && !table[1].procname) {
		pos = append_path(new_path, pos, table->procname);
		if (!pos)
			goto out;
		table = table->child;
	}
1425
	if (nr_subheaders == 1) {
1426
		header = __register_sysctl_table(set, new_path, table);
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
		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;
1437
		header->ctl_table_arg = ctl_table_arg;
1438 1439

		if (register_leaf_sysctl_tables(new_path, pos, &subheader,
1440
						set, table))
1441 1442 1443
			goto err_register_leaves;
	}

1444 1445 1446
out:
	kfree(new_path);
	return header;
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457

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;
1458 1459
}

1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472
/**
 * 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)
{
1473
	return __register_sysctl_paths(&sysctl_table_root.default_set,
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
					path, table);
}
EXPORT_SYMBOL(register_sysctl_paths);

/**
 * 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);
}
EXPORT_SYMBOL(register_sysctl_table);

1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
static void put_links(struct ctl_table_header *header)
{
	struct ctl_table_set *root_set = &sysctl_table_root.default_set;
	struct ctl_table_root *root = header->root;
	struct ctl_dir *parent = header->parent;
	struct ctl_dir *core_parent;
	struct ctl_table *entry;

	if (header->set == root_set)
		return;

	core_parent = xlate_dir(root_set, parent);
	if (IS_ERR(core_parent))
		return;

	for (entry = header->ctl_table; entry->procname; entry++) {
		struct ctl_table_header *link_head;
		struct ctl_table *link;
		const char *name = entry->procname;

		link = find_entry(&link_head, core_parent, name, strlen(name));
		if (link &&
		    ((S_ISDIR(link->mode) && S_ISDIR(entry->mode)) ||
		     (S_ISLNK(link->mode) && (link->data == root)))) {
			drop_sysctl_table(link_head);
		}
		else {
			printk(KERN_ERR "sysctl link missing during unregister: ");
			sysctl_print_dir(parent);
			printk(KERN_CONT "/%s\n", name);
		}
	}
}

1529 1530
static void drop_sysctl_table(struct ctl_table_header *header)
{
1531 1532
	struct ctl_dir *parent = header->parent;

1533 1534 1535
	if (--header->nreg)
		return;

1536
	put_links(header);
1537 1538 1539
	start_unregistering(header);
	if (!--header->count)
		kfree_rcu(header, rcu);
1540 1541 1542

	if (parent)
		drop_sysctl_table(&parent->header);
1543 1544
}

1545 1546 1547 1548 1549 1550 1551 1552 1553
/**
 * 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)
{
1554
	int nr_subheaders;
1555 1556 1557 1558 1559
	might_sleep();

	if (header == NULL)
		return;

1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
	nr_subheaders = count_subheaders(header->ctl_table_arg);
	if (unlikely(nr_subheaders > 1)) {
		struct ctl_table_header **subheaders;
		int i;

		subheaders = (struct ctl_table_header **)(header + 1);
		for (i = nr_subheaders -1; i >= 0; i--) {
			struct ctl_table_header *subh = subheaders[i];
			struct ctl_table *table = subh->ctl_table_arg;
			unregister_sysctl_table(subh);
			kfree(table);
		}
		kfree(header);
		return;
	}

1576
	spin_lock(&sysctl_lock);
1577
	drop_sysctl_table(header);
1578 1579 1580 1581
	spin_unlock(&sysctl_lock);
}
EXPORT_SYMBOL(unregister_sysctl_table);

1582
void setup_sysctl_set(struct ctl_table_set *set,
1583
	struct ctl_table_root *root,
1584 1585
	int (*is_seen)(struct ctl_table_set *))
{
1586
	memset(set, 0, sizeof(*set));
1587
	set->is_seen = is_seen;
1588
	init_header(&set->dir.header, root, set, NULL, root_table);
1589 1590
}

1591 1592
void retire_sysctl_set(struct ctl_table_set *set)
{
1593
	WARN_ON(!RB_EMPTY_ROOT(&set->dir.root));
1594
}
1595

A
Alexey Dobriyan 已提交
1596
int __init proc_sys_init(void)
1597
{
A
Alexey Dobriyan 已提交
1598 1599
	struct proc_dir_entry *proc_sys_root;

1600
	proc_sys_root = proc_mkdir("sys", NULL);
A
Al Viro 已提交
1601 1602
	proc_sys_root->proc_iops = &proc_sys_dir_operations;
	proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
1603
	proc_sys_root->nlink = 0;
1604 1605

	return sysctl_init();
1606
}