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