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