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