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
 184 #define PROC_DYNAMIC_FIRST 0xF0000000U
 185
 186 /*
 187  * Return an inode number between PROC_DYNAMIC_FIRST and
 188  * 0xffffffff, or zero on failure.
 189  */
 190 int proc_alloc_inum(unsigned int *inum)
 191 {
 192         int i;
 193
 194         i = ida_simple_get(&proc_inum_ida, 0, UINT_MAX - PROC_DYNAMIC_FIRST + 1,
 195                            GFP_KERNEL);
 196         if (i < 0)
 197                 return i;
 198
 199         *inum = PROC_DYNAMIC_FIRST + (unsigned int)i;
 200         return 0;
 201 }
 202
 203 void proc_free_inum(unsigned int inum)
 204 {
 205         ida_simple_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST);
 206 }
 207
 208 /*
 209  * Don't create negative dentries here, return -ENOENT by hand
 210  * instead.
 211  */
 212 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
 213                 struct dentry *dentry)
 214 {
 215         struct inode *inode;
 216
 217         read_lock(&proc_subdir_lock);
 218         de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len);
 219         if (de) {
 220                 pde_get(de);
 221                 read_unlock(&proc_subdir_lock);
 222                 inode = proc_get_inode(dir->i_sb, de);
 223                 if (!inode)
 224                         return ERR_PTR(-ENOMEM);
 225                 d_set_d_op(dentry, &simple_dentry_operations);
 226                 d_add(dentry, inode);
 227                 return NULL;
 228         }
 229         read_unlock(&proc_subdir_lock);
 230         return ERR_PTR(-ENOENT);
 231 }
 232
 233 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
 234                 unsigned int flags)
 235 {
 236         return proc_lookup_de(PDE(dir), dir, dentry);
 237 }
 238
 239 /*
 240  * This returns non-zero if at EOF, so that the /proc
 241  * root directory can use this and check if it should
 242  * continue with the <pid> entries..
 243  *
 244  * Note that the VFS-layer doesn't care about the return
 245  * value of the readdir() call, as long as it's non-negative
 246  * for success..
 247  */
 248 int proc_readdir_de(struct proc_dir_entry *de, struct file *file,
 249                     struct dir_context *ctx)
 250 {
 251         int i;
 252
 253         if (!dir_emit_dots(file, ctx))
 254                 return 0;
 255
 256         read_lock(&proc_subdir_lock);
 257         de = pde_subdir_first(de);
 258         i = ctx->pos - 2;
 259         for (;;) {
 260                 if (!de) {
 261                         read_unlock(&proc_subdir_lock);
 262                         return 0;
 263                 }
 264                 if (!i)
 265                         break;
 266                 de = pde_subdir_next(de);
 267                 i--;
 268         }
 269
 270         do {
 271                 struct proc_dir_entry *next;
 272                 pde_get(de);
 273                 read_unlock(&proc_subdir_lock);
 274                 if (!dir_emit(ctx, de->name, de->namelen,
 275                             de->low_ino, de->mode >> 12)) {
 276                         pde_put(de);
 277                         return 0;
 278                 }
 279                 read_lock(&proc_subdir_lock);
 280                 ctx->pos++;
 281                 next = pde_subdir_next(de);
 282                 pde_put(de);
 283                 de = next;
 284         } while (de);
 285         read_unlock(&proc_subdir_lock);
 286         return 1;
 287 }
 288
 289 int proc_readdir(struct file *file, struct dir_context *ctx)
 290 {
 291         struct inode *inode = file_inode(file);
 292
 293         return proc_readdir_de(PDE(inode), file, ctx);
 294 }
 295
 296 /*
 297  * These are the generic /proc directory operations. They
 298  * use the in-memory "struct proc_dir_entry" tree to parse
 299  * the /proc directory.
 300  */
 301 static const struct file_operations proc_dir_operations = {
 302         .llseek                 = generic_file_llseek,
 303         .read                   = generic_read_dir,
 304         .iterate_shared         = proc_readdir,
 305 };
 306
 307 /*
 308  * proc directories can do almost nothing..
 309  */
 310 static const struct inode_operations proc_dir_inode_operations = {
 311         .lookup         = proc_lookup,
 312         .getattr        = proc_getattr,
 313         .setattr        = proc_notify_change,
 314 };
 315
 316 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
 317 {
 318         int ret;
 319
 320         ret = proc_alloc_inum(&dp->low_ino);
 321         if (ret)
 322                 return ret;
 323
 324         write_lock(&proc_subdir_lock);
 325         dp->parent = dir;
 326         if (pde_subdir_insert(dir, dp) == false) {
 327                 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
 328                      dir->name, dp->name);
 329                 write_unlock(&proc_subdir_lock);
 330                 proc_free_inum(dp->low_ino);
 331                 return -EEXIST;
 332         }
 333         write_unlock(&proc_subdir_lock);
 334
 335         return 0;
 336 }
 337
 338 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
 339                                           const char *name,
 340                                           umode_t mode,
 341                                           nlink_t nlink)
 342 {
 343         struct proc_dir_entry *ent = NULL;
 344         const char *fn;
 345         struct qstr qstr;
 346
 347         if (xlate_proc_name(name, parent, &fn) != 0)
 348                 goto out;
 349         qstr.name = fn;
 350         qstr.len = strlen(fn);
 351         if (qstr.len == 0 || qstr.len >= 256) {
 352                 WARN(1, "name len %u\n", qstr.len);
 353                 return NULL;
 354         }
 355         if (*parent == &proc_root && name_to_int(&qstr) != ~0U) {
 356                 WARN(1, "create '/proc/%s' by hand\n", qstr.name);
 357                 return NULL;
 358         }
 359         if (is_empty_pde(*parent)) {
 360                 WARN(1, "attempt to add to permanently empty directory");
 361                 return NULL;
 362         }
 363
 364         ent = kzalloc(sizeof(struct proc_dir_entry) + qstr.len + 1, GFP_KERNEL);
 365         if (!ent)
 366                 goto out;
 367
 368         memcpy(ent->name, fn, qstr.len + 1);
 369         ent->namelen = qstr.len;
 370         ent->mode = mode;
 371         ent->nlink = nlink;
 372         ent->subdir = RB_ROOT;
 373         atomic_set(&ent->count, 1);
 374         spin_lock_init(&ent->pde_unload_lock);
 375         INIT_LIST_HEAD(&ent->pde_openers);
 376         proc_set_user(ent, (*parent)->uid, (*parent)->gid);
 377
 378 out:
 379         return ent;
 380 }
 381
 382 struct proc_dir_entry *proc_symlink(const char *name,
 383                 struct proc_dir_entry *parent, const char *dest)
 384 {
 385         struct proc_dir_entry *ent;
 386
 387         ent = __proc_create(&parent, name,
 388                           (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
 389
 390         if (ent) {
 391                 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL);
 392                 if (ent->data) {
 393                         strcpy((char*)ent->data,dest);
 394                         ent->proc_iops = &proc_link_inode_operations;
 395                         if (proc_register(parent, ent) < 0) {
 396                                 kfree(ent->data);
 397                                 kfree(ent);
 398                                 ent = NULL;
 399                         }
 400                 } else {
 401                         kfree(ent);
 402                         ent = NULL;
 403                 }
 404         }
 405         return ent;
 406 }
 407 EXPORT_SYMBOL(proc_symlink);
 408
 409 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
 410                 struct proc_dir_entry *parent, void *data)
 411 {
 412         struct proc_dir_entry *ent;
 413
 414         if (mode == 0)
 415                 mode = S_IRUGO | S_IXUGO;
 416
 417         ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
 418         if (ent) {
 419                 ent->data = data;
 420                 ent->proc_fops = &proc_dir_operations;
 421                 ent->proc_iops = &proc_dir_inode_operations;
 422                 parent->nlink++;
 423                 if (proc_register(parent, ent) < 0) {
 424                         kfree(ent);
 425                         parent->nlink--;
 426                         ent = NULL;
 427                 }
 428         }
 429         return ent;
 430 }
 431 EXPORT_SYMBOL_GPL(proc_mkdir_data);
 432
 433 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode,
 434                                        struct proc_dir_entry *parent)
 435 {
 436         return proc_mkdir_data(name, mode, parent, NULL);
 437 }
 438 EXPORT_SYMBOL(proc_mkdir_mode);
 439
 440 struct proc_dir_entry *proc_mkdir(const char *name,
 441                 struct proc_dir_entry *parent)
 442 {
 443         return proc_mkdir_data(name, 0, parent, NULL);
 444 }
 445 EXPORT_SYMBOL(proc_mkdir);
 446
 447 struct proc_dir_entry *proc_create_mount_point(const char *name)
 448 {
 449         umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO;
 450         struct proc_dir_entry *ent, *parent = NULL;
 451
 452         ent = __proc_create(&parent, name, mode, 2);
 453         if (ent) {
 454                 ent->data = NULL;
 455                 ent->proc_fops = NULL;
 456                 ent->proc_iops = NULL;
 457                 parent->nlink++;
 458                 if (proc_register(parent, ent) < 0) {
 459                         kfree(ent);
 460                         parent->nlink--;
 461                         ent = NULL;
 462                 }
 463         }
 464         return ent;
 465 }
 466 EXPORT_SYMBOL(proc_create_mount_point);
 467
 468 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
 469                                         struct proc_dir_entry *parent,
 470                                         const struct file_operations *proc_fops,
 471                                         void *data)
 472 {
 473         struct proc_dir_entry *pde;
 474         if ((mode & S_IFMT) == 0)
 475                 mode |= S_IFREG;
 476
 477         if (!S_ISREG(mode)) {
 478                 WARN_ON(1);     /* use proc_mkdir() */
 479                 return NULL;
 480         }
 481
 482         BUG_ON(proc_fops == NULL);
 483
 484         if ((mode & S_IALLUGO) == 0)
 485                 mode |= S_IRUGO;
 486         pde = __proc_create(&parent, name, mode, 1);
 487         if (!pde)
 488                 goto out;
 489         pde->proc_fops = proc_fops;
 490         pde->data = data;
 491         pde->proc_iops = &proc_file_inode_operations;
 492         if (proc_register(parent, pde) < 0)
 493                 goto out_free;
 494         return pde;
 495 out_free:
 496         kfree(pde);
 497 out:
 498         return NULL;
 499 }
 500 EXPORT_SYMBOL(proc_create_data);
 501
 502 void proc_set_size(struct proc_dir_entry *de, loff_t size)
 503 {
 504         de->size = size;
 505 }
 506 EXPORT_SYMBOL(proc_set_size);
 507
 508 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid)
 509 {
 510         de->uid = uid;
 511         de->gid = gid;
 512 }
 513 EXPORT_SYMBOL(proc_set_user);
 514
 515 static void free_proc_entry(struct proc_dir_entry *de)
 516 {
 517         proc_free_inum(de->low_ino);
 518
 519         if (S_ISLNK(de->mode))
 520                 kfree(de->data);
 521         kfree(de);
 522 }
 523
 524 void pde_put(struct proc_dir_entry *pde)
 525 {
 526         if (atomic_dec_and_test(&pde->count))
 527                 free_proc_entry(pde);
 528 }
 529
 530 /*
 531  * Remove a /proc entry and free it if it's not currently in use.
 532  */
 533 void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
 534 {
 535         struct proc_dir_entry *de = NULL;
 536         const char *fn = name;
 537         unsigned int len;
 538
 539         write_lock(&proc_subdir_lock);
 540         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 541                 write_unlock(&proc_subdir_lock);
 542                 return;
 543         }
 544         len = strlen(fn);
 545
 546         de = pde_subdir_find(parent, fn, len);
 547         if (de)
 548                 rb_erase(&de->subdir_node, &parent->subdir);
 549         write_unlock(&proc_subdir_lock);
 550         if (!de) {
 551                 WARN(1, "name '%s'\n", name);
 552                 return;
 553         }
 554
 555         proc_entry_rundown(de);
 556
 557         if (S_ISDIR(de->mode))
 558                 parent->nlink--;
 559         de->nlink = 0;
 560         WARN(pde_subdir_first(de),
 561              "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n",
 562              __func__, de->parent->name, de->name, pde_subdir_first(de)->name);
 563         pde_put(de);
 564 }
 565 EXPORT_SYMBOL(remove_proc_entry);
 566
 567 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent)
 568 {
 569         struct proc_dir_entry *root = NULL, *de, *next;
 570         const char *fn = name;
 571         unsigned int len;
 572
 573         write_lock(&proc_subdir_lock);
 574         if (__xlate_proc_name(name, &parent, &fn) != 0) {
 575                 write_unlock(&proc_subdir_lock);
 576                 return -ENOENT;
 577         }
 578         len = strlen(fn);
 579
 580         root = pde_subdir_find(parent, fn, len);
 581         if (!root) {
 582                 write_unlock(&proc_subdir_lock);
 583                 return -ENOENT;
 584         }
 585         rb_erase(&root->subdir_node, &parent->subdir);
 586
 587         de = root;
 588         while (1) {
 589                 next = pde_subdir_first(de);
 590                 if (next) {
 591                         rb_erase(&next->subdir_node, &de->subdir);
 592                         de = next;
 593                         continue;
 594                 }
 595                 write_unlock(&proc_subdir_lock);
 596
 597                 proc_entry_rundown(de);
 598                 next = de->parent;
 599                 if (S_ISDIR(de->mode))
 600                         next->nlink--;
 601                 de->nlink = 0;
 602                 if (de == root)
 603                         break;
 604                 pde_put(de);
 605
 606                 write_lock(&proc_subdir_lock);
 607                 de = next;
 608         }
 609         pde_put(root);
 610         return 0;
 611 }
 612 EXPORT_SYMBOL(remove_proc_subtree);
 613
 614 void *proc_get_parent_data(const struct inode *inode)
 615 {
 616         struct proc_dir_entry *de = PDE(inode);
 617         return de->parent->data;
 618 }
 619 EXPORT_SYMBOL_GPL(proc_get_parent_data);
 620
 621 void proc_remove(struct proc_dir_entry *de)
 622 {
 623         if (de)
 624                 remove_proc_subtree(de->name, de->parent);
 625 }
 626 EXPORT_SYMBOL(proc_remove);
 627
 628 void *PDE_DATA(const struct inode *inode)
 629 {
 630         return __PDE_DATA(inode);
 631 }
 632 EXPORT_SYMBOL(PDE_DATA);