4 #include <linux/init.h>
5 #include <linux/sysctl.h>
6 #include <linux/poll.h>
7 #include <linux/proc_fs.h>
8 #include <linux/security.h>
9 #include <linux/namei.h>
10 #include <linux/module.h>
13 static const struct dentry_operations proc_sys_dentry_operations
;
14 static const struct file_operations proc_sys_file_operations
;
15 static const struct inode_operations proc_sys_inode_operations
;
16 static const struct file_operations proc_sys_dir_file_operations
;
17 static const struct inode_operations proc_sys_dir_operations
;
19 void proc_sys_poll_notify(struct ctl_table_poll
*poll
)
24 atomic_inc(&poll
->event
);
25 wake_up_interruptible(&poll
->wait
);
28 static struct ctl_table root_table
[1];
29 static struct ctl_table_root sysctl_table_root
;
30 static struct ctl_table_header root_table_header
= {
32 .ctl_table
= root_table
,
33 .ctl_entry
= LIST_HEAD_INIT(sysctl_table_root
.default_set
.list
),}},
34 .root
= &sysctl_table_root
,
35 .set
= &sysctl_table_root
.default_set
,
37 static struct ctl_table_root sysctl_table_root
= {
38 .root_list
= LIST_HEAD_INIT(sysctl_table_root
.root_list
),
39 .default_set
.list
= LIST_HEAD_INIT(root_table_header
.ctl_entry
),
42 static DEFINE_SPINLOCK(sysctl_lock
);
44 /* called under sysctl_lock */
45 static int use_table(struct ctl_table_header
*p
)
47 if (unlikely(p
->unregistering
))
53 /* called under sysctl_lock */
54 static void unuse_table(struct ctl_table_header
*p
)
57 if (unlikely(p
->unregistering
))
58 complete(p
->unregistering
);
61 /* called under sysctl_lock, will reacquire if has to wait */
62 static void start_unregistering(struct ctl_table_header
*p
)
65 * if p->used is 0, nobody will ever touch that entry again;
66 * we'll eliminate all paths to it before dropping sysctl_lock
68 if (unlikely(p
->used
)) {
69 struct completion wait
;
70 init_completion(&wait
);
71 p
->unregistering
= &wait
;
72 spin_unlock(&sysctl_lock
);
73 wait_for_completion(&wait
);
74 spin_lock(&sysctl_lock
);
76 /* anything non-NULL; we'll never dereference it */
77 p
->unregistering
= ERR_PTR(-EINVAL
);
80 * do not remove from the list until nobody holds it; walking the
81 * list in do_sysctl() relies on that.
83 list_del_init(&p
->ctl_entry
);
86 static void sysctl_head_get(struct ctl_table_header
*head
)
88 spin_lock(&sysctl_lock
);
90 spin_unlock(&sysctl_lock
);
93 void sysctl_head_put(struct ctl_table_header
*head
)
95 spin_lock(&sysctl_lock
);
98 spin_unlock(&sysctl_lock
);
101 static struct ctl_table_header
*sysctl_head_grab(struct ctl_table_header
*head
)
105 spin_lock(&sysctl_lock
);
106 if (!use_table(head
))
107 head
= ERR_PTR(-ENOENT
);
108 spin_unlock(&sysctl_lock
);
112 static void sysctl_head_finish(struct ctl_table_header
*head
)
116 spin_lock(&sysctl_lock
);
118 spin_unlock(&sysctl_lock
);
121 static struct ctl_table_set
*
122 lookup_header_set(struct ctl_table_root
*root
, struct nsproxy
*namespaces
)
124 struct ctl_table_set
*set
= &root
->default_set
;
126 set
= root
->lookup(root
, namespaces
);
130 static struct list_head
*
131 lookup_header_list(struct ctl_table_root
*root
, struct nsproxy
*namespaces
)
133 struct ctl_table_set
*set
= lookup_header_set(root
, namespaces
);
137 static struct ctl_table_header
*__sysctl_head_next(struct nsproxy
*namespaces
,
138 struct ctl_table_header
*prev
)
140 struct ctl_table_root
*root
;
141 struct list_head
*header_list
;
142 struct ctl_table_header
*head
;
143 struct list_head
*tmp
;
145 spin_lock(&sysctl_lock
);
148 tmp
= &prev
->ctl_entry
;
152 tmp
= &root_table_header
.ctl_entry
;
154 head
= list_entry(tmp
, struct ctl_table_header
, ctl_entry
);
156 if (!use_table(head
))
158 spin_unlock(&sysctl_lock
);
163 header_list
= lookup_header_list(root
, namespaces
);
164 if (tmp
!= header_list
)
168 root
= list_entry(root
->root_list
.next
,
169 struct ctl_table_root
, root_list
);
170 if (root
== &sysctl_table_root
)
172 header_list
= lookup_header_list(root
, namespaces
);
173 } while (list_empty(header_list
));
174 tmp
= header_list
->next
;
177 spin_unlock(&sysctl_lock
);
181 static struct ctl_table_header
*sysctl_head_next(struct ctl_table_header
*prev
)
183 return __sysctl_head_next(current
->nsproxy
, prev
);
186 void register_sysctl_root(struct ctl_table_root
*root
)
188 spin_lock(&sysctl_lock
);
189 list_add_tail(&root
->root_list
, &sysctl_table_root
.root_list
);
190 spin_unlock(&sysctl_lock
);
194 * sysctl_perm does NOT grant the superuser all rights automatically, because
195 * some sysctl variables are readonly even to root.
198 static int test_perm(int mode
, int op
)
202 else if (in_egroup_p(0))
204 if ((op
& ~mode
& (MAY_READ
|MAY_WRITE
|MAY_EXEC
)) == 0)
209 static int sysctl_perm(struct ctl_table_root
*root
, struct ctl_table
*table
, int op
)
213 if (root
->permissions
)
214 mode
= root
->permissions(root
, current
->nsproxy
, table
);
218 return test_perm(mode
, op
);
221 static void sysctl_set_parent(struct ctl_table
*parent
, struct ctl_table
*table
)
223 for (; table
->procname
; table
++) {
224 table
->parent
= parent
;
226 sysctl_set_parent(table
, table
->child
);
231 static struct inode
*proc_sys_make_inode(struct super_block
*sb
,
232 struct ctl_table_header
*head
, struct ctl_table
*table
)
235 struct proc_inode
*ei
;
237 inode
= new_inode(sb
);
241 inode
->i_ino
= get_next_ino();
243 sysctl_head_get(head
);
246 ei
->sysctl_entry
= table
;
248 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
249 inode
->i_mode
= table
->mode
;
251 inode
->i_mode
|= S_IFREG
;
252 inode
->i_op
= &proc_sys_inode_operations
;
253 inode
->i_fop
= &proc_sys_file_operations
;
255 inode
->i_mode
|= S_IFDIR
;
256 inode
->i_op
= &proc_sys_dir_operations
;
257 inode
->i_fop
= &proc_sys_dir_file_operations
;
263 static struct ctl_table
*find_in_table(struct ctl_table
*p
, struct qstr
*name
)
265 for ( ; p
->procname
; p
++) {
266 if (strlen(p
->procname
) != name
->len
)
269 if (memcmp(p
->procname
, name
->name
, name
->len
) != 0)
278 static struct ctl_table_header
*grab_header(struct inode
*inode
)
280 if (PROC_I(inode
)->sysctl
)
281 return sysctl_head_grab(PROC_I(inode
)->sysctl
);
283 return sysctl_head_next(NULL
);
286 static struct dentry
*proc_sys_lookup(struct inode
*dir
, struct dentry
*dentry
,
287 struct nameidata
*nd
)
289 struct ctl_table_header
*head
= grab_header(dir
);
290 struct ctl_table
*table
= PROC_I(dir
)->sysctl_entry
;
291 struct ctl_table_header
*h
= NULL
;
292 struct qstr
*name
= &dentry
->d_name
;
295 struct dentry
*err
= ERR_PTR(-ENOENT
);
298 return ERR_CAST(head
);
300 if (table
&& !table
->child
) {
305 table
= table
? table
->child
: head
->ctl_table
;
307 p
= find_in_table(table
, name
);
309 for (h
= sysctl_head_next(NULL
); h
; h
= sysctl_head_next(h
)) {
310 if (h
->attached_to
!= table
)
312 p
= find_in_table(h
->attached_by
, name
);
321 err
= ERR_PTR(-ENOMEM
);
322 inode
= proc_sys_make_inode(dir
->i_sb
, h
? h
: head
, p
);
324 sysctl_head_finish(h
);
330 d_set_d_op(dentry
, &proc_sys_dentry_operations
);
331 d_add(dentry
, inode
);
334 sysctl_head_finish(head
);
338 static ssize_t
proc_sys_call_handler(struct file
*filp
, void __user
*buf
,
339 size_t count
, loff_t
*ppos
, int write
)
341 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
342 struct ctl_table_header
*head
= grab_header(inode
);
343 struct ctl_table
*table
= PROC_I(inode
)->sysctl_entry
;
348 return PTR_ERR(head
);
351 * At this point we know that the sysctl was not unregistered
352 * and won't be until we finish.
355 if (sysctl_perm(head
->root
, table
, write
? MAY_WRITE
: MAY_READ
))
358 /* if that can happen at all, it should be -EINVAL, not -EISDIR */
360 if (!table
->proc_handler
)
363 /* careful: calling conventions are nasty here */
365 error
= table
->proc_handler(table
, write
, buf
, &res
, ppos
);
369 sysctl_head_finish(head
);
374 static ssize_t
proc_sys_read(struct file
*filp
, char __user
*buf
,
375 size_t count
, loff_t
*ppos
)
377 return proc_sys_call_handler(filp
, (void __user
*)buf
, count
, ppos
, 0);
380 static ssize_t
proc_sys_write(struct file
*filp
, const char __user
*buf
,
381 size_t count
, loff_t
*ppos
)
383 return proc_sys_call_handler(filp
, (void __user
*)buf
, count
, ppos
, 1);
386 static int proc_sys_open(struct inode
*inode
, struct file
*filp
)
388 struct ctl_table
*table
= PROC_I(inode
)->sysctl_entry
;
391 filp
->private_data
= proc_sys_poll_event(table
->poll
);
396 static unsigned int proc_sys_poll(struct file
*filp
, poll_table
*wait
)
398 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
399 struct ctl_table
*table
= PROC_I(inode
)->sysctl_entry
;
400 unsigned long event
= (unsigned long)filp
->private_data
;
401 unsigned int ret
= DEFAULT_POLLMASK
;
403 if (!table
->proc_handler
)
409 poll_wait(filp
, &table
->poll
->wait
, wait
);
411 if (event
!= atomic_read(&table
->poll
->event
)) {
412 filp
->private_data
= proc_sys_poll_event(table
->poll
);
413 ret
= POLLIN
| POLLRDNORM
| POLLERR
| POLLPRI
;
420 static int proc_sys_fill_cache(struct file
*filp
, void *dirent
,
422 struct ctl_table_header
*head
,
423 struct ctl_table
*table
)
425 struct dentry
*child
, *dir
= filp
->f_path
.dentry
;
429 unsigned type
= DT_UNKNOWN
;
431 qname
.name
= table
->procname
;
432 qname
.len
= strlen(table
->procname
);
433 qname
.hash
= full_name_hash(qname
.name
, qname
.len
);
435 child
= d_lookup(dir
, &qname
);
437 child
= d_alloc(dir
, &qname
);
439 inode
= proc_sys_make_inode(dir
->d_sb
, head
, table
);
444 d_set_d_op(child
, &proc_sys_dentry_operations
);
451 inode
= child
->d_inode
;
453 type
= inode
->i_mode
>> 12;
455 return !!filldir(dirent
, qname
.name
, qname
.len
, filp
->f_pos
, ino
, type
);
458 static int scan(struct ctl_table_header
*head
, ctl_table
*table
,
459 unsigned long *pos
, struct file
*file
,
460 void *dirent
, filldir_t filldir
)
463 for (; table
->procname
; table
++, (*pos
)++) {
466 if (*pos
< file
->f_pos
)
469 res
= proc_sys_fill_cache(file
, dirent
, filldir
, head
, table
);
473 file
->f_pos
= *pos
+ 1;
478 static int proc_sys_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
480 struct dentry
*dentry
= filp
->f_path
.dentry
;
481 struct inode
*inode
= dentry
->d_inode
;
482 struct ctl_table_header
*head
= grab_header(inode
);
483 struct ctl_table
*table
= PROC_I(inode
)->sysctl_entry
;
484 struct ctl_table_header
*h
= NULL
;
489 return PTR_ERR(head
);
491 if (table
&& !table
->child
) {
496 table
= table
? table
->child
: head
->ctl_table
;
499 /* Avoid a switch here: arm builds fail with missing __cmpdi2 */
500 if (filp
->f_pos
== 0) {
501 if (filldir(dirent
, ".", 1, filp
->f_pos
,
502 inode
->i_ino
, DT_DIR
) < 0)
506 if (filp
->f_pos
== 1) {
507 if (filldir(dirent
, "..", 2, filp
->f_pos
,
508 parent_ino(dentry
), DT_DIR
) < 0)
514 ret
= scan(head
, table
, &pos
, filp
, dirent
, filldir
);
518 for (h
= sysctl_head_next(NULL
); h
; h
= sysctl_head_next(h
)) {
519 if (h
->attached_to
!= table
)
521 ret
= scan(h
, h
->attached_by
, &pos
, filp
, dirent
, filldir
);
523 sysctl_head_finish(h
);
529 sysctl_head_finish(head
);
533 static int proc_sys_permission(struct inode
*inode
, int mask
)
536 * sysctl entries that are not writeable,
537 * are _NOT_ writeable, capabilities or not.
539 struct ctl_table_header
*head
;
540 struct ctl_table
*table
;
543 /* Executable files are not allowed under /proc/sys/ */
544 if ((mask
& MAY_EXEC
) && S_ISREG(inode
->i_mode
))
547 head
= grab_header(inode
);
549 return PTR_ERR(head
);
551 table
= PROC_I(inode
)->sysctl_entry
;
552 if (!table
) /* global root - r-xr-xr-x */
553 error
= mask
& MAY_WRITE
? -EACCES
: 0;
554 else /* Use the permissions on the sysctl table entry */
555 error
= sysctl_perm(head
->root
, table
, mask
& ~MAY_NOT_BLOCK
);
557 sysctl_head_finish(head
);
561 static int proc_sys_setattr(struct dentry
*dentry
, struct iattr
*attr
)
563 struct inode
*inode
= dentry
->d_inode
;
566 if (attr
->ia_valid
& (ATTR_MODE
| ATTR_UID
| ATTR_GID
))
569 error
= inode_change_ok(inode
, attr
);
573 if ((attr
->ia_valid
& ATTR_SIZE
) &&
574 attr
->ia_size
!= i_size_read(inode
)) {
575 error
= vmtruncate(inode
, attr
->ia_size
);
580 setattr_copy(inode
, attr
);
581 mark_inode_dirty(inode
);
585 static int proc_sys_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
587 struct inode
*inode
= dentry
->d_inode
;
588 struct ctl_table_header
*head
= grab_header(inode
);
589 struct ctl_table
*table
= PROC_I(inode
)->sysctl_entry
;
592 return PTR_ERR(head
);
594 generic_fillattr(inode
, stat
);
596 stat
->mode
= (stat
->mode
& S_IFMT
) | table
->mode
;
598 sysctl_head_finish(head
);
602 static const struct file_operations proc_sys_file_operations
= {
603 .open
= proc_sys_open
,
604 .poll
= proc_sys_poll
,
605 .read
= proc_sys_read
,
606 .write
= proc_sys_write
,
607 .llseek
= default_llseek
,
610 static const struct file_operations proc_sys_dir_file_operations
= {
611 .read
= generic_read_dir
,
612 .readdir
= proc_sys_readdir
,
613 .llseek
= generic_file_llseek
,
616 static const struct inode_operations proc_sys_inode_operations
= {
617 .permission
= proc_sys_permission
,
618 .setattr
= proc_sys_setattr
,
619 .getattr
= proc_sys_getattr
,
622 static const struct inode_operations proc_sys_dir_operations
= {
623 .lookup
= proc_sys_lookup
,
624 .permission
= proc_sys_permission
,
625 .setattr
= proc_sys_setattr
,
626 .getattr
= proc_sys_getattr
,
629 static int proc_sys_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
631 if (nd
->flags
& LOOKUP_RCU
)
633 return !PROC_I(dentry
->d_inode
)->sysctl
->unregistering
;
636 static int proc_sys_delete(const struct dentry
*dentry
)
638 return !!PROC_I(dentry
->d_inode
)->sysctl
->unregistering
;
641 static int sysctl_is_seen(struct ctl_table_header
*p
)
643 struct ctl_table_set
*set
= p
->set
;
645 spin_lock(&sysctl_lock
);
646 if (p
->unregistering
)
648 else if (!set
->is_seen
)
651 res
= set
->is_seen(set
);
652 spin_unlock(&sysctl_lock
);
656 static int proc_sys_compare(const struct dentry
*parent
,
657 const struct inode
*pinode
,
658 const struct dentry
*dentry
, const struct inode
*inode
,
659 unsigned int len
, const char *str
, const struct qstr
*name
)
661 struct ctl_table_header
*head
;
662 /* Although proc doesn't have negative dentries, rcu-walk means
663 * that inode here can be NULL */
664 /* AV: can it, indeed? */
667 if (name
->len
!= len
)
669 if (memcmp(name
->name
, str
, len
))
671 head
= rcu_dereference(PROC_I(inode
)->sysctl
);
672 return !head
|| !sysctl_is_seen(head
);
675 static const struct dentry_operations proc_sys_dentry_operations
= {
676 .d_revalidate
= proc_sys_revalidate
,
677 .d_delete
= proc_sys_delete
,
678 .d_compare
= proc_sys_compare
,
681 static struct ctl_table
*is_branch_in(struct ctl_table
*branch
,
682 struct ctl_table
*table
)
685 const char *s
= branch
->procname
;
687 /* branch should have named subdirectory as its first element */
688 if (!s
|| !branch
->child
)
691 /* ... and nothing else */
692 if (branch
[1].procname
)
695 /* table should contain subdirectory with the same name */
696 for (p
= table
; p
->procname
; p
++) {
699 if (p
->procname
&& strcmp(p
->procname
, s
) == 0)
705 /* see if attaching q to p would be an improvement */
706 static void try_attach(struct ctl_table_header
*p
, struct ctl_table_header
*q
)
708 struct ctl_table
*to
= p
->ctl_table
, *by
= q
->ctl_table
;
709 struct ctl_table
*next
;
711 int not_in_parent
= !p
->attached_by
;
713 while ((next
= is_branch_in(by
, to
)) != NULL
) {
714 if (by
== q
->attached_by
)
716 if (to
== p
->attached_by
)
722 if (is_better
&& not_in_parent
) {
729 #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
730 static int sysctl_depth(struct ctl_table
*table
)
732 struct ctl_table
*tmp
;
736 for (tmp
= table
; tmp
->parent
; tmp
= tmp
->parent
)
742 static struct ctl_table
*sysctl_parent(struct ctl_table
*table
, int n
)
746 for (i
= 0; table
&& i
< n
; i
++)
747 table
= table
->parent
;
753 static void sysctl_print_path(struct ctl_table
*table
)
755 struct ctl_table
*tmp
;
757 depth
= sysctl_depth(table
);
758 if (table
->procname
) {
759 for (i
= depth
; i
>= 0; i
--) {
760 tmp
= sysctl_parent(table
, i
);
761 printk("/%s", tmp
->procname
?tmp
->procname
:"");
767 static struct ctl_table
*sysctl_check_lookup(struct nsproxy
*namespaces
,
768 struct ctl_table
*table
)
770 struct ctl_table_header
*head
;
771 struct ctl_table
*ref
, *test
;
772 int depth
, cur_depth
;
774 depth
= sysctl_depth(table
);
776 for (head
= __sysctl_head_next(namespaces
, NULL
); head
;
777 head
= __sysctl_head_next(namespaces
, head
)) {
779 ref
= head
->ctl_table
;
781 test
= sysctl_parent(table
, cur_depth
);
782 for (; ref
->procname
; ref
++) {
784 if (cur_depth
&& !ref
->child
)
787 if (test
->procname
&& ref
->procname
&&
788 (strcmp(test
->procname
, ref
->procname
) == 0))
792 if (cur_depth
!= 0) {
803 sysctl_head_finish(head
);
807 static void set_fail(const char **fail
, struct ctl_table
*table
, const char *str
)
810 printk(KERN_ERR
"sysctl table check failed: ");
811 sysctl_print_path(table
);
812 printk(" %s\n", *fail
);
818 static void sysctl_check_leaf(struct nsproxy
*namespaces
,
819 struct ctl_table
*table
, const char **fail
)
821 struct ctl_table
*ref
;
823 ref
= sysctl_check_lookup(namespaces
, table
);
824 if (ref
&& (ref
!= table
))
825 set_fail(fail
, table
, "Sysctl already exists");
828 static int sysctl_check_table(struct nsproxy
*namespaces
, struct ctl_table
*table
)
831 for (; table
->procname
; table
++) {
832 const char *fail
= NULL
;
835 if (!table
->parent
->procname
)
836 set_fail(&fail
, table
, "Parent without procname");
840 set_fail(&fail
, table
, "Directory with data?");
842 set_fail(&fail
, table
, "Directory with maxlen?");
843 if ((table
->mode
& (S_IRUGO
|S_IXUGO
)) != table
->mode
)
844 set_fail(&fail
, table
, "Writable sysctl directory");
845 if (table
->proc_handler
)
846 set_fail(&fail
, table
, "Directory with proc_handler");
848 set_fail(&fail
, table
, "Directory with extra1");
850 set_fail(&fail
, table
, "Directory with extra2");
852 if ((table
->proc_handler
== proc_dostring
) ||
853 (table
->proc_handler
== proc_dointvec
) ||
854 (table
->proc_handler
== proc_dointvec_minmax
) ||
855 (table
->proc_handler
== proc_dointvec_jiffies
) ||
856 (table
->proc_handler
== proc_dointvec_userhz_jiffies
) ||
857 (table
->proc_handler
== proc_dointvec_ms_jiffies
) ||
858 (table
->proc_handler
== proc_doulongvec_minmax
) ||
859 (table
->proc_handler
== proc_doulongvec_ms_jiffies_minmax
)) {
861 set_fail(&fail
, table
, "No data");
863 set_fail(&fail
, table
, "No maxlen");
865 #ifdef CONFIG_PROC_SYSCTL
866 if (!table
->proc_handler
)
867 set_fail(&fail
, table
, "No proc_handler");
869 sysctl_check_leaf(namespaces
, table
, &fail
);
871 if (table
->mode
> 0777)
872 set_fail(&fail
, table
, "bogus .mode");
874 set_fail(&fail
, table
, NULL
);
878 error
|= sysctl_check_table(namespaces
, table
->child
);
882 #endif /* CONFIG_SYSCTL_SYSCALL_CHECK */
885 * __register_sysctl_paths - register a sysctl hierarchy
886 * @root: List of sysctl headers to register on
887 * @namespaces: Data to compute which lists of sysctl entries are visible
888 * @path: The path to the directory the sysctl table is in.
889 * @table: the top-level table structure
891 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
892 * array. A completely 0 filled entry terminates the table.
894 * The members of the &struct ctl_table structure are used as follows:
896 * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
897 * enter a sysctl file
899 * data - a pointer to data for use by proc_handler
901 * maxlen - the maximum size in bytes of the data
903 * mode - the file permissions for the /proc/sys file, and for sysctl(2)
905 * child - a pointer to the child sysctl table if this entry is a directory, or
908 * proc_handler - the text handler routine (described below)
910 * de - for internal use by the sysctl routines
912 * extra1, extra2 - extra pointers usable by the proc handler routines
914 * Leaf nodes in the sysctl tree will be represented by a single file
915 * under /proc; non-leaf nodes will be represented by directories.
917 * sysctl(2) can automatically manage read and write requests through
918 * the sysctl table. The data and maxlen fields of the ctl_table
919 * struct enable minimal validation of the values being written to be
920 * performed, and the mode field allows minimal authentication.
922 * There must be a proc_handler routine for any terminal nodes
923 * mirrored under /proc/sys (non-terminals are handled by a built-in
924 * directory handler). Several default handlers are available to
925 * cover common cases -
927 * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
928 * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
929 * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
931 * It is the handler's job to read the input buffer from user memory
932 * and process it. The handler should return 0 on success.
934 * This routine returns %NULL on a failure to register, and a pointer
935 * to the table header on success.
937 struct ctl_table_header
*__register_sysctl_paths(
938 struct ctl_table_root
*root
,
939 struct nsproxy
*namespaces
,
940 const struct ctl_path
*path
, struct ctl_table
*table
)
942 struct ctl_table_header
*header
;
943 struct ctl_table
*new, **prevp
;
944 unsigned int n
, npath
;
945 struct ctl_table_set
*set
;
946 size_t path_bytes
= 0;
949 /* Count the path components */
950 for (npath
= 0; path
[npath
].procname
; ++npath
)
951 path_bytes
+= strlen(path
[npath
].procname
) + 1;
954 * For each path component, allocate a 2-element ctl_table array.
955 * The first array element will be filled with the sysctl entry
956 * for this, the second will be the sentinel (procname == 0).
958 * We allocate everything in one go so that we don't have to
959 * worry about freeing additional memory in unregister_sysctl_table.
961 header
= kzalloc(sizeof(struct ctl_table_header
) + path_bytes
+
962 (2 * npath
* sizeof(struct ctl_table
)), GFP_KERNEL
);
966 new = (struct ctl_table
*) (header
+ 1);
967 new_name
= (char *)(new + (2 * npath
));
969 /* Now connect the dots */
970 prevp
= &header
->ctl_table
;
971 for (n
= 0; n
< npath
; ++n
, ++path
) {
972 /* Copy the procname */
973 strcpy(new_name
, path
->procname
);
974 new->procname
= new_name
;
981 new_name
+= strlen(new_name
) + 1;
984 header
->ctl_table_arg
= table
;
986 INIT_LIST_HEAD(&header
->ctl_entry
);
988 header
->unregistering
= NULL
;
990 sysctl_set_parent(NULL
, header
->ctl_table
);
992 #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
993 if (sysctl_check_table(namespaces
, header
->ctl_table
)) {
998 spin_lock(&sysctl_lock
);
999 header
->set
= lookup_header_set(root
, namespaces
);
1000 header
->attached_by
= header
->ctl_table
;
1001 header
->attached_to
= root_table
;
1002 header
->parent
= &root_table_header
;
1004 root
= header
->root
;
1006 struct ctl_table_header
*p
;
1007 list_for_each_entry(p
, &set
->list
, ctl_entry
) {
1008 if (p
->unregistering
)
1010 try_attach(p
, header
);
1012 if (root
== &sysctl_table_root
)
1014 root
= list_entry(root
->root_list
.prev
,
1015 struct ctl_table_root
, root_list
);
1016 set
= lookup_header_set(root
, namespaces
);
1018 header
->parent
->count
++;
1019 list_add_tail(&header
->ctl_entry
, &header
->set
->list
);
1020 spin_unlock(&sysctl_lock
);
1026 * register_sysctl_table_path - register a sysctl table hierarchy
1027 * @path: The path to the directory the sysctl table is in.
1028 * @table: the top-level table structure
1030 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1031 * array. A completely 0 filled entry terminates the table.
1033 * See __register_sysctl_paths for more details.
1035 struct ctl_table_header
*register_sysctl_paths(const struct ctl_path
*path
,
1036 struct ctl_table
*table
)
1038 return __register_sysctl_paths(&sysctl_table_root
, current
->nsproxy
,
1041 EXPORT_SYMBOL(register_sysctl_paths
);
1044 * register_sysctl_table - register a sysctl table hierarchy
1045 * @table: the top-level table structure
1047 * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1048 * array. A completely 0 filled entry terminates the table.
1050 * See register_sysctl_paths for more details.
1052 struct ctl_table_header
*register_sysctl_table(struct ctl_table
*table
)
1054 static const struct ctl_path null_path
[] = { {} };
1056 return register_sysctl_paths(null_path
, table
);
1058 EXPORT_SYMBOL(register_sysctl_table
);
1061 * unregister_sysctl_table - unregister a sysctl table hierarchy
1062 * @header: the header returned from register_sysctl_table
1064 * Unregisters the sysctl table and all children. proc entries may not
1065 * actually be removed until they are no longer used by anyone.
1067 void unregister_sysctl_table(struct ctl_table_header
* header
)
1074 spin_lock(&sysctl_lock
);
1075 start_unregistering(header
);
1076 if (!--header
->parent
->count
) {
1078 kfree_rcu(header
->parent
, rcu
);
1080 if (!--header
->count
)
1081 kfree_rcu(header
, rcu
);
1082 spin_unlock(&sysctl_lock
);
1084 EXPORT_SYMBOL(unregister_sysctl_table
);
1086 void setup_sysctl_set(struct ctl_table_set
*p
,
1087 int (*is_seen
)(struct ctl_table_set
*))
1089 INIT_LIST_HEAD(&p
->list
);
1090 p
->is_seen
= is_seen
;
1093 void retire_sysctl_set(struct ctl_table_set
*set
)
1095 WARN_ON(!list_empty(&set
->list
));
1098 int __init
proc_sys_init(void)
1100 struct proc_dir_entry
*proc_sys_root
;
1102 proc_sys_root
= proc_mkdir("sys", NULL
);
1103 proc_sys_root
->proc_iops
= &proc_sys_dir_operations
;
1104 proc_sys_root
->proc_fops
= &proc_sys_dir_file_operations
;
1105 proc_sys_root
->nlink
= 0;
1107 return sysctl_init();