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