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