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