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