?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/mm/pat: Don't report PAT on CPUs that don't support it
[linux/fpc-iii.git] / fs / proc / proc_sysctl.c
blob4353faa9d4162bd720e4a1e78b04f44fdc50ecf3
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 void register_sysctl_root(struct ctl_table_root *root)
429 {
430 }
431
432 /*
433 * sysctl_perm does NOT grant the superuser all rights automatically, because
434 * some sysctl variables are readonly even to root.
435 */
436
437 static int test_perm(int mode, int op)
438 {
439 if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
440 mode >>= 6;
441 else if (in_egroup_p(GLOBAL_ROOT_GID))
442 mode >>= 3;
443 if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
444 return 0;
445 return -EACCES;
446 }
447
448 static int sysctl_perm(struct ctl_table_header *head, struct ctl_table *table, int op)
449 {
450 struct ctl_table_root *root = head->root;
451 int mode;
452
453 if (root->permissions)
454 mode = root->permissions(head, table);
455 else
456 mode = table->mode;
457
458 return test_perm(mode, op);
459 }
460
461 static struct inode *proc_sys_make_inode(struct super_block *sb,
462 struct ctl_table_header *head, struct ctl_table *table)
463 {
464 struct ctl_table_root *root = head->root;
465 struct inode *inode;
466 struct proc_inode *ei;
467
468 inode = new_inode(sb);
469 if (!inode)
470 goto out;
471
472 inode->i_ino = get_next_ino();
473
474 ei = PROC_I(inode);
475
476 spin_lock(&sysctl_lock);
477 if (unlikely(head->unregistering)) {
478 spin_unlock(&sysctl_lock);
479 iput(inode);
480 inode = NULL;
481 goto out;
482 }
483 ei->sysctl = head;
484 ei->sysctl_entry = table;
485 hlist_add_head_rcu(&ei->sysctl_inodes, &head->inodes);
486 head->count++;
487 spin_unlock(&sysctl_lock);
488
489 inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
490 inode->i_mode = table->mode;
491 if (!S_ISDIR(table->mode)) {
492 inode->i_mode |= S_IFREG;
493 inode->i_op = &proc_sys_inode_operations;
494 inode->i_fop = &proc_sys_file_operations;
495 } else {
496 inode->i_mode |= S_IFDIR;
497 inode->i_op = &proc_sys_dir_operations;
498 inode->i_fop = &proc_sys_dir_file_operations;
499 if (is_empty_dir(head))
500 make_empty_dir_inode(inode);
501 }
502
503 if (root->set_ownership)
504 root->set_ownership(head, table, &inode->i_uid, &inode->i_gid);
505
506 out:
507 return inode;
508 }
509
510 void proc_sys_evict_inode(struct inode *inode, struct ctl_table_header *head)
511 {
512 spin_lock(&sysctl_lock);
513 hlist_del_init_rcu(&PROC_I(inode)->sysctl_inodes);
514 if (!--head->count)
515 kfree_rcu(head, rcu);
516 spin_unlock(&sysctl_lock);
517 }
518
519 static struct ctl_table_header *grab_header(struct inode *inode)
520 {
521 struct ctl_table_header *head = PROC_I(inode)->sysctl;
522 if (!head)
523 head = &sysctl_table_root.default_set.dir.header;
524 return sysctl_head_grab(head);
525 }
526
527 static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
528 unsigned int flags)
529 {
530 struct ctl_table_header *head = grab_header(dir);
531 struct ctl_table_header *h = NULL;
532 const struct qstr *name = &dentry->d_name;
533 struct ctl_table *p;
534 struct inode *inode;
535 struct dentry *err = ERR_PTR(-ENOENT);
536 struct ctl_dir *ctl_dir;
537 int ret;
538
539 if (IS_ERR(head))
540 return ERR_CAST(head);
541
542 ctl_dir = container_of(head, struct ctl_dir, header);
543
544 p = lookup_entry(&h, ctl_dir, name->name, name->len);
545 if (!p)
546 goto out;
547
548 if (S_ISLNK(p->mode)) {
549 ret = sysctl_follow_link(&h, &p);
550 err = ERR_PTR(ret);
551 if (ret)
552 goto out;
553 }
554
555 err = ERR_PTR(-ENOMEM);
556 inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
557 if (!inode)
558 goto out;
559
560 err = NULL;
561 d_set_d_op(dentry, &proc_sys_dentry_operations);
562 d_add(dentry, inode);
563
564 out:
565 if (h)
566 sysctl_head_finish(h);
567 sysctl_head_finish(head);
568 return err;
569 }
570
571 static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
572 size_t count, loff_t *ppos, int write)
573 {
574 struct inode *inode = file_inode(filp);
575 struct ctl_table_header *head = grab_header(inode);
576 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
577 ssize_t error;
578 size_t res;
579
580 if (IS_ERR(head))
581 return PTR_ERR(head);
582
583 /*
584 * At this point we know that the sysctl was not unregistered
585 * and won't be until we finish.
586 */
587 error = -EPERM;
588 if (sysctl_perm(head, table, write ? MAY_WRITE : MAY_READ))
589 goto out;
590
591 /* if that can happen at all, it should be -EINVAL, not -EISDIR */
592 error = -EINVAL;
593 if (!table->proc_handler)
594 goto out;
595
596 /* careful: calling conventions are nasty here */
597 res = count;
598 error = table->proc_handler(table, write, buf, &res, ppos);
599 if (!error)
600 error = res;
601 out:
602 sysctl_head_finish(head);
603
604 return error;
605 }
606
607 static ssize_t proc_sys_read(struct file *filp, char __user *buf,
608 size_t count, loff_t *ppos)
609 {
610 return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
611 }
612
613 static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
614 size_t count, loff_t *ppos)
615 {
616 return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
617 }
618
619 static int proc_sys_open(struct inode *inode, struct file *filp)
620 {
621 struct ctl_table_header *head = grab_header(inode);
622 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
623
624 /* sysctl was unregistered */
625 if (IS_ERR(head))
626 return PTR_ERR(head);
627
628 if (table->poll)
629 filp->private_data = proc_sys_poll_event(table->poll);
630
631 sysctl_head_finish(head);
632
633 return 0;
634 }
635
636 static unsigned int proc_sys_poll(struct file *filp, poll_table *wait)
637 {
638 struct inode *inode = file_inode(filp);
639 struct ctl_table_header *head = grab_header(inode);
640 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
641 unsigned int ret = DEFAULT_POLLMASK;
642 unsigned long event;
643
644 /* sysctl was unregistered */
645 if (IS_ERR(head))
646 return POLLERR | POLLHUP;
647
648 if (!table->proc_handler)
649 goto out;
650
651 if (!table->poll)
652 goto out;
653
654 event = (unsigned long)filp->private_data;
655 poll_wait(filp, &table->poll->wait, wait);
656
657 if (event != atomic_read(&table->poll->event)) {
658 filp->private_data = proc_sys_poll_event(table->poll);
659 ret = POLLIN | POLLRDNORM | POLLERR | POLLPRI;
660 }
661
662 out:
663 sysctl_head_finish(head);
664
665 return ret;
666 }
667
668 static bool proc_sys_fill_cache(struct file *file,
669 struct dir_context *ctx,
670 struct ctl_table_header *head,
671 struct ctl_table *table)
672 {
673 struct dentry *child, *dir = file->f_path.dentry;
674 struct inode *inode;
675 struct qstr qname;
676 ino_t ino = 0;
677 unsigned type = DT_UNKNOWN;
678
679 qname.name = table->procname;
680 qname.len = strlen(table->procname);
681 qname.hash = full_name_hash(dir, qname.name, qname.len);
682
683 child = d_lookup(dir, &qname);
684 if (!child) {
685 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
686 child = d_alloc_parallel(dir, &qname, &wq);
687 if (IS_ERR(child))
688 return false;
689 if (d_in_lookup(child)) {
690 inode = proc_sys_make_inode(dir->d_sb, head, table);
691 if (!inode) {
692 d_lookup_done(child);
693 dput(child);
694 return false;
695 }
696 d_set_d_op(child, &proc_sys_dentry_operations);
697 d_add(child, inode);
698 }
699 }
700 inode = d_inode(child);
701 ino = inode->i_ino;
702 type = inode->i_mode >> 12;
703 dput(child);
704 return dir_emit(ctx, qname.name, qname.len, ino, type);
705 }
706
707 static bool proc_sys_link_fill_cache(struct file *file,
708 struct dir_context *ctx,
709 struct ctl_table_header *head,
710 struct ctl_table *table)
711 {
712 bool ret = true;
713 head = sysctl_head_grab(head);
714
715 if (S_ISLNK(table->mode)) {
716 /* It is not an error if we can not follow the link ignore it */
717 int err = sysctl_follow_link(&head, &table);
718 if (err)
719 goto out;
720 }
721
722 ret = proc_sys_fill_cache(file, ctx, head, table);
723 out:
724 sysctl_head_finish(head);
725 return ret;
726 }
727
728 static int scan(struct ctl_table_header *head, struct ctl_table *table,
729 unsigned long *pos, struct file *file,
730 struct dir_context *ctx)
731 {
732 bool res;
733
734 if ((*pos)++ < ctx->pos)
735 return true;
736
737 if (unlikely(S_ISLNK(table->mode)))
738 res = proc_sys_link_fill_cache(file, ctx, head, table);
739 else
740 res = proc_sys_fill_cache(file, ctx, head, table);
741
742 if (res)
743 ctx->pos = *pos;
744
745 return res;
746 }
747
748 static int proc_sys_readdir(struct file *file, struct dir_context *ctx)
749 {
750 struct ctl_table_header *head = grab_header(file_inode(file));
751 struct ctl_table_header *h = NULL;
752 struct ctl_table *entry;
753 struct ctl_dir *ctl_dir;
754 unsigned long pos;
755
756 if (IS_ERR(head))
757 return PTR_ERR(head);
758
759 ctl_dir = container_of(head, struct ctl_dir, header);
760
761 if (!dir_emit_dots(file, ctx))
762 goto out;
763
764 pos = 2;
765
766 for (first_entry(ctl_dir, &h, &entry); h; next_entry(&h, &entry)) {
767 if (!scan(h, entry, &pos, file, ctx)) {
768 sysctl_head_finish(h);
769 break;
770 }
771 }
772 out:
773 sysctl_head_finish(head);
774 return 0;
775 }
776
777 static int proc_sys_permission(struct inode *inode, int mask)
778 {
779 /*
780 * sysctl entries that are not writeable,
781 * are _NOT_ writeable, capabilities or not.
782 */
783 struct ctl_table_header *head;
784 struct ctl_table *table;
785 int error;
786
787 /* Executable files are not allowed under /proc/sys/ */
788 if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
789 return -EACCES;
790
791 head = grab_header(inode);
792 if (IS_ERR(head))
793 return PTR_ERR(head);
794
795 table = PROC_I(inode)->sysctl_entry;
796 if (!table) /* global root - r-xr-xr-x */
797 error = mask & MAY_WRITE ? -EACCES : 0;
798 else /* Use the permissions on the sysctl table entry */
799 error = sysctl_perm(head, table, mask & ~MAY_NOT_BLOCK);
800
801 sysctl_head_finish(head);
802 return error;
803 }
804
805 static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
806 {
807 struct inode *inode = d_inode(dentry);
808 int error;
809
810 if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
811 return -EPERM;
812
813 error = setattr_prepare(dentry, attr);
814 if (error)
815 return error;
816
817 setattr_copy(inode, attr);
818 mark_inode_dirty(inode);
819 return 0;
820 }
821
822 static int proc_sys_getattr(const struct path *path, struct kstat *stat,
823 u32 request_mask, unsigned int query_flags)
824 {
825 struct inode *inode = d_inode(path->dentry);
826 struct ctl_table_header *head = grab_header(inode);
827 struct ctl_table *table = PROC_I(inode)->sysctl_entry;
828
829 if (IS_ERR(head))
830 return PTR_ERR(head);
831
832 generic_fillattr(inode, stat);
833 if (table)
834 stat->mode = (stat->mode & S_IFMT) | table->mode;
835
836 sysctl_head_finish(head);
837 return 0;
838 }
839
840 static const struct file_operations proc_sys_file_operations = {
841 .open = proc_sys_open,
842 .poll = proc_sys_poll,
843 .read = proc_sys_read,
844 .write = proc_sys_write,
845 .llseek = default_llseek,
846 };
847
848 static const struct file_operations proc_sys_dir_file_operations = {
849 .read = generic_read_dir,
850 .iterate_shared = proc_sys_readdir,
851 .llseek = generic_file_llseek,
852 };
853
854 static const struct inode_operations proc_sys_inode_operations = {
855 .permission = proc_sys_permission,
856 .setattr = proc_sys_setattr,
857 .getattr = proc_sys_getattr,
858 };
859
860 static const struct inode_operations proc_sys_dir_operations = {
861 .lookup = proc_sys_lookup,
862 .permission = proc_sys_permission,
863 .setattr = proc_sys_setattr,
864 .getattr = proc_sys_getattr,
865 };
866
867 static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
868 {
869 if (flags & LOOKUP_RCU)
870 return -ECHILD;
871 return !PROC_I(d_inode(dentry))->sysctl->unregistering;
872 }
873
874 static int proc_sys_delete(const struct dentry *dentry)
875 {
876 return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
877 }
878
879 static int sysctl_is_seen(struct ctl_table_header *p)
880 {
881 struct ctl_table_set *set = p->set;
882 int res;
883 spin_lock(&sysctl_lock);
884 if (p->unregistering)
885 res = 0;
886 else if (!set->is_seen)
887 res = 1;
888 else
889 res = set->is_seen(set);
890 spin_unlock(&sysctl_lock);
891 return res;
892 }
893
894 static int proc_sys_compare(const struct dentry *dentry,
895 unsigned int len, const char *str, const struct qstr *name)
896 {
897 struct ctl_table_header *head;
898 struct inode *inode;
899
900 /* Although proc doesn't have negative dentries, rcu-walk means
901 * that inode here can be NULL */
902 /* AV: can it, indeed? */
903 inode = d_inode_rcu(dentry);
904 if (!inode)
905 return 1;
906 if (name->len != len)
907 return 1;
908 if (memcmp(name->name, str, len))
909 return 1;
910 head = rcu_dereference(PROC_I(inode)->sysctl);
911 return !head || !sysctl_is_seen(head);
912 }
913
914 static const struct dentry_operations proc_sys_dentry_operations = {
915 .d_revalidate = proc_sys_revalidate,
916 .d_delete = proc_sys_delete,
917 .d_compare = proc_sys_compare,
918 };
919
920 static struct ctl_dir *find_subdir(struct ctl_dir *dir,
921 const char *name, int namelen)
922 {
923 struct ctl_table_header *head;
924 struct ctl_table *entry;
925
926 entry = find_entry(&head, dir, name, namelen);
927 if (!entry)
928 return ERR_PTR(-ENOENT);
929 if (!S_ISDIR(entry->mode))
930 return ERR_PTR(-ENOTDIR);
931 return container_of(head, struct ctl_dir, header);
932 }
933
934 static struct ctl_dir *new_dir(struct ctl_table_set *set,
935 const char *name, int namelen)
936 {
937 struct ctl_table *table;
938 struct ctl_dir *new;
939 struct ctl_node *node;
940 char *new_name;
941
942 new = kzalloc(sizeof(*new) + sizeof(struct ctl_node) +
943 sizeof(struct ctl_table)*2 + namelen + 1,
944 GFP_KERNEL);
945 if (!new)
946 return NULL;
947
948 node = (struct ctl_node *)(new + 1);
949 table = (struct ctl_table *)(node + 1);
950 new_name = (char *)(table + 2);
951 memcpy(new_name, name, namelen);
952 new_name[namelen] = '\0';
953 table[0].procname = new_name;
954 table[0].mode = S_IFDIR|S_IRUGO|S_IXUGO;
955 init_header(&new->header, set->dir.header.root, set, node, table);
956
957 return new;
958 }
959
960 /**
961 * get_subdir - find or create a subdir with the specified name.
962 * @dir: Directory to create the subdirectory in
963 * @name: The name of the subdirectory to find or create
964 * @namelen: The length of name
965 *
966 * Takes a directory with an elevated reference count so we know that
967 * if we drop the lock the directory will not go away. Upon success
968 * the reference is moved from @dir to the returned subdirectory.
969 * Upon error an error code is returned and the reference on @dir is
970 * simply dropped.
971 */
972 static struct ctl_dir *get_subdir(struct ctl_dir *dir,
973 const char *name, int namelen)
974 {
975 struct ctl_table_set *set = dir->header.set;
976 struct ctl_dir *subdir, *new = NULL;
977 int err;
978
979 spin_lock(&sysctl_lock);
980 subdir = find_subdir(dir, name, namelen);
981 if (!IS_ERR(subdir))
982 goto found;
983 if (PTR_ERR(subdir) != -ENOENT)
984 goto failed;
985
986 spin_unlock(&sysctl_lock);
987 new = new_dir(set, name, namelen);
988 spin_lock(&sysctl_lock);
989 subdir = ERR_PTR(-ENOMEM);
990 if (!new)
991 goto failed;
992
993 /* Was the subdir added while we dropped the lock? */
994 subdir = find_subdir(dir, name, namelen);
995 if (!IS_ERR(subdir))
996 goto found;
997 if (PTR_ERR(subdir) != -ENOENT)
998 goto failed;
999
1000 /* Nope. Use the our freshly made directory entry. */
1001 err = insert_header(dir, &new->header);
1002 subdir = ERR_PTR(err);
1003 if (err)
1004 goto failed;
1005 subdir = new;
1006 found:
1007 subdir->header.nreg++;
1008 failed:
1009 if (IS_ERR(subdir)) {
1010 pr_err("sysctl could not get directory: ");
1011 sysctl_print_dir(dir);
1012 pr_cont("/%*.*s %ld\n",
1013 namelen, namelen, name, PTR_ERR(subdir));
1014 }
1015 drop_sysctl_table(&dir->header);
1016 if (new)
1017 drop_sysctl_table(&new->header);
1018 spin_unlock(&sysctl_lock);
1019 return subdir;
1020 }
1021
1022 static struct ctl_dir *xlate_dir(struct ctl_table_set *set, struct ctl_dir *dir)
1023 {
1024 struct ctl_dir *parent;
1025 const char *procname;
1026 if (!dir->header.parent)
1027 return &set->dir;
1028 parent = xlate_dir(set, dir->header.parent);
1029 if (IS_ERR(parent))
1030 return parent;
1031 procname = dir->header.ctl_table[0].procname;
1032 return find_subdir(parent, procname, strlen(procname));
1033 }
1034
1035 static int sysctl_follow_link(struct ctl_table_header **phead,
1036 struct ctl_table **pentry)
1037 {
1038 struct ctl_table_header *head;
1039 struct ctl_table_root *root;
1040 struct ctl_table_set *set;
1041 struct ctl_table *entry;
1042 struct ctl_dir *dir;
1043 int ret;
1044
1045 ret = 0;
1046 spin_lock(&sysctl_lock);
1047 root = (*pentry)->data;
1048 set = lookup_header_set(root);
1049 dir = xlate_dir(set, (*phead)->parent);
1050 if (IS_ERR(dir))
1051 ret = PTR_ERR(dir);
1052 else {
1053 const char *procname = (*pentry)->procname;
1054 head = NULL;
1055 entry = find_entry(&head, dir, procname, strlen(procname));
1056 ret = -ENOENT;
1057 if (entry && use_table(head)) {
1058 unuse_table(*phead);
1059 *phead = head;
1060 *pentry = entry;
1061 ret = 0;
1062 }
1063 }
1064
1065 spin_unlock(&sysctl_lock);
1066 return ret;
1067 }
1068
1069 static int sysctl_err(const char *path, struct ctl_table *table, char *fmt, ...)
1070 {
1071 struct va_format vaf;
1072 va_list args;
1073
1074 va_start(args, fmt);
1075 vaf.fmt = fmt;
1076 vaf.va = &args;
1077
1078 pr_err("sysctl table check failed: %s/%s %pV\n",
1079 path, table->procname, &vaf);
1080
1081 va_end(args);
1082 return -EINVAL;
1083 }
1084
1085 static int sysctl_check_table(const char *path, struct ctl_table *table)
1086 {
1087 int err = 0;
1088 for (; table->procname; table++) {
1089 if (table->child)
1090 err = sysctl_err(path, table, "Not a file");
1091
1092 if ((table->proc_handler == proc_dostring) ||
1093 (table->proc_handler == proc_dointvec) ||
1094 (table->proc_handler == proc_douintvec) ||
1095 (table->proc_handler == proc_dointvec_minmax) ||
1096 (table->proc_handler == proc_dointvec_jiffies) ||
1097 (table->proc_handler == proc_dointvec_userhz_jiffies) ||
1098 (table->proc_handler == proc_dointvec_ms_jiffies) ||
1099 (table->proc_handler == proc_doulongvec_minmax) ||
1100 (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
1101 if (!table->data)
1102 err = sysctl_err(path, table, "No data");
1103 if (!table->maxlen)
1104 err = sysctl_err(path, table, "No maxlen");
1105 }
1106 if (!table->proc_handler)
1107 err = sysctl_err(path, table, "No proc_handler");
1108
1109 if ((table->mode & (S_IRUGO|S_IWUGO)) != table->mode)
1110 err = sysctl_err(path, table, "bogus .mode 0%o",
1111 table->mode);
1112 }
1113 return err;
1114 }
1115
1116 static struct ctl_table_header *new_links(struct ctl_dir *dir, struct ctl_table *table,
1117 struct ctl_table_root *link_root)
1118 {
1119 struct ctl_table *link_table, *entry, *link;
1120 struct ctl_table_header *links;
1121 struct ctl_node *node;
1122 char *link_name;
1123 int nr_entries, name_bytes;
1124
1125 name_bytes = 0;
1126 nr_entries = 0;
1127 for (entry = table; entry->procname; entry++) {
1128 nr_entries++;
1129 name_bytes += strlen(entry->procname) + 1;
1130 }
1131
1132 links = kzalloc(sizeof(struct ctl_table_header) +
1133 sizeof(struct ctl_node)*nr_entries +
1134 sizeof(struct ctl_table)*(nr_entries + 1) +
1135 name_bytes,
1136 GFP_KERNEL);
1137
1138 if (!links)
1139 return NULL;
1140
1141 node = (struct ctl_node *)(links + 1);
1142 link_table = (struct ctl_table *)(node + nr_entries);
1143 link_name = (char *)&link_table[nr_entries + 1];
1144
1145 for (link = link_table, entry = table; entry->procname; link++, entry++) {
1146 int len = strlen(entry->procname) + 1;
1147 memcpy(link_name, entry->procname, len);
1148 link->procname = link_name;
1149 link->mode = S_IFLNK|S_IRWXUGO;
1150 link->data = link_root;
1151 link_name += len;
1152 }
1153 init_header(links, dir->header.root, dir->header.set, node, link_table);
1154 links->nreg = nr_entries;
1155
1156 return links;
1157 }
1158
1159 static bool get_links(struct ctl_dir *dir,
1160 struct ctl_table *table, struct ctl_table_root *link_root)
1161 {
1162 struct ctl_table_header *head;
1163 struct ctl_table *entry, *link;
1164
1165 /* Are there links available for every entry in table? */
1166 for (entry = table; entry->procname; entry++) {
1167 const char *procname = entry->procname;
1168 link = find_entry(&head, dir, procname, strlen(procname));
1169 if (!link)
1170 return false;
1171 if (S_ISDIR(link->mode) && S_ISDIR(entry->mode))
1172 continue;
1173 if (S_ISLNK(link->mode) && (link->data == link_root))
1174 continue;
1175 return false;
1176 }
1177
1178 /* The checks passed. Increase the registration count on the links */
1179 for (entry = table; entry->procname; entry++) {
1180 const char *procname = entry->procname;
1181 link = find_entry(&head, dir, procname, strlen(procname));
1182 head->nreg++;
1183 }
1184 return true;
1185 }
1186
1187 static int insert_links(struct ctl_table_header *head)
1188 {
1189 struct ctl_table_set *root_set = &sysctl_table_root.default_set;
1190 struct ctl_dir *core_parent = NULL;
1191 struct ctl_table_header *links;
1192 int err;
1193
1194 if (head->set == root_set)
1195 return 0;
1196
1197 core_parent = xlate_dir(root_set, head->parent);
1198 if (IS_ERR(core_parent))
1199 return 0;
1200
1201 if (get_links(core_parent, head->ctl_table, head->root))
1202 return 0;
1203
1204 core_parent->header.nreg++;
1205 spin_unlock(&sysctl_lock);
1206
1207 links = new_links(core_parent, head->ctl_table, head->root);
1208
1209 spin_lock(&sysctl_lock);
1210 err = -ENOMEM;
1211 if (!links)
1212 goto out;
1213
1214 err = 0;
1215 if (get_links(core_parent, head->ctl_table, head->root)) {
1216 kfree(links);
1217 goto out;
1218 }
1219
1220 err = insert_header(core_parent, links);
1221 if (err)
1222 kfree(links);
1223 out:
1224 drop_sysctl_table(&core_parent->header);
1225 return err;
1226 }
1227
1228 /**
1229 * __register_sysctl_table - register a leaf sysctl table
1230 * @set: Sysctl tree to register on
1231 * @path: The path to the directory the sysctl table is in.
1232 * @table: the top-level table structure
1233 *
1234 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1235 * array. A completely 0 filled entry terminates the table.
1236 *
1237 * The members of the &struct ctl_table structure are used as follows:
1238 *
1239 * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1240 * enter a sysctl file
1241 *
1242 * data - a pointer to data for use by proc_handler
1243 *
1244 * maxlen - the maximum size in bytes of the data
1245 *
1246 * mode - the file permissions for the /proc/sys file
1247 *
1248 * child - must be %NULL.
1249 *
1250 * proc_handler - the text handler routine (described below)
1251 *
1252 * extra1, extra2 - extra pointers usable by the proc handler routines
1253 *
1254 * Leaf nodes in the sysctl tree will be represented by a single file
1255 * under /proc; non-leaf nodes will be represented by directories.
1256 *
1257 * There must be a proc_handler routine for any terminal nodes.
1258 * Several default handlers are available to cover common cases -
1259 *
1260 * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
1261 * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
1262 * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
1263 *
1264 * It is the handler's job to read the input buffer from user memory
1265 * and process it. The handler should return 0 on success.
1266 *
1267 * This routine returns %NULL on a failure to register, and a pointer
1268 * to the table header on success.
1269 */
1270 struct ctl_table_header *__register_sysctl_table(
1271 struct ctl_table_set *set,
1272 const char *path, struct ctl_table *table)
1273 {
1274 struct ctl_table_root *root = set->dir.header.root;
1275 struct ctl_table_header *header;
1276 const char *name, *nextname;
1277 struct ctl_dir *dir;
1278 struct ctl_table *entry;
1279 struct ctl_node *node;
1280 int nr_entries = 0;
1281
1282 for (entry = table; entry->procname; entry++)
1283 nr_entries++;
1284
1285 header = kzalloc(sizeof(struct ctl_table_header) +
1286 sizeof(struct ctl_node)*nr_entries, GFP_KERNEL);
1287 if (!header)
1288 return NULL;
1289
1290 node = (struct ctl_node *)(header + 1);
1291 init_header(header, root, set, node, table);
1292 if (sysctl_check_table(path, table))
1293 goto fail;
1294
1295 spin_lock(&sysctl_lock);
1296 dir = &set->dir;
1297 /* Reference moved down the diretory tree get_subdir */
1298 dir->header.nreg++;
1299 spin_unlock(&sysctl_lock);
1300
1301 /* Find the directory for the ctl_table */
1302 for (name = path; name; name = nextname) {
1303 int namelen;
1304 nextname = strchr(name, '/');
1305 if (nextname) {
1306 namelen = nextname - name;
1307 nextname++;
1308 } else {
1309 namelen = strlen(name);
1310 }
1311 if (namelen == 0)
1312 continue;
1313
1314 dir = get_subdir(dir, name, namelen);
1315 if (IS_ERR(dir))
1316 goto fail;
1317 }
1318
1319 spin_lock(&sysctl_lock);
1320 if (insert_header(dir, header))
1321 goto fail_put_dir_locked;
1322
1323 drop_sysctl_table(&dir->header);
1324 spin_unlock(&sysctl_lock);
1325
1326 return header;
1327
1328 fail_put_dir_locked:
1329 drop_sysctl_table(&dir->header);
1330 spin_unlock(&sysctl_lock);
1331 fail:
1332 kfree(header);
1333 dump_stack();
1334 return NULL;
1335 }
1336
1337 /**
1338 * register_sysctl - register a sysctl table
1339 * @path: The path to the directory the sysctl table is in.
1340 * @table: the table structure
1341 *
1342 * Register a sysctl table. @table should be a filled in ctl_table
1343 * array. A completely 0 filled entry terminates the table.
1344 *
1345 * See __register_sysctl_table for more details.
1346 */
1347 struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table)
1348 {
1349 return __register_sysctl_table(&sysctl_table_root.default_set,
1350 path, table);
1351 }
1352 EXPORT_SYMBOL(register_sysctl);
1353
1354 static char *append_path(const char *path, char *pos, const char *name)
1355 {
1356 int namelen;
1357 namelen = strlen(name);
1358 if (((pos - path) + namelen + 2) >= PATH_MAX)
1359 return NULL;
1360 memcpy(pos, name, namelen);
1361 pos[namelen] = '/';
1362 pos[namelen + 1] = '\0';
1363 pos += namelen + 1;
1364 return pos;
1365 }
1366
1367 static int count_subheaders(struct ctl_table *table)
1368 {
1369 int has_files = 0;
1370 int nr_subheaders = 0;
1371 struct ctl_table *entry;
1372
1373 /* special case: no directory and empty directory */
1374 if (!table || !table->procname)
1375 return 1;
1376
1377 for (entry = table; entry->procname; entry++) {
1378 if (entry->child)
1379 nr_subheaders += count_subheaders(entry->child);
1380 else
1381 has_files = 1;
1382 }
1383 return nr_subheaders + has_files;
1384 }
1385
1386 static int register_leaf_sysctl_tables(const char *path, char *pos,
1387 struct ctl_table_header ***subheader, struct ctl_table_set *set,
1388 struct ctl_table *table)
1389 {
1390 struct ctl_table *ctl_table_arg = NULL;
1391 struct ctl_table *entry, *files;
1392 int nr_files = 0;
1393 int nr_dirs = 0;
1394 int err = -ENOMEM;
1395
1396 for (entry = table; entry->procname; entry++) {
1397 if (entry->child)
1398 nr_dirs++;
1399 else
1400 nr_files++;
1401 }
1402
1403 files = table;
1404 /* If there are mixed files and directories we need a new table */
1405 if (nr_dirs && nr_files) {
1406 struct ctl_table *new;
1407 files = kzalloc(sizeof(struct ctl_table) * (nr_files + 1),
1408 GFP_KERNEL);
1409 if (!files)
1410 goto out;
1411
1412 ctl_table_arg = files;
1413 for (new = files, entry = table; entry->procname; entry++) {
1414 if (entry->child)
1415 continue;
1416 *new = *entry;
1417 new++;
1418 }
1419 }
1420
1421 /* Register everything except a directory full of subdirectories */
1422 if (nr_files || !nr_dirs) {
1423 struct ctl_table_header *header;
1424 header = __register_sysctl_table(set, path, files);
1425 if (!header) {
1426 kfree(ctl_table_arg);
1427 goto out;
1428 }
1429
1430 /* Remember if we need to free the file table */
1431 header->ctl_table_arg = ctl_table_arg;
1432 **subheader = header;
1433 (*subheader)++;
1434 }
1435
1436 /* Recurse into the subdirectories. */
1437 for (entry = table; entry->procname; entry++) {
1438 char *child_pos;
1439
1440 if (!entry->child)
1441 continue;
1442
1443 err = -ENAMETOOLONG;
1444 child_pos = append_path(path, pos, entry->procname);
1445 if (!child_pos)
1446 goto out;
1447
1448 err = register_leaf_sysctl_tables(path, child_pos, subheader,
1449 set, entry->child);
1450 pos[0] = '\0';
1451 if (err)
1452 goto out;
1453 }
1454 err = 0;
1455 out:
1456 /* On failure our caller will unregister all registered subheaders */
1457 return err;
1458 }
1459
1460 /**
1461 * __register_sysctl_paths - register a sysctl table hierarchy
1462 * @set: Sysctl tree to register on
1463 * @path: The path to the directory the sysctl table is in.
1464 * @table: the top-level table structure
1465 *
1466 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1467 * array. A completely 0 filled entry terminates the table.
1468 *
1469 * See __register_sysctl_table for more details.
1470 */
1471 struct ctl_table_header *__register_sysctl_paths(
1472 struct ctl_table_set *set,
1473 const struct ctl_path *path, struct ctl_table *table)
1474 {
1475 struct ctl_table *ctl_table_arg = table;
1476 int nr_subheaders = count_subheaders(table);
1477 struct ctl_table_header *header = NULL, **subheaders, **subheader;
1478 const struct ctl_path *component;
1479 char *new_path, *pos;
1480
1481 pos = new_path = kmalloc(PATH_MAX, GFP_KERNEL);
1482 if (!new_path)
1483 return NULL;
1484
1485 pos[0] = '\0';
1486 for (component = path; component->procname; component++) {
1487 pos = append_path(new_path, pos, component->procname);
1488 if (!pos)
1489 goto out;
1490 }
1491 while (table->procname && table->child && !table[1].procname) {
1492 pos = append_path(new_path, pos, table->procname);
1493 if (!pos)
1494 goto out;
1495 table = table->child;
1496 }
1497 if (nr_subheaders == 1) {
1498 header = __register_sysctl_table(set, new_path, table);
1499 if (header)
1500 header->ctl_table_arg = ctl_table_arg;
1501 } else {
1502 header = kzalloc(sizeof(*header) +
1503 sizeof(*subheaders)*nr_subheaders, GFP_KERNEL);
1504 if (!header)
1505 goto out;
1506
1507 subheaders = (struct ctl_table_header **) (header + 1);
1508 subheader = subheaders;
1509 header->ctl_table_arg = ctl_table_arg;
1510
1511 if (register_leaf_sysctl_tables(new_path, pos, &subheader,
1512 set, table))
1513 goto err_register_leaves;
1514 }
1515
1516 out:
1517 kfree(new_path);
1518 return header;
1519
1520 err_register_leaves:
1521 while (subheader > subheaders) {
1522 struct ctl_table_header *subh = *(--subheader);
1523 struct ctl_table *table = subh->ctl_table_arg;
1524 unregister_sysctl_table(subh);
1525 kfree(table);
1526 }
1527 kfree(header);
1528 header = NULL;
1529 goto out;
1530 }
1531
1532 /**
1533 * register_sysctl_table_path - register a sysctl table hierarchy
1534 * @path: The path to the directory the sysctl table is in.
1535 * @table: the top-level table structure
1536 *
1537 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1538 * array. A completely 0 filled entry terminates the table.
1539 *
1540 * See __register_sysctl_paths for more details.
1541 */
1542 struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
1543 struct ctl_table *table)
1544 {
1545 return __register_sysctl_paths(&sysctl_table_root.default_set,
1546 path, table);
1547 }
1548 EXPORT_SYMBOL(register_sysctl_paths);
1549
1550 /**
1551 * register_sysctl_table - register a sysctl table hierarchy
1552 * @table: the top-level table structure
1553 *
1554 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1555 * array. A completely 0 filled entry terminates the table.
1556 *
1557 * See register_sysctl_paths for more details.
1558 */
1559 struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
1560 {
1561 static const struct ctl_path null_path[] = { {} };
1562
1563 return register_sysctl_paths(null_path, table);
1564 }
1565 EXPORT_SYMBOL(register_sysctl_table);
1566
1567 static void put_links(struct ctl_table_header *header)
1568 {
1569 struct ctl_table_set *root_set = &sysctl_table_root.default_set;
1570 struct ctl_table_root *root = header->root;
1571 struct ctl_dir *parent = header->parent;
1572 struct ctl_dir *core_parent;
1573 struct ctl_table *entry;
1574
1575 if (header->set == root_set)
1576 return;
1577
1578 core_parent = xlate_dir(root_set, parent);
1579 if (IS_ERR(core_parent))
1580 return;
1581
1582 for (entry = header->ctl_table; entry->procname; entry++) {
1583 struct ctl_table_header *link_head;
1584 struct ctl_table *link;
1585 const char *name = entry->procname;
1586
1587 link = find_entry(&link_head, core_parent, name, strlen(name));
1588 if (link &&
1589 ((S_ISDIR(link->mode) && S_ISDIR(entry->mode)) ||
1590 (S_ISLNK(link->mode) && (link->data == root)))) {
1591 drop_sysctl_table(link_head);
1592 }
1593 else {
1594 pr_err("sysctl link missing during unregister: ");
1595 sysctl_print_dir(parent);
1596 pr_cont("/%s\n", name);
1597 }
1598 }
1599 }
1600
1601 static void drop_sysctl_table(struct ctl_table_header *header)
1602 {
1603 struct ctl_dir *parent = header->parent;
1604
1605 if (--header->nreg)
1606 return;
1607
1608 put_links(header);
1609 start_unregistering(header);
1610 if (!--header->count)
1611 kfree_rcu(header, rcu);
1612
1613 if (parent)
1614 drop_sysctl_table(&parent->header);
1615 }
1616
1617 /**
1618 * unregister_sysctl_table - unregister a sysctl table hierarchy
1619 * @header: the header returned from register_sysctl_table
1620 *
1621 * Unregisters the sysctl table and all children. proc entries may not
1622 * actually be removed until they are no longer used by anyone.
1623 */
1624 void unregister_sysctl_table(struct ctl_table_header * header)
1625 {
1626 int nr_subheaders;
1627 might_sleep();
1628
1629 if (header == NULL)
1630 return;
1631
1632 nr_subheaders = count_subheaders(header->ctl_table_arg);
1633 if (unlikely(nr_subheaders > 1)) {
1634 struct ctl_table_header **subheaders;
1635 int i;
1636
1637 subheaders = (struct ctl_table_header **)(header + 1);
1638 for (i = nr_subheaders -1; i >= 0; i--) {
1639 struct ctl_table_header *subh = subheaders[i];
1640 struct ctl_table *table = subh->ctl_table_arg;
1641 unregister_sysctl_table(subh);
1642 kfree(table);
1643 }
1644 kfree(header);
1645 return;
1646 }
1647
1648 spin_lock(&sysctl_lock);
1649 drop_sysctl_table(header);
1650 spin_unlock(&sysctl_lock);
1651 }
1652 EXPORT_SYMBOL(unregister_sysctl_table);
1653
1654 void setup_sysctl_set(struct ctl_table_set *set,
1655 struct ctl_table_root *root,
1656 int (*is_seen)(struct ctl_table_set *))
1657 {
1658 memset(set, 0, sizeof(*set));
1659 set->is_seen = is_seen;
1660 init_header(&set->dir.header, root, set, NULL, root_table);
1661 }
1662
1663 void retire_sysctl_set(struct ctl_table_set *set)
1664 {
1665 WARN_ON(!RB_EMPTY_ROOT(&set->dir.root));
1666 }
1667
1668 int __init proc_sys_init(void)
1669 {
1670 struct proc_dir_entry *proc_sys_root;
1671
1672 proc_sys_root = proc_mkdir("sys", NULL);
1673 proc_sys_root->proc_iops = &proc_sys_dir_operations;
1674 proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
1675 proc_sys_root->nlink = 0;
1676
1677 return sysctl_init();
1678 }
Linux with added FPC-III support