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