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/namei.h> 23 #include <linux/bitops.h> 24 #include <linux/spinlock.h> 25 #include <linux/completion.h> 26 #include <asm/uaccess.h> 27 28 #include "internal.h" 29 30 static DEFINE_SPINLOCK(proc_subdir_lock); 31 32 static int proc_match(unsigned int len, const char *name, struct proc_dir_entry *de) 33 { 34 if (len < de->namelen) 35 return -1; 36 if (len > de->namelen) 37 return 1; 38 39 return memcmp(name, de->name, len); 40 } 41 42 static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir) 43 { 44 return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry, 45 subdir_node); 46 } 47 48 static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir) 49 { 50 return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry, 51 subdir_node); 52 } 53 54 static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir, 55 const char *name, 56 unsigned int len) 57 { 58 struct rb_node *node = dir->subdir.rb_node; 59 60 while (node) { 61 struct proc_dir_entry *de = container_of(node, 62 struct proc_dir_entry, 63 subdir_node); 64 int result = proc_match(len, name, de); 65 66 if (result < 0) 67 node = node->rb_left; 68 else if (result > 0) 69 node = node->rb_right; 70 else 71 return de; 72 } 73 return NULL; 74 } 75 76 static bool pde_subdir_insert(struct proc_dir_entry *dir, 77 struct proc_dir_entry *de) 78 { 79 struct rb_root *root = &dir->subdir; 80 struct rb_node **new = &root->rb_node, *parent = NULL; 81 82 /* Figure out where to put new node */ 83 while (*new) { 84 struct proc_dir_entry *this = 85 container_of(*new, struct proc_dir_entry, 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 = dentry->d_inode; 106 struct proc_dir_entry *de = PDE(inode); 107 int error; 108 109 error = inode_change_ok(inode, 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(struct vfsmount *mnt, struct dentry *dentry, 122 struct kstat *stat) 123 { 124 struct inode *inode = dentry->d_inode; 125 struct proc_dir_entry *de = PROC_I(inode)->pde; 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 spin_lock(&proc_subdir_lock); 177 rv = __xlate_proc_name(name, ret, residual); 178 spin_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 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd) 227 { 228 nd_set_link(nd, __PDE_DATA(dentry->d_inode)); 229 return NULL; 230 } 231 232 static const struct inode_operations proc_link_inode_operations = { 233 .readlink = generic_readlink, 234 .follow_link = proc_follow_link, 235 }; 236 237 /* 238 * Don't create negative dentries here, return -ENOENT by hand 239 * instead. 240 */ 241 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir, 242 struct dentry *dentry) 243 { 244 struct inode *inode; 245 246 spin_lock(&proc_subdir_lock); 247 de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len); 248 if (de) { 249 pde_get(de); 250 spin_unlock(&proc_subdir_lock); 251 inode = proc_get_inode(dir->i_sb, de); 252 if (!inode) 253 return ERR_PTR(-ENOMEM); 254 d_set_d_op(dentry, &simple_dentry_operations); 255 d_add(dentry, inode); 256 return NULL; 257 } 258 spin_unlock(&proc_subdir_lock); 259 return ERR_PTR(-ENOENT); 260 } 261 262 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry, 263 unsigned int flags) 264 { 265 return proc_lookup_de(PDE(dir), dir, dentry); 266 } 267 268 /* 269 * This returns non-zero if at EOF, so that the /proc 270 * root directory can use this and check if it should 271 * continue with the <pid> entries.. 272 * 273 * Note that the VFS-layer doesn't care about the return 274 * value of the readdir() call, as long as it's non-negative 275 * for success.. 276 */ 277 int proc_readdir_de(struct proc_dir_entry *de, struct file *file, 278 struct dir_context *ctx) 279 { 280 int i; 281 282 if (!dir_emit_dots(file, ctx)) 283 return 0; 284 285 spin_lock(&proc_subdir_lock); 286 de = pde_subdir_first(de); 287 i = ctx->pos - 2; 288 for (;;) { 289 if (!de) { 290 spin_unlock(&proc_subdir_lock); 291 return 0; 292 } 293 if (!i) 294 break; 295 de = pde_subdir_next(de); 296 i--; 297 } 298 299 do { 300 struct proc_dir_entry *next; 301 pde_get(de); 302 spin_unlock(&proc_subdir_lock); 303 if (!dir_emit(ctx, de->name, de->namelen, 304 de->low_ino, de->mode >> 12)) { 305 pde_put(de); 306 return 0; 307 } 308 spin_lock(&proc_subdir_lock); 309 ctx->pos++; 310 next = pde_subdir_next(de); 311 pde_put(de); 312 de = next; 313 } while (de); 314 spin_unlock(&proc_subdir_lock); 315 return 1; 316 } 317 318 int proc_readdir(struct file *file, struct dir_context *ctx) 319 { 320 struct inode *inode = file_inode(file); 321 322 return proc_readdir_de(PDE(inode), file, ctx); 323 } 324 325 /* 326 * These are the generic /proc directory operations. They 327 * use the in-memory "struct proc_dir_entry" tree to parse 328 * the /proc directory. 329 */ 330 static const struct file_operations proc_dir_operations = { 331 .llseek = generic_file_llseek, 332 .read = generic_read_dir, 333 .iterate = proc_readdir, 334 }; 335 336 /* 337 * proc directories can do almost nothing.. 338 */ 339 static const struct inode_operations proc_dir_inode_operations = { 340 .lookup = proc_lookup, 341 .getattr = proc_getattr, 342 .setattr = proc_notify_change, 343 }; 344 345 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp) 346 { 347 int ret; 348 349 ret = proc_alloc_inum(&dp->low_ino); 350 if (ret) 351 return ret; 352 353 if (S_ISDIR(dp->mode)) { 354 dp->proc_fops = &proc_dir_operations; 355 dp->proc_iops = &proc_dir_inode_operations; 356 dir->nlink++; 357 } else if (S_ISLNK(dp->mode)) { 358 dp->proc_iops = &proc_link_inode_operations; 359 } else if (S_ISREG(dp->mode)) { 360 BUG_ON(dp->proc_fops == NULL); 361 dp->proc_iops = &proc_file_inode_operations; 362 } else { 363 WARN_ON(1); 364 proc_free_inum(dp->low_ino); 365 return -EINVAL; 366 } 367 368 spin_lock(&proc_subdir_lock); 369 dp->parent = dir; 370 if (pde_subdir_insert(dir, dp) == false) { 371 WARN(1, "proc_dir_entry '%s/%s' already registered\n", 372 dir->name, dp->name); 373 spin_unlock(&proc_subdir_lock); 374 if (S_ISDIR(dp->mode)) 375 dir->nlink--; 376 proc_free_inum(dp->low_ino); 377 return -EEXIST; 378 } 379 spin_unlock(&proc_subdir_lock); 380 381 return 0; 382 } 383 384 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent, 385 const char *name, 386 umode_t mode, 387 nlink_t nlink) 388 { 389 struct proc_dir_entry *ent = NULL; 390 const char *fn; 391 struct qstr qstr; 392 393 if (xlate_proc_name(name, parent, &fn) != 0) 394 goto out; 395 qstr.name = fn; 396 qstr.len = strlen(fn); 397 if (qstr.len == 0 || qstr.len >= 256) { 398 WARN(1, "name len %u\n", qstr.len); 399 return NULL; 400 } 401 if (*parent == &proc_root && name_to_int(&qstr) != ~0U) { 402 WARN(1, "create '/proc/%s' by hand\n", qstr.name); 403 return NULL; 404 } 405 406 ent = kzalloc(sizeof(struct proc_dir_entry) + qstr.len + 1, GFP_KERNEL); 407 if (!ent) 408 goto out; 409 410 memcpy(ent->name, fn, qstr.len + 1); 411 ent->namelen = qstr.len; 412 ent->mode = mode; 413 ent->nlink = nlink; 414 ent->subdir = RB_ROOT; 415 atomic_set(&ent->count, 1); 416 spin_lock_init(&ent->pde_unload_lock); 417 INIT_LIST_HEAD(&ent->pde_openers); 418 out: 419 return ent; 420 } 421 422 struct proc_dir_entry *proc_symlink(const char *name, 423 struct proc_dir_entry *parent, const char *dest) 424 { 425 struct proc_dir_entry *ent; 426 427 ent = __proc_create(&parent, name, 428 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1); 429 430 if (ent) { 431 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL); 432 if (ent->data) { 433 strcpy((char*)ent->data,dest); 434 if (proc_register(parent, ent) < 0) { 435 kfree(ent->data); 436 kfree(ent); 437 ent = NULL; 438 } 439 } else { 440 kfree(ent); 441 ent = NULL; 442 } 443 } 444 return ent; 445 } 446 EXPORT_SYMBOL(proc_symlink); 447 448 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode, 449 struct proc_dir_entry *parent, void *data) 450 { 451 struct proc_dir_entry *ent; 452 453 if (mode == 0) 454 mode = S_IRUGO | S_IXUGO; 455 456 ent = __proc_create(&parent, name, S_IFDIR | mode, 2); 457 if (ent) { 458 ent->data = data; 459 if (proc_register(parent, ent) < 0) { 460 kfree(ent); 461 ent = NULL; 462 } 463 } 464 return ent; 465 } 466 EXPORT_SYMBOL_GPL(proc_mkdir_data); 467 468 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode, 469 struct proc_dir_entry *parent) 470 { 471 return proc_mkdir_data(name, mode, parent, NULL); 472 } 473 EXPORT_SYMBOL(proc_mkdir_mode); 474 475 struct proc_dir_entry *proc_mkdir(const char *name, 476 struct proc_dir_entry *parent) 477 { 478 return proc_mkdir_data(name, 0, parent, NULL); 479 } 480 EXPORT_SYMBOL(proc_mkdir); 481 482 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode, 483 struct proc_dir_entry *parent, 484 const struct file_operations *proc_fops, 485 void *data) 486 { 487 struct proc_dir_entry *pde; 488 if ((mode & S_IFMT) == 0) 489 mode |= S_IFREG; 490 491 if (!S_ISREG(mode)) { 492 WARN_ON(1); /* use proc_mkdir() */ 493 return NULL; 494 } 495 496 if ((mode & S_IALLUGO) == 0) 497 mode |= S_IRUGO; 498 pde = __proc_create(&parent, name, mode, 1); 499 if (!pde) 500 goto out; 501 pde->proc_fops = proc_fops; 502 pde->data = data; 503 if (proc_register(parent, pde) < 0) 504 goto out_free; 505 return pde; 506 out_free: 507 kfree(pde); 508 out: 509 return NULL; 510 } 511 EXPORT_SYMBOL(proc_create_data); 512 513 void proc_set_size(struct proc_dir_entry *de, loff_t size) 514 { 515 de->size = size; 516 } 517 EXPORT_SYMBOL(proc_set_size); 518 519 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid) 520 { 521 de->uid = uid; 522 de->gid = gid; 523 } 524 EXPORT_SYMBOL(proc_set_user); 525 526 static void free_proc_entry(struct proc_dir_entry *de) 527 { 528 proc_free_inum(de->low_ino); 529 530 if (S_ISLNK(de->mode)) 531 kfree(de->data); 532 kfree(de); 533 } 534 535 void pde_put(struct proc_dir_entry *pde) 536 { 537 if (atomic_dec_and_test(&pde->count)) 538 free_proc_entry(pde); 539 } 540 541 /* 542 * Remove a /proc entry and free it if it's not currently in use. 543 */ 544 void remove_proc_entry(const char *name, struct proc_dir_entry *parent) 545 { 546 struct proc_dir_entry *de = NULL; 547 const char *fn = name; 548 unsigned int len; 549 550 spin_lock(&proc_subdir_lock); 551 if (__xlate_proc_name(name, &parent, &fn) != 0) { 552 spin_unlock(&proc_subdir_lock); 553 return; 554 } 555 len = strlen(fn); 556 557 de = pde_subdir_find(parent, fn, len); 558 if (de) 559 rb_erase(&de->subdir_node, &parent->subdir); 560 spin_unlock(&proc_subdir_lock); 561 if (!de) { 562 WARN(1, "name '%s'\n", name); 563 return; 564 } 565 566 proc_entry_rundown(de); 567 568 if (S_ISDIR(de->mode)) 569 parent->nlink--; 570 de->nlink = 0; 571 WARN(pde_subdir_first(de), 572 "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n", 573 __func__, de->parent->name, de->name, pde_subdir_first(de)->name); 574 pde_put(de); 575 } 576 EXPORT_SYMBOL(remove_proc_entry); 577 578 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent) 579 { 580 struct proc_dir_entry *root = NULL, *de, *next; 581 const char *fn = name; 582 unsigned int len; 583 584 spin_lock(&proc_subdir_lock); 585 if (__xlate_proc_name(name, &parent, &fn) != 0) { 586 spin_unlock(&proc_subdir_lock); 587 return -ENOENT; 588 } 589 len = strlen(fn); 590 591 root = pde_subdir_find(parent, fn, len); 592 if (!root) { 593 spin_unlock(&proc_subdir_lock); 594 return -ENOENT; 595 } 596 rb_erase(&root->subdir_node, &parent->subdir); 597 598 de = root; 599 while (1) { 600 next = pde_subdir_first(de); 601 if (next) { 602 rb_erase(&next->subdir_node, &de->subdir); 603 de = next; 604 continue; 605 } 606 spin_unlock(&proc_subdir_lock); 607 608 proc_entry_rundown(de); 609 next = de->parent; 610 if (S_ISDIR(de->mode)) 611 next->nlink--; 612 de->nlink = 0; 613 if (de == root) 614 break; 615 pde_put(de); 616 617 spin_lock(&proc_subdir_lock); 618 de = next; 619 } 620 pde_put(root); 621 return 0; 622 } 623 EXPORT_SYMBOL(remove_proc_subtree); 624 625 void *proc_get_parent_data(const struct inode *inode) 626 { 627 struct proc_dir_entry *de = PDE(inode); 628 return de->parent->data; 629 } 630 EXPORT_SYMBOL_GPL(proc_get_parent_data); 631 632 void proc_remove(struct proc_dir_entry *de) 633 { 634 if (de) 635 remove_proc_subtree(de->name, de->parent); 636 } 637 EXPORT_SYMBOL(proc_remove); 638 639 void *PDE_DATA(const struct inode *inode) 640 { 641 return __PDE_DATA(inode); 642 } 643 EXPORT_SYMBOL(PDE_DATA); 644