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