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                 parent->nlink++;
 476                 if (proc_register(parent, ent) < 0) {
 477                         kfree(ent);
 478                         parent->nlink--;
 479                         ent = NULL;
 480                 }
 481         }
 482         return ent;
 483 }
 484 EXPORT_SYMBOL(proc_create_mount_point);
 485
 486 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
 487                                         struct proc_dir_entry *parent,
 488                                         const struct file_operations *proc_fops,
 489                                         void *data)
 490 {
 491         struct proc_dir_entry *pde;
 492         if ((mode & S_IFMT) == 0)
 493                 mode |= S_IFREG;
 494
 495         if (!S_ISREG(mode)) {
 496                 WARN_ON(1);     /* use proc_mkdir() */
 497                 return NULL;
 498         }
 499
 500         BUG_ON(proc_fops == NULL);
 501
 502         if ((mode & S_IALLUGO) == 0)
 503                 mode |= S_IRUGO;
 504         pde = __proc_create(&parent, name, mode, 1);
 505         if (!pde)
 506                 goto out;
 507         pde->proc_fops = proc_fops;
 508         pde->data = data;
 509         pde->proc_iops = &proc_file_inode_operations;
 510         if (proc_register(parent, pde) < 0)
 511                 goto out_free;
 512         return pde;
 513 out_free:
 514         kfree(pde);
 515 out:
 516         return NULL;
 517 }
 518 EXPORT_SYMBOL(proc_create_data);
 519
 520 void proc_set_size(struct proc_dir_entry *de, loff_t size)
 521 {
 522         de->size = size;
 523 }
 524 EXPORT_SYMBOL(proc_set_size);
 525
 526 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
 527 {
 528         de->uid = uid;
 529         de->gid = gid;
 530 }
 531 EXPORT_SYMBOL(proc_set_user);
 532
 533 static void free_proc_entry(struct proc_dir_entry *de)
 534 {
 535         proc_free_inum(de->low_ino);
 536
 537         if (S_ISLNK(de->mode))
 538                 kfree(de->data);
 539         kfree(de);
 540 }
 541
 542 void pde_put(struct proc_dir_entry *pde)
 543 {
 544         if (atomic_dec_and_test(&pde->count))
 545                 free_proc_entry(pde);
 546 }
 547
 548 /*
 549  * Remove a /proc entry and free it if it's not currently in use.
 550  */
 551 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
 552 {
 553         struct proc_dir_entry *de = NULL;
 554         const char *fn = name;
 555         unsigned int len;
 556
 557         write_lock(&proc_subdir_lock);
 558         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 559                 write_unlock(&proc_subdir_lock);
 560                 return;
 561         }
 562         len = strlen(fn);
 563
 564         de = pde_subdir_find(parent, fn, len);
 565         if (de)
 566                 rb_erase(&de->subdir_node, &parent->subdir);
 567         write_unlock(&proc_subdir_lock);
 568         if (!de) {
 569                 WARN(1, "name '%s'\n", name);
 570                 return;
 571         }
 572
 573         proc_entry_rundown(de);
 574
 575         if (S_ISDIR(de->mode))
 576                 parent->nlink--;
 577         de->nlink = 0;
 578         WARN(pde_subdir_first(de),
 579              "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
 580              __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
 581         pde_put(de);
 582 }
 583 EXPORT_SYMBOL(remove_proc_entry);
 584
 585 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
 586 {
 587         struct proc_dir_entry *root = NULL, *de, *next;
 588         const char *fn = name;
 589         unsigned int len;
 590
 591         write_lock(&proc_subdir_lock);
 592         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 593                 write_unlock(&proc_subdir_lock);
 594                 return -ENOENT;
 595         }
 596         len = strlen(fn);
 597
 598         root = pde_subdir_find(parent, fn, len);
 599         if (!root) {
 600                 write_unlock(&proc_subdir_lock);
 601                 return -ENOENT;
 602         }
 603         rb_erase(&root->subdir_node, &parent->subdir);
 604
 605         de = root;
 606         while (1) {
 607                 next = pde_subdir_first(de);
 608                 if (next) {
 609                         rb_erase(&next->subdir_node, &de->subdir);
 610                         de = next;
 611                         continue;
 612                 }
 613                 write_unlock(&proc_subdir_lock);
 614
 615                 proc_entry_rundown(de);
 616                 next = de->parent;
 617                 if (S_ISDIR(de->mode))
 618                         next->nlink--;
 619                 de->nlink = 0;
 620                 if (de == root)
 621                         break;
 622                 pde_put(de);
 623
 624                 write_lock(&proc_subdir_lock);
 625                 de = next;
 626         }
 627         pde_put(root);
 628         return 0;
 629 }
 630 EXPORT_SYMBOL(remove_proc_subtree);
 631
 632 void *proc_get_parent_data(const struct inode *inode)
 633 {
 634         struct proc_dir_entry *de = PDE(inode);
 635         return de->parent->data;
 636 }
 637 EXPORT_SYMBOL_GPL(proc_get_parent_data);
 638
 639 void proc_remove(struct proc_dir_entry *de)
 640 {
 641         if (de)
 642                 remove_proc_subtree(de->name, de->parent);
 643 }
 644 EXPORT_SYMBOL(proc_remove);
 645
 646 void *PDE_DATA(const struct inode *inode)
 647 {
 648         return __PDE_DATA(inode);
 649 }
 650 EXPORT_SYMBOL(PDE_DATA);