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

source code of linux/fs/proc/proc_sysctl.c