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