1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * proc/fs/generic.c --- generic routines for the proc-fs 4 * 5 * This file contains generic proc-fs routines for handling 6 * directories and files. 7 * 8 * Copyright (C) 1991, 1992 Linus Torvalds. 9 * Copyright (C) 1997 Theodore Ts'o 10 */ 11 12 #include <linux/cache.h> 13 #include <linux/errno.h> 14 #include <linux/time.h> 15 #include <linux/proc_fs.h> 16 #include <linux/stat.h> 17 #include <linux/mm.h> 18 #include <linux/module.h> 19 #include <linux/namei.h> 20 #include <linux/slab.h> 21 #include <linux/printk.h> 22 #include <linux/mount.h> 23 #include <linux/init.h> 24 #include <linux/idr.h> 25 #include <linux/bitops.h> 26 #include <linux/spinlock.h> 27 #include <linux/completion.h> 28 #include <linux/uaccess.h> 29 #include <linux/seq_file.h> 30 31 #include "internal.h" 32 33 static DEFINE_RWLOCK(proc_subdir_lock); 34 35 struct kmem_cache *proc_dir_entry_cache __ro_after_init; 36 37 void pde_free(struct proc_dir_entry *pde) 38 { 39 if (S_ISLNK(pde->mode)) 40 kfree(pde->data); 41 if (pde->name != pde->inline_name) 42 kfree(pde->name); 43 kmem_cache_free(proc_dir_entry_cache, pde); 44 } 45 46 static int proc_match(const char *name, struct proc_dir_entry *de, unsigned int len) 47 { 48 if (len < de->namelen) 49 return -1; 50 if (len > de->namelen) 51 return 1; 52 53 return memcmp(name, de->name, len); 54 } 55 56 static struct proc_dir_entry *pde_subdir_first(struct proc_dir_entry *dir) 57 { 58 return rb_entry_safe(rb_first(&dir->subdir), struct proc_dir_entry, 59 subdir_node); 60 } 61 62 static struct proc_dir_entry *pde_subdir_next(struct proc_dir_entry *dir) 63 { 64 return rb_entry_safe(rb_next(&dir->subdir_node), struct proc_dir_entry, 65 subdir_node); 66 } 67 68 static struct proc_dir_entry *pde_subdir_find(struct proc_dir_entry *dir, 69 const char *name, 70 unsigned int len) 71 { 72 struct rb_node *node = dir->subdir.rb_node; 73 74 while (node) { 75 struct proc_dir_entry *de = rb_entry(node, 76 struct proc_dir_entry, 77 subdir_node); 78 int result = proc_match(name, de, len); 79 80 if (result < 0) 81 node = node->rb_left; 82 else if (result > 0) 83 node = node->rb_right; 84 else 85 return de; 86 } 87 return NULL; 88 } 89 90 static bool pde_subdir_insert(struct proc_dir_entry *dir, 91 struct proc_dir_entry *de) 92 { 93 struct rb_root *root = &dir->subdir; 94 struct rb_node **new = &root->rb_node, *parent = NULL; 95 96 /* Figure out where to put new node */ 97 while (*new) { 98 struct proc_dir_entry *this = rb_entry(*new, 99 struct proc_dir_entry, 100 subdir_node); 101 int result = proc_match(de->name, this, de->namelen); 102 103 parent = *new; 104 if (result < 0) 105 new = &(*new)->rb_left; 106 else if (result > 0) 107 new = &(*new)->rb_right; 108 else 109 return false; 110 } 111 112 /* Add new node and rebalance tree. */ 113 rb_link_node(&de->subdir_node, parent, new); 114 rb_insert_color(&de->subdir_node, root); 115 return true; 116 } 117 118 static int proc_notify_change(struct mnt_idmap *idmap, 119 struct dentry *dentry, struct iattr *iattr) 120 { 121 struct inode *inode = d_inode(dentry); 122 struct proc_dir_entry *de = PDE(inode); 123 int error; 124 125 error = setattr_prepare(&nop_mnt_idmap, dentry, iattr); 126 if (error) 127 return error; 128 129 setattr_copy(&nop_mnt_idmap, inode, iattr); 130 131 proc_set_user(de, inode->i_uid, inode->i_gid); 132 de->mode = inode->i_mode; 133 return 0; 134 } 135 136 static int proc_getattr(struct mnt_idmap *idmap, 137 const struct path *path, struct kstat *stat, 138 u32 request_mask, unsigned int query_flags) 139 { 140 struct inode *inode = d_inode(path->dentry); 141 struct proc_dir_entry *de = PDE(inode); 142 if (de) { 143 nlink_t nlink = READ_ONCE(de->nlink); 144 if (nlink > 0) { 145 set_nlink(inode, nlink); 146 } 147 } 148 149 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); 150 return 0; 151 } 152 153 static const struct inode_operations proc_file_inode_operations = { 154 .setattr = proc_notify_change, 155 }; 156 157 /* 158 * This function parses a name such as "tty/driver/serial", and 159 * returns the struct proc_dir_entry for "/proc/tty/driver", and 160 * returns "serial" in residual. 161 */ 162 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret, 163 const char **residual) 164 { 165 const char *cp = name, *next; 166 struct proc_dir_entry *de; 167 168 de = *ret ?: &proc_root; 169 while ((next = strchr(cp, '/')) != NULL) { 170 de = pde_subdir_find(de, cp, next - cp); 171 if (!de) { 172 WARN(1, "name '%s'\n", name); 173 return -ENOENT; 174 } 175 cp = next + 1; 176 } 177 *residual = cp; 178 *ret = de; 179 return 0; 180 } 181 182 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret, 183 const char **residual) 184 { 185 int rv; 186 187 read_lock(&proc_subdir_lock); 188 rv = __xlate_proc_name(name, ret, residual); 189 read_unlock(&proc_subdir_lock); 190 return rv; 191 } 192 193 static DEFINE_IDA(proc_inum_ida); 194 195 #define PROC_DYNAMIC_FIRST 0xF0000000U 196 197 /* 198 * Return an inode number between PROC_DYNAMIC_FIRST and 199 * 0xffffffff, or zero on failure. 200 */ 201 int proc_alloc_inum(unsigned int *inum) 202 { 203 int i; 204 205 i = ida_alloc_max(&proc_inum_ida, UINT_MAX - PROC_DYNAMIC_FIRST, 206 GFP_KERNEL); 207 if (i < 0) 208 return i; 209 210 *inum = PROC_DYNAMIC_FIRST + (unsigned int)i; 211 return 0; 212 } 213 214 void proc_free_inum(unsigned int inum) 215 { 216 ida_free(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST); 217 } 218 219 static int proc_misc_d_revalidate(struct inode *dir, const struct qstr *name, 220 struct dentry *dentry, unsigned int flags) 221 { 222 if (flags & LOOKUP_RCU) 223 return -ECHILD; 224 225 if (atomic_read(&PDE(d_inode(dentry))->in_use) < 0) 226 return 0; /* revalidate */ 227 return 1; 228 } 229 230 static int proc_misc_d_delete(const struct dentry *dentry) 231 { 232 return atomic_read(&PDE(d_inode(dentry))->in_use) < 0; 233 } 234 235 static const struct dentry_operations proc_misc_dentry_ops = { 236 .d_revalidate = proc_misc_d_revalidate, 237 .d_delete = proc_misc_d_delete, 238 }; 239 240 /* 241 * Don't create negative dentries here, return -ENOENT by hand 242 * instead. 243 */ 244 struct dentry *proc_lookup_de(struct inode *dir, struct dentry *dentry, 245 struct proc_dir_entry *de) 246 { 247 struct inode *inode; 248 249 read_lock(&proc_subdir_lock); 250 de = pde_subdir_find(de, dentry->d_name.name, dentry->d_name.len); 251 if (de) { 252 pde_get(de); 253 read_unlock(&proc_subdir_lock); 254 inode = proc_get_inode(dir->i_sb, de); 255 if (!inode) 256 return ERR_PTR(-ENOMEM); 257 if (de->flags & PROC_ENTRY_FORCE_LOOKUP) 258 return d_splice_alias_ops(inode, dentry, 259 &proc_net_dentry_ops); 260 return d_splice_alias_ops(inode, dentry, 261 &proc_misc_dentry_ops); 262 } 263 read_unlock(&proc_subdir_lock); 264 return ERR_PTR(-ENOENT); 265 } 266 267 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry, 268 unsigned int flags) 269 { 270 struct proc_fs_info *fs_info = proc_sb_info(dir->i_sb); 271 272 if (fs_info->pidonly == PROC_PIDONLY_ON) 273 return ERR_PTR(-ENOENT); 274 275 return proc_lookup_de(dir, dentry, PDE(dir)); 276 } 277 278 /* 279 * This returns non-zero if at EOF, so that the /proc 280 * root directory can use this and check if it should 281 * continue with the <pid> entries.. 282 * 283 * Note that the VFS-layer doesn't care about the return 284 * value of the readdir() call, as long as it's non-negative 285 * for success.. 286 */ 287 int proc_readdir_de(struct file *file, struct dir_context *ctx, 288 struct proc_dir_entry *de) 289 { 290 int i; 291 292 if (!dir_emit_dots(file, ctx)) 293 return 0; 294 295 i = ctx->pos - 2; 296 read_lock(&proc_subdir_lock); 297 de = pde_subdir_first(de); 298 for (;;) { 299 if (!de) { 300 read_unlock(&proc_subdir_lock); 301 return 0; 302 } 303 if (!i) 304 break; 305 de = pde_subdir_next(de); 306 i--; 307 } 308 309 do { 310 struct proc_dir_entry *next; 311 pde_get(de); 312 read_unlock(&proc_subdir_lock); 313 if (!dir_emit(ctx, de->name, de->namelen, 314 de->low_ino, de->mode >> 12)) { 315 pde_put(de); 316 return 0; 317 } 318 ctx->pos++; 319 read_lock(&proc_subdir_lock); 320 next = pde_subdir_next(de); 321 pde_put(de); 322 de = next; 323 } while (de); 324 read_unlock(&proc_subdir_lock); 325 return 1; 326 } 327 328 int proc_readdir(struct file *file, struct dir_context *ctx) 329 { 330 struct inode *inode = file_inode(file); 331 struct proc_fs_info *fs_info = proc_sb_info(inode->i_sb); 332 333 if (fs_info->pidonly == PROC_PIDONLY_ON) 334 return 1; 335 336 return proc_readdir_de(file, ctx, PDE(inode)); 337 } 338 339 /* 340 * These are the generic /proc directory operations. They 341 * use the in-memory "struct proc_dir_entry" tree to parse 342 * the /proc directory. 343 */ 344 static const struct file_operations proc_dir_operations = { 345 .llseek = generic_file_llseek, 346 .read = generic_read_dir, 347 .iterate_shared = proc_readdir, 348 }; 349 350 static int proc_net_d_revalidate(struct inode *dir, const struct qstr *name, 351 struct dentry *dentry, unsigned int flags) 352 { 353 return 0; 354 } 355 356 const struct dentry_operations proc_net_dentry_ops = { 357 .d_revalidate = proc_net_d_revalidate, 358 .d_delete = always_delete_dentry, 359 }; 360 361 /* 362 * proc directories can do almost nothing.. 363 */ 364 static const struct inode_operations proc_dir_inode_operations = { 365 .lookup = proc_lookup, 366 .getattr = proc_getattr, 367 .setattr = proc_notify_change, 368 }; 369 370 static void pde_set_flags(struct proc_dir_entry *pde) 371 { 372 const struct proc_ops *proc_ops = pde->proc_ops; 373 374 if (!proc_ops) 375 return; 376 377 if (proc_ops->proc_flags & PROC_ENTRY_PERMANENT) 378 pde->flags |= PROC_ENTRY_PERMANENT; 379 if (proc_ops->proc_read_iter) 380 pde->flags |= PROC_ENTRY_proc_read_iter; 381 #ifdef CONFIG_COMPAT 382 if (proc_ops->proc_compat_ioctl) 383 pde->flags |= PROC_ENTRY_proc_compat_ioctl; 384 #endif 385 if (proc_ops->proc_lseek) 386 pde->flags |= PROC_ENTRY_proc_lseek; 387 } 388 389 /* returns the registered entry, or frees dp and returns NULL on failure */ 390 struct proc_dir_entry *proc_register(struct proc_dir_entry *dir, 391 struct proc_dir_entry *dp) 392 { 393 if (proc_alloc_inum(&dp->low_ino)) 394 goto out_free_entry; 395 396 if (!S_ISDIR(dp->mode)) 397 pde_set_flags(dp); 398 399 write_lock(&proc_subdir_lock); 400 dp->parent = dir; 401 if (pde_subdir_insert(dir, dp) == false) { 402 WARN(1, "proc_dir_entry '%s/%s' already registered\n", 403 dir->name, dp->name); 404 write_unlock(&proc_subdir_lock); 405 goto out_free_inum; 406 } 407 dir->nlink++; 408 write_unlock(&proc_subdir_lock); 409 410 return dp; 411 out_free_inum: 412 proc_free_inum(dp->low_ino); 413 out_free_entry: 414 pde_free(dp); 415 return NULL; 416 } 417 418 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent, 419 const char *name, 420 umode_t mode, 421 nlink_t nlink) 422 { 423 struct proc_dir_entry *ent = NULL; 424 const char *fn; 425 struct qstr qstr; 426 427 if (xlate_proc_name(name, parent, &fn) != 0) 428 goto out; 429 qstr.name = fn; 430 qstr.len = strlen(fn); 431 if (qstr.len == 0 || qstr.len >= 256) { 432 WARN(1, "name len %u\n", qstr.len); 433 return NULL; 434 } 435 if (qstr.len == 1 && fn[0] == '.') { 436 WARN(1, "name '.'\n"); 437 return NULL; 438 } 439 if (qstr.len == 2 && fn[0] == '.' && fn[1] == '.') { 440 WARN(1, "name '..'\n"); 441 return NULL; 442 } 443 if (*parent == &proc_root && name_to_int(&qstr) != ~0U) { 444 WARN(1, "create '/proc/%s' by hand\n", qstr.name); 445 return NULL; 446 } 447 if (is_empty_pde(*parent)) { 448 WARN(1, "attempt to add to permanently empty directory"); 449 return NULL; 450 } 451 452 ent = kmem_cache_zalloc(proc_dir_entry_cache, GFP_KERNEL); 453 if (!ent) 454 goto out; 455 456 if (qstr.len + 1 <= SIZEOF_PDE_INLINE_NAME) { 457 ent->name = ent->inline_name; 458 } else { 459 ent->name = kmalloc(qstr.len + 1, GFP_KERNEL); 460 if (!ent->name) { 461 pde_free(ent); 462 return NULL; 463 } 464 } 465 466 memcpy(ent->name, fn, qstr.len + 1); 467 ent->namelen = qstr.len; 468 ent->mode = mode; 469 ent->nlink = nlink; 470 ent->subdir = RB_ROOT; 471 refcount_set(&ent->refcnt, 1); 472 spin_lock_init(&ent->pde_unload_lock); 473 INIT_LIST_HEAD(&ent->pde_openers); 474 proc_set_user(ent, (*parent)->uid, (*parent)->gid); 475 476 /* Revalidate everything under /proc/${pid}/net */ 477 if ((*parent)->flags & PROC_ENTRY_FORCE_LOOKUP) 478 pde_force_lookup(ent); 479 480 out: 481 return ent; 482 } 483 484 struct proc_dir_entry *proc_symlink(const char *name, 485 struct proc_dir_entry *parent, const char *dest) 486 { 487 struct proc_dir_entry *ent; 488 489 ent = __proc_create(&parent, name, 490 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1); 491 492 if (ent) { 493 ent->size = strlen(dest); 494 ent->data = kmemdup(dest, ent->size + 1, GFP_KERNEL); 495 if (ent->data) { 496 ent->proc_iops = &proc_link_inode_operations; 497 ent = proc_register(parent, ent); 498 } else { 499 pde_free(ent); 500 ent = NULL; 501 } 502 } 503 return ent; 504 } 505 EXPORT_SYMBOL(proc_symlink); 506 507 struct proc_dir_entry *_proc_mkdir(const char *name, umode_t mode, 508 struct proc_dir_entry *parent, void *data, bool force_lookup) 509 { 510 struct proc_dir_entry *ent; 511 512 if (mode == 0) 513 mode = S_IRUGO | S_IXUGO; 514 515 ent = __proc_create(&parent, name, S_IFDIR | mode, 2); 516 if (ent) { 517 ent->data = data; 518 ent->proc_dir_ops = &proc_dir_operations; 519 ent->proc_iops = &proc_dir_inode_operations; 520 if (force_lookup) { 521 pde_force_lookup(ent); 522 } 523 ent = proc_register(parent, ent); 524 } 525 return ent; 526 } 527 EXPORT_SYMBOL_GPL(_proc_mkdir); 528 529 struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode, 530 struct proc_dir_entry *parent, void *data) 531 { 532 return _proc_mkdir(name, mode, parent, data, false); 533 } 534 EXPORT_SYMBOL_GPL(proc_mkdir_data); 535 536 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode, 537 struct proc_dir_entry *parent) 538 { 539 return proc_mkdir_data(name, mode, parent, NULL); 540 } 541 EXPORT_SYMBOL(proc_mkdir_mode); 542 543 struct proc_dir_entry *proc_mkdir(const char *name, 544 struct proc_dir_entry *parent) 545 { 546 return proc_mkdir_data(name, 0, parent, NULL); 547 } 548 EXPORT_SYMBOL(proc_mkdir); 549 550 struct proc_dir_entry *proc_create_mount_point(const char *name) 551 { 552 umode_t mode = S_IFDIR | S_IRUGO | S_IXUGO; 553 struct proc_dir_entry *ent, *parent = NULL; 554 555 ent = __proc_create(&parent, name, mode, 2); 556 if (ent) { 557 ent->data = NULL; 558 ent->proc_dir_ops = NULL; 559 ent->proc_iops = NULL; 560 ent = proc_register(parent, ent); 561 } 562 return ent; 563 } 564 EXPORT_SYMBOL(proc_create_mount_point); 565 566 struct proc_dir_entry *proc_create_reg(const char *name, umode_t mode, 567 struct proc_dir_entry **parent, void *data) 568 { 569 struct proc_dir_entry *p; 570 571 if ((mode & S_IFMT) == 0) 572 mode |= S_IFREG; 573 if ((mode & S_IALLUGO) == 0) 574 mode |= S_IRUGO; 575 if (WARN_ON_ONCE(!S_ISREG(mode))) 576 return NULL; 577 578 p = __proc_create(parent, name, mode, 1); 579 if (p) { 580 p->proc_iops = &proc_file_inode_operations; 581 p->data = data; 582 } 583 return p; 584 } 585 586 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode, 587 struct proc_dir_entry *parent, 588 const struct proc_ops *proc_ops, void *data) 589 { 590 struct proc_dir_entry *p; 591 592 p = proc_create_reg(name, mode, &parent, data); 593 if (!p) 594 return NULL; 595 p->proc_ops = proc_ops; 596 return proc_register(parent, p); 597 } 598 EXPORT_SYMBOL(proc_create_data); 599 600 struct proc_dir_entry *proc_create(const char *name, umode_t mode, 601 struct proc_dir_entry *parent, 602 const struct proc_ops *proc_ops) 603 { 604 return proc_create_data(name, mode, parent, proc_ops, NULL); 605 } 606 EXPORT_SYMBOL(proc_create); 607 608 static int proc_seq_open(struct inode *inode, struct file *file) 609 { 610 struct proc_dir_entry *de = PDE(inode); 611 612 if (de->state_size) 613 return seq_open_private(file, de->seq_ops, de->state_size); 614 return seq_open(file, de->seq_ops); 615 } 616 617 static int proc_seq_release(struct inode *inode, struct file *file) 618 { 619 struct proc_dir_entry *de = PDE(inode); 620 621 if (de->state_size) 622 return seq_release_private(inode, file); 623 return seq_release(inode, file); 624 } 625 626 static const struct proc_ops proc_seq_ops = { 627 /* not permanent -- can call into arbitrary seq_operations */ 628 .proc_open = proc_seq_open, 629 .proc_read_iter = seq_read_iter, 630 .proc_lseek = seq_lseek, 631 .proc_release = proc_seq_release, 632 }; 633 634 struct proc_dir_entry *proc_create_seq_private(const char *name, umode_t mode, 635 struct proc_dir_entry *parent, const struct seq_operations *ops, 636 unsigned int state_size, void *data) 637 { 638 struct proc_dir_entry *p; 639 640 p = proc_create_reg(name, mode, &parent, data); 641 if (!p) 642 return NULL; 643 p->proc_ops = &proc_seq_ops; 644 p->seq_ops = ops; 645 p->state_size = state_size; 646 return proc_register(parent, p); 647 } 648 EXPORT_SYMBOL(proc_create_seq_private); 649 650 static int proc_single_open(struct inode *inode, struct file *file) 651 { 652 struct proc_dir_entry *de = PDE(inode); 653 654 return single_open(file, de->single_show, de->data); 655 } 656 657 static const struct proc_ops proc_single_ops = { 658 /* not permanent -- can call into arbitrary ->single_show */ 659 .proc_open = proc_single_open, 660 .proc_read_iter = seq_read_iter, 661 .proc_lseek = seq_lseek, 662 .proc_release = single_release, 663 }; 664 665 struct proc_dir_entry *proc_create_single_data(const char *name, umode_t mode, 666 struct proc_dir_entry *parent, 667 int (*show)(struct seq_file *, void *), void *data) 668 { 669 struct proc_dir_entry *p; 670 671 p = proc_create_reg(name, mode, &parent, data); 672 if (!p) 673 return NULL; 674 p->proc_ops = &proc_single_ops; 675 p->single_show = show; 676 return proc_register(parent, p); 677 } 678 EXPORT_SYMBOL(proc_create_single_data); 679 680 void proc_set_size(struct proc_dir_entry *de, loff_t size) 681 { 682 de->size = size; 683 } 684 EXPORT_SYMBOL(proc_set_size); 685 686 void proc_set_user(struct proc_dir_entry *de, kuid_t uid, kgid_t gid) 687 { 688 de->uid = uid; 689 de->gid = gid; 690 } 691 EXPORT_SYMBOL(proc_set_user); 692 693 void pde_put(struct proc_dir_entry *pde) 694 { 695 if (refcount_dec_and_test(&pde->refcnt)) { 696 proc_free_inum(pde->low_ino); 697 pde_free(pde); 698 } 699 } 700 701 /* 702 * Remove a /proc entry and free it if it's not currently in use. 703 */ 704 void remove_proc_entry(const char *name, struct proc_dir_entry *parent) 705 { 706 struct proc_dir_entry *de = NULL; 707 const char *fn = name; 708 unsigned int len; 709 710 write_lock(&proc_subdir_lock); 711 if (__xlate_proc_name(name, &parent, &fn) != 0) { 712 write_unlock(&proc_subdir_lock); 713 return; 714 } 715 len = strlen(fn); 716 717 de = pde_subdir_find(parent, fn, len); 718 if (de) { 719 if (unlikely(pde_is_permanent(de))) { 720 WARN(1, "removing permanent /proc entry '%s'", de->name); 721 de = NULL; 722 } else { 723 rb_erase(&de->subdir_node, &parent->subdir); 724 if (S_ISDIR(de->mode)) 725 parent->nlink--; 726 } 727 } 728 write_unlock(&proc_subdir_lock); 729 if (!de) { 730 WARN(1, "name '%s'\n", name); 731 return; 732 } 733 734 proc_entry_rundown(de); 735 736 WARN(pde_subdir_first(de), 737 "%s: removing non-empty directory '%s/%s', leaking at least '%s'\n", 738 __func__, de->parent->name, de->name, pde_subdir_first(de)->name); 739 pde_put(de); 740 } 741 EXPORT_SYMBOL(remove_proc_entry); 742 743 int remove_proc_subtree(const char *name, struct proc_dir_entry *parent) 744 { 745 struct proc_dir_entry *root = NULL, *de, *next; 746 const char *fn = name; 747 unsigned int len; 748 749 write_lock(&proc_subdir_lock); 750 if (__xlate_proc_name(name, &parent, &fn) != 0) { 751 write_unlock(&proc_subdir_lock); 752 return -ENOENT; 753 } 754 len = strlen(fn); 755 756 root = pde_subdir_find(parent, fn, len); 757 if (!root) { 758 write_unlock(&proc_subdir_lock); 759 return -ENOENT; 760 } 761 if (unlikely(pde_is_permanent(root))) { 762 write_unlock(&proc_subdir_lock); 763 WARN(1, "removing permanent /proc entry '%s/%s'", 764 root->parent->name, root->name); 765 return -EINVAL; 766 } 767 rb_erase(&root->subdir_node, &parent->subdir); 768 769 de = root; 770 while (1) { 771 next = pde_subdir_first(de); 772 if (next) { 773 if (unlikely(pde_is_permanent(next))) { 774 write_unlock(&proc_subdir_lock); 775 WARN(1, "removing permanent /proc entry '%s/%s'", 776 next->parent->name, next->name); 777 return -EINVAL; 778 } 779 rb_erase(&next->subdir_node, &de->subdir); 780 de = next; 781 continue; 782 } 783 next = de->parent; 784 if (S_ISDIR(de->mode)) 785 next->nlink--; 786 write_unlock(&proc_subdir_lock); 787 788 proc_entry_rundown(de); 789 if (de == root) 790 break; 791 pde_put(de); 792 793 write_lock(&proc_subdir_lock); 794 de = next; 795 } 796 pde_put(root); 797 return 0; 798 } 799 EXPORT_SYMBOL(remove_proc_subtree); 800 801 void *proc_get_parent_data(const struct inode *inode) 802 { 803 struct proc_dir_entry *de = PDE(inode); 804 return de->parent->data; 805 } 806 EXPORT_SYMBOL_GPL(proc_get_parent_data); 807 808 void proc_remove(struct proc_dir_entry *de) 809 { 810 if (de) 811 remove_proc_subtree(de->name, de->parent); 812 } 813 EXPORT_SYMBOL(proc_remove); 814 815 /* 816 * Pull a user buffer into memory and pass it to the file's write handler if 817 * one is supplied. The ->write() method is permitted to modify the 818 * kernel-side buffer. 819 */ 820 ssize_t proc_simple_write(struct file *f, const char __user *ubuf, size_t size, 821 loff_t *_pos) 822 { 823 struct proc_dir_entry *pde = PDE(file_inode(f)); 824 char *buf; 825 int ret; 826 827 if (!pde->write) 828 return -EACCES; 829 if (size == 0 || size > PAGE_SIZE - 1) 830 return -EINVAL; 831 buf = memdup_user_nul(ubuf, size); 832 if (IS_ERR(buf)) 833 return PTR_ERR(buf); 834 ret = pde->write(f, buf, size); 835 kfree(buf); 836 return ret == 0 ? size : ret; 837 } 838