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); 633