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