fs/proc/proc_sysctl.c

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