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