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