fs/proc/generic.c

   1 /*
   2  * proc/fs/generic.c --- generic routines for the proc-fs
   3  *
   4  * This file contains generic proc-fs routines for handling
   5  * directories and files.
   6  *
   7  * Copyright (C) 1991, 1992 Linus Torvalds.
   8  * Copyright (C) 1997 Theodore Ts'o
   9  */
  10
  11 #include <linux/errno.h>
  12 #include <linux/time.h>
  13 #include <linux/proc_fs.h>
  14 #include <linux/stat.h>
  15 #include <linux/mm.h>
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/printk.h>
  19 #include <linux/mount.h>
  20 #include <linux/init.h>
  21 #include <linux/idr.h>
  22 #include <linux/bitops.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/completion.h>
  25 #include <linux/uaccess.h>
  26
  27 #include "internal.h"
  28
  29 static DEFINE_RWLOCK(proc_subdir_lock);
  30
  31 static int proc_match(unsigned int len, const char *name, struct proc_dir_entry *de)
  32 {
  33         if (len < de->namelen)
  34                 return -1;
  35         if (len > de->namelen)
  36                 return 1;
  37
  38         return memcmp(name, de->name, len);
  39 }
  40
  41 static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir)
  42 {
  43         return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry,
  44                              subdir_node);
  45 }
  46
  47 static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir)
  48 {
  49         return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry,
  50                              subdir_node);
  51 }
  52
  53 static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir,
  54                                               const char *name,
  55                                               unsigned int len)
  56 {
  57         struct rb_node *node = dir->subdir.rb_node;
  58
  59         while (node) {
  60                 struct proc_dir_entry *de = rb_entry(node,
  61                                                      struct proc_dir_entry,
  62                                                      subdir_node);
  63                 int result = proc_match(len, name, de);
  64
  65                 if (result < 0)
  66                         node = node->rb_left;
  67                 else if (result > 0)
  68                         node = node->rb_right;
  69                 else
  70                         return de;
  71         }
  72         return NULL;
  73 }
  74
  75 static bool pde_subdir_insert(struct proc_dir_entry *dir,
  76                               struct proc_dir_entry *de)
  77 {
  78         struct rb_root *root = &dir->subdir;
  79         struct rb_node **new = &root->rb_node, *parent = NULL;
  80
  81         /* Figure out where to put new node */
  82         while (*new) {
  83                 struct proc_dir_entry *this = rb_entry(*new,
  84                                                        struct proc_dir_entry,
  85                                                        subdir_node);
  86                 int result = proc_match(de->namelen, de->name, this);
  87
  88                 parent = *new;
  89                 if (result < 0)
  90                         new = &(*new)->rb_left;
  91                 else if (result > 0)
  92                         new = &(*new)->rb_right;
  93                 else
  94                         return false;
  95         }
  96
  97         /* Add new node and rebalance tree. */
  98         rb_link_node(&de->subdir_node, parent, new);
  99         rb_insert_color(&de->subdir_node, root);
 100         return true;
 101 }
 102
 103 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 104 {
 105         struct inode *inode = d_inode(dentry);
 106         struct proc_dir_entry *de = PDE(inode);
 107         int error;
 108
 109         error = setattr_prepare(dentry, iattr);
 110         if (error)
 111                 return error;
 112
 113         setattr_copy(inode, iattr);
 114         mark_inode_dirty(inode);
 115
 116         proc_set_user(de, inode->i_uid, inode->i_gid);
 117         de->mode = inode->i_mode;
 118         return 0;
 119 }
 120
 121 static int proc_getattr(const struct path *path, struct kstat *stat,
 122                         u32 request_mask, unsigned int query_flags)
 123 {
 124         struct inode *inode = d_inode(path->dentry);
 125         struct proc_dir_entry *de = PDE(inode);
 126         if (de && de->nlink)
 127                 set_nlink(inode, de->nlink);
 128
 129         generic_fillattr(inode, stat);
 130         return 0;
 131 }
 132
 133 static const struct inode_operations proc_file_inode_operations = {
 134         .setattr        = proc_notify_change,
 135 };
 136
 137 /*
 138  * This function parses a name such as "tty/driver/serial", and
 139  * returns the struct proc_dir_entry for "/proc/tty/driver", and
 140  * returns "serial" in residual.
 141  */
 142 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret,
 143                              const char **residual)
 144 {
 145         const char              *cp = name, *next;
 146         struct proc_dir_entry   *de;
 147         unsigned int            len;
 148
 149         de = *ret;
 150         if (!de)
 151                 de = &proc_root;
 152
 153         while (1) {
 154                 next = strchr(cp, '/');
 155                 if (!next)
 156                         break;
 157
 158                 len = next - cp;
 159                 de = pde_subdir_find(de, cp, len);
 160                 if (!de) {
 161                         WARN(1, "name '%s'\n", name);
 162                         return -ENOENT;
 163                 }
 164                 cp += len + 1;
 165         }
 166         *residual = cp;
 167         *ret = de;
 168         return 0;
 169 }
 170
 171 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret,
 172                            const char **residual)
 173 {
 174         int rv;
 175
 176         read_lock(&proc_subdir_lock);
 177         rv = __xlate_proc_name(name, ret, residual);
 178         read_unlock(&proc_subdir_lock);
 179         return rv;
 180 }
 181
 182 static DEFINE_IDA(proc_inum_ida);
 183 static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */
 184
 185 #define PROC_DYNAMIC_FIRST 0xF0000000U
 186
 187 /*
 188  * Return an inode number between PROC_DYNAMIC_FIRST and
 189  * 0xffffffff, or zero on failure.
 190  */
 191 int proc_alloc_inum(unsigned int *inum)
 192 {
 193         unsigned int i;
 194         int error;
 195
 196 retry:
 197         if (!ida_pre_get(&proc_inum_ida, GFP_KERNEL))
 198                 return -ENOMEM;
 199
 200         spin_lock_irq(&proc_inum_lock);
 201         error = ida_get_new(&proc_inum_ida, &i);
 202         spin_unlock_irq(&proc_inum_lock);
 203         if (error == -EAGAIN)
 204                 goto retry;
 205         else if (error)
 206                 return error;
 207
 208         if (i > UINT_MAX - PROC_DYNAMIC_FIRST) {
 209                 spin_lock_irq(&proc_inum_lock);
 210                 ida_remove(&proc_inum_ida, i);
 211                 spin_unlock_irq(&proc_inum_lock);
 212                 return -ENOSPC;
 213         }
 214         *inum = PROC_DYNAMIC_FIRST + i;
 215         return 0;
 216 }
 217
 218 void proc_free_inum(unsigned int inum)
 219 {
 220         unsigned long flags;
 221         spin_lock_irqsave(&proc_inum_lock, flags);
 222         ida_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
 223         spin_unlock_irqrestore(&proc_inum_lock, flags);
 224 }
 225
 226 /*
 227  * Don't create negative dentries here, return -ENOENT by hand
 228  * instead.
 229  */
 230 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
 231                 struct dentry *dentry)
 232 {
 233         struct inode *inode;
 234
 235         read_lock(&proc_subdir_lock);
 236         de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
 237         if (de) {
 238                 pde_get(de);
 239                 read_unlock(&proc_subdir_lock);
 240                 inode = proc_get_inode(dir->i_sb, de);
 241                 if (!inode)
 242                         return ERR_PTR(-ENOMEM);
 243                 d_set_d_op(dentry, &simple_dentry_operations);
 244                 d_add(dentry, inode);
 245                 return NULL;
 246         }
 247         read_unlock(&proc_subdir_lock);
 248         return ERR_PTR(-ENOENT);
 249 }
 250
 251 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
 252                 unsigned int flags)
 253 {
 254         return proc_lookup_de(PDE(dir), dir, dentry);
 255 }
 256
 257 /*
 258  * This returns non-zero if at EOF, so that the /proc
 259  * root directory can use this and check if it should
 260  * continue with the <pid> entries..
 261  *
 262  * Note that the VFS-layer doesn't care about the return
 263  * value of the readdir() call, as long as it's non-negative
 264  * for success..
 265  */
 266 int proc_readdir_de(struct proc_dir_entry *de, struct file *file,
 267                     struct dir_context *ctx)
 268 {
 269         int i;
 270
 271         if (!dir_emit_dots(file, ctx))
 272                 return 0;
 273
 274         read_lock(&proc_subdir_lock);
 275         de = pde_subdir_first(de);
 276         i = ctx->pos - 2;
 277         for (;;) {
 278                 if (!de) {
 279                         read_unlock(&proc_subdir_lock);
 280                         return 0;
 281                 }
 282                 if (!i)
 283                         break;
 284                 de = pde_subdir_next(de);
 285                 i--;
 286         }
 287
 288         do {
 289                 struct proc_dir_entry *next;
 290                 pde_get(de);
 291                 read_unlock(&proc_subdir_lock);
 292                 if (!dir_emit(ctx, de->name, de->namelen,
 293                             de->low_ino, de->mode >> 12)) {
 294                         pde_put(de);
 295                         return 0;
 296                 }
 297                 read_lock(&proc_subdir_lock);
 298                 ctx->pos++;
 299                 next = pde_subdir_next(de);
 300                 pde_put(de);
 301                 de = next;
 302         } while (de);
 303         read_unlock(&proc_subdir_lock);
 304         return 1;
 305 }
 306
 307 int proc_readdir(struct file *file, struct dir_context *ctx)
 308 {
 309         struct inode *inode = file_inode(file);
 310
 311         return proc_readdir_de(PDE(inode), file, ctx);
 312 }
 313
 314 /*
 315  * These are the generic /proc directory operations. They
 316  * use the in-memory "struct proc_dir_entry" tree to parse
 317  * the /proc directory.
 318  */
 319 static const struct file_operations proc_dir_operations = {
 320         .llseek                 = generic_file_llseek,
 321         .read                   = generic_read_dir,
 322         .iterate_shared         = proc_readdir,
 323 };
 324
 325 /*
 326  * proc directories can do almost nothing..
 327  */
 328 static const struct inode_operations proc_dir_inode_operations = {
 329         .lookup         = proc_lookup,
 330         .getattr        = proc_getattr,
 331         .setattr        = proc_notify_change,
 332 };
 333
 334 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
 335 {
 336         int ret;
 337
 338         ret = proc_alloc_inum(&dp->low_ino);
 339         if (ret)
 340                 return ret;
 341
 342         write_lock(&proc_subdir_lock);
 343         dp->parent = dir;
 344         if (pde_subdir_insert(dir, dp) == false) {
 345                 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
 346                      dir->name, dp->name);
 347                 write_unlock(&proc_subdir_lock);
 348                 proc_free_inum(dp->low_ino);
 349                 return -EEXIST;
 350         }
 351         write_unlock(&proc_subdir_lock);
 352
 353         return 0;
 354 }
 355
 356 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 357                                           const char *name,
 358                                           umode_t mode,
 359                                           nlink_t nlink)
 360 {
 361         struct proc_dir_entry *ent = NULL;
 362         const char *fn;
 363         struct qstr qstr;
 364
 365         if (xlate_proc_name(name, parent, &fn) != 0)
 366                 goto out;
 367         qstr.name = fn;
 368         qstr.len = strlen(fn);
 369         if (qstr.len == 0 || qstr.len >= 256) {
 370                 WARN(1, "name len %u\n", qstr.len);
 371                 return NULL;
 372         }
 373         if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
 374                 WARN(1, "create '/proc/%s' by hand\n", qstr.name);
 375                 return NULL;
 376         }
 377         if (is_empty_pde(*parent)) {
 378                 WARN(1, "attempt to add to permanently empty directory");
 379                 return NULL;
 380         }
 381
 382         ent = kzalloc(sizeof(struct proc_dir_entry) + qstr.len + 1, GFP_KERNEL);
 383         if (!ent)
 384                 goto out;
 385
 386         memcpy(ent->name, fn, qstr.len + 1);
 387         ent->namelen = qstr.len;
 388         ent->mode = mode;
 389         ent->nlink = nlink;
 390         ent->subdir = RB_ROOT;
 391         atomic_set(&ent->count, 1);
 392         spin_lock_init(&ent->pde_unload_lock);
 393         INIT_LIST_HEAD(&ent->pde_openers);
 394         proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 395
 396 out:
 397         return ent;
 398 }
 399
 400 struct proc_dir_entry *proc_symlink(const char *name,
 401                 struct proc_dir_entry *parent, const char *dest)
 402 {
 403         struct proc_dir_entry *ent;
 404
 405         ent = __proc_create(&parent, name,
 406                           (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
 407
 408         if (ent) {
 409                 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
 410                 if (ent->data) {
 411                         strcpy((char*)ent->data,dest);
 412                         ent->proc_iops = &proc_link_inode_operations;
 413                         if (proc_register(parent, ent) < 0) {
 414                                 kfree(ent->data);
 415                                 kfree(ent);
 416                                 ent = NULL;
 417                         }
 418                 } else {
 419                         kfree(ent);
 420                         ent = NULL;
 421                 }
 422         }
 423         return ent;
 424 }
 425 EXPORT_SYMBOL(proc_symlink);
 426
 427 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
 428                 struct proc_dir_entry *parent, void *data)
 429 {
 430         struct proc_dir_entry *ent;
 431
 432         if (mode == 0)
 433                 mode = S_IRUGO | S_IXUGO;
 434
 435         ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
 436         if (ent) {
 437                 ent->data = data;
 438                 ent->proc_fops = &proc_dir_operations;
 439                 ent->proc_iops = &proc_dir_inode_operations;
 440                 parent->nlink++;
 441                 if (proc_register(parent, ent) < 0) {
 442                         kfree(ent);
 443                         parent->nlink--;
 444                         ent = NULL;
 445                 }
 446         }
 447         return ent;
 448 }
 449 EXPORT_SYMBOL_GPL(proc_mkdir_data);
 450
 451 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
 452                                        struct proc_dir_entry *parent)
 453 {
 454         return proc_mkdir_data(name, mode, parent, NULL);
 455 }
 456 EXPORT_SYMBOL(proc_mkdir_mode);
 457
 458 struct proc_dir_entry *proc_mkdir(const char *name,
 459                 struct proc_dir_entry *parent)
 460 {
 461         return proc_mkdir_data(name, 0, parent, NULL);
 462 }
 463 EXPORT_SYMBOL(proc_mkdir);
 464
 465 struct proc_dir_entry *proc_create_mount_point(const char *name)
 466 {
 467         umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
 468         struct proc_dir_entry *ent, *parent = NULL;
 469
 470         ent = __proc_create(&parent, name, mode, 2);
 471         if (ent) {
 472                 ent->data = NULL;
 473                 ent->proc_fops = NULL;
 474                 ent->proc_iops = NULL;
 475                 if (proc_register(parent, ent) < 0) {
 476                         kfree(ent);
 477                         parent->nlink--;
 478                         ent = NULL;
 479                 }
 480         }
 481         return ent;
 482 }
 483 EXPORT_SYMBOL(proc_create_mount_point);
 484
 485 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
 486                                         struct proc_dir_entry *parent,
 487                                         const struct file_operations *proc_fops,
 488                                         void *data)
 489 {
 490         struct proc_dir_entry *pde;
 491         if ((mode & S_IFMT) == 0)
 492                 mode |= S_IFREG;
 493
 494         if (!S_ISREG(mode)) {
 495                 WARN_ON(1);     /* use proc_mkdir() */
 496                 return NULL;
 497         }
 498
 499         BUG_ON(proc_fops == NULL);
 500
 501         if ((mode & S_IALLUGO) == 0)
 502                 mode |= S_IRUGO;
 503         pde = __proc_create(&parent, name, mode, 1);
 504         if (!pde)
 505                 goto out;
 506         pde->proc_fops = proc_fops;
 507         pde->data = data;
 508         pde->proc_iops = &proc_file_inode_operations;
 509         if (proc_register(parent, pde) < 0)
 510                 goto out_free;
 511         return pde;
 512 out_free:
 513         kfree(pde);
 514 out:
 515         return NULL;
 516 }
 517 EXPORT_SYMBOL(proc_create_data);
 518
 519 void proc_set_size(struct proc_dir_entry *de, loff_t size)
 520 {
 521         de->size = size;
 522 }
 523 EXPORT_SYMBOL(proc_set_size);
 524
 525 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
 526 {
 527         de->uid = uid;
 528         de->gid = gid;
 529 }
 530 EXPORT_SYMBOL(proc_set_user);
 531
 532 static void free_proc_entry(struct proc_dir_entry *de)
 533 {
 534         proc_free_inum(de->low_ino);
 535
 536         if (S_ISLNK(de->mode))
 537                 kfree(de->data);
 538         kfree(de);
 539 }
 540
 541 void pde_put(struct proc_dir_entry *pde)
 542 {
 543         if (atomic_dec_and_test(&pde->count))
 544                 free_proc_entry(pde);
 545 }
 546
 547 /*
 548  * Remove a /proc entry and free it if it's not currently in use.
 549  */
 550 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
 551 {
 552         struct proc_dir_entry *de = NULL;
 553         const char *fn = name;
 554         unsigned int len;
 555
 556         write_lock(&proc_subdir_lock);
 557         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 558                 write_unlock(&proc_subdir_lock);
 559                 return;
 560         }
 561         len = strlen(fn);
 562
 563         de = pde_subdir_find(parent, fn, len);
 564         if (de)
 565                 rb_erase(&de->subdir_node, &parent->subdir);
 566         write_unlock(&proc_subdir_lock);
 567         if (!de) {
 568                 WARN(1, "name '%s'\n", name);
 569                 return;
 570         }
 571
 572         proc_entry_rundown(de);
 573
 574         if (S_ISDIR(de->mode))
 575                 parent->nlink--;
 576         de->nlink = 0;
 577         WARN(pde_subdir_first(de),
 578              "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
 579              __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
 580         pde_put(de);
 581 }
 582 EXPORT_SYMBOL(remove_proc_entry);
 583
 584 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
 585 {
 586         struct proc_dir_entry *root = NULL, *de, *next;
 587         const char *fn = name;
 588         unsigned int len;
 589
 590         write_lock(&proc_subdir_lock);
 591         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 592                 write_unlock(&proc_subdir_lock);
 593                 return -ENOENT;
 594         }
 595         len = strlen(fn);
 596
 597         root = pde_subdir_find(parent, fn, len);
 598         if (!root) {
 599                 write_unlock(&proc_subdir_lock);
 600                 return -ENOENT;
 601         }
 602         rb_erase(&root->subdir_node, &parent->subdir);
 603
 604         de = root;
 605         while (1) {
 606                 next = pde_subdir_first(de);
 607                 if (next) {
 608                         rb_erase(&next->subdir_node, &de->subdir);
 609                         de = next;
 610                         continue;
 611                 }
 612                 write_unlock(&proc_subdir_lock);
 613
 614                 proc_entry_rundown(de);
 615                 next = de->parent;
 616                 if (S_ISDIR(de->mode))
 617                         next->nlink--;
 618                 de->nlink = 0;
 619                 if (de == root)
 620                         break;
 621                 pde_put(de);
 622
 623                 write_lock(&proc_subdir_lock);
 624                 de = next;
 625         }
 626         pde_put(root);
 627         return 0;
 628 }
 629 EXPORT_SYMBOL(remove_proc_subtree);
 630
 631 void *proc_get_parent_data(const struct inode *inode)
 632 {
 633         struct proc_dir_entry *de = PDE(inode);
 634         return de->parent->data;
 635 }
 636 EXPORT_SYMBOL_GPL(proc_get_parent_data);
 637
 638 void proc_remove(struct proc_dir_entry *de)
 639 {
 640         if (de)
 641                 remove_proc_subtree(de->name, de->parent);
 642 }
 643 EXPORT_SYMBOL(proc_remove);
 644
 645 void *PDE_DATA(const struct inode *inode)
 646 {
 647         return __PDE_DATA(inode);
 648 }
 649 EXPORT_SYMBOL(PDE_DATA);