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/mount.h> 19 #include <linux/init.h> 20 #include <linux/idr.h> 21 #include <linux/namei.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 29 DEFINE_SPINLOCK(proc_subdir_lock); 30 31 static int proc_match(unsigned int len, const char *name, struct proc_dir_entry *de) 32 { 33 if (de->namelen != len) 34 return 0; 35 return !memcmp(name, de->name, len); 36 } 37 38 /* buffer size is one page but our output routines use some slack for overruns */ 39 #define PROC_BLOCK_SIZE (PAGE_SIZE - 1024) 40 41 static ssize_t 42 __proc_file_read(struct file *file, char __user *buf, size_t nbytes, 43 loff_t *ppos) 44 { 45 struct inode * inode = file->f_path.dentry->d_inode; 46 char *page; 47 ssize_t retval=0; 48 int eof=0; 49 ssize_t n, count; 50 char *start; 51 struct proc_dir_entry * dp; 52 unsigned long long pos; 53 54 /* 55 * Gaah, please just use "seq_file" instead. The legacy /proc 56 * interfaces cut loff_t down to off_t for reads, and ignore 57 * the offset entirely for writes.. 58 */ 59 pos = *ppos; 60 if (pos > MAX_NON_LFS) 61 return 0; 62 if (nbytes > MAX_NON_LFS - pos) 63 nbytes = MAX_NON_LFS - pos; 64 65 dp = PDE(inode); 66 if (!(page = (char*) __get_free_page(GFP_TEMPORARY))) 67 return -ENOMEM; 68 69 while ((nbytes > 0) && !eof) { 70 count = min_t(size_t, PROC_BLOCK_SIZE, nbytes); 71 72 start = NULL; 73 if (dp->read_proc) { 74 /* 75 * How to be a proc read function 76 * ------------------------------ 77 * Prototype: 78 * int f(char *buffer, char **start, off_t offset, 79 * int count, int *peof, void *dat) 80 * 81 * Assume that the buffer is "count" bytes in size. 82 * 83 * If you know you have supplied all the data you 84 * have, set *peof. 85 * 86 * You have three ways to return data: 87 * 0) Leave *start = NULL. (This is the default.) 88 * Put the data of the requested offset at that 89 * offset within the buffer. Return the number (n) 90 * of bytes there are from the beginning of the 91 * buffer up to the last byte of data. If the 92 * number of supplied bytes (= n - offset) is 93 * greater than zero and you didn't signal eof 94 * and the reader is prepared to take more data 95 * you will be called again with the requested 96 * offset advanced by the number of bytes 97 * absorbed. This interface is useful for files 98 * no larger than the buffer. 99 * 1) Set *start = an unsigned long value less than 100 * the buffer address but greater than zero. 101 * Put the data of the requested offset at the 102 * beginning of the buffer. Return the number of 103 * bytes of data placed there. If this number is 104 * greater than zero and you didn't signal eof 105 * and the reader is prepared to take more data 106 * you will be called again with the requested 107 * offset advanced by *start. This interface is 108 * useful when you have a large file consisting 109 * of a series of blocks which you want to count 110 * and return as wholes. 111 * (Hack by Paul.Russell@rustcorp.com.au) 112 * 2) Set *start = an address within the buffer. 113 * Put the data of the requested offset at *start. 114 * Return the number of bytes of data placed there. 115 * If this number is greater than zero and you 116 * didn't signal eof and the reader is prepared to 117 * take more data you will be called again with the 118 * requested offset advanced by the number of bytes 119 * absorbed. 120 */ 121 n = dp->read_proc(page, &start, *ppos, 122 count, &eof, dp->data); 123 } else 124 break; 125 126 if (n == 0) /* end of file */ 127 break; 128 if (n < 0) { /* error */ 129 if (retval == 0) 130 retval = n; 131 break; 132 } 133 134 if (start == NULL) { 135 if (n > PAGE_SIZE) { 136 printk(KERN_ERR 137 "proc_file_read: Apparent buffer overflow!\n"); 138 n = PAGE_SIZE; 139 } 140 n -= *ppos; 141 if (n <= 0) 142 break; 143 if (n > count) 144 n = count; 145 start = page + *ppos; 146 } else if (start < page) { 147 if (n > PAGE_SIZE) { 148 printk(KERN_ERR 149 "proc_file_read: Apparent buffer overflow!\n"); 150 n = PAGE_SIZE; 151 } 152 if (n > count) { 153 /* 154 * Don't reduce n because doing so might 155 * cut off part of a data block. 156 */ 157 printk(KERN_WARNING 158 "proc_file_read: Read count exceeded\n"); 159 } 160 } else /* start >= page */ { 161 unsigned long startoff = (unsigned long)(start - page); 162 if (n > (PAGE_SIZE - startoff)) { 163 printk(KERN_ERR 164 "proc_file_read: Apparent buffer overflow!\n"); 165 n = PAGE_SIZE - startoff; 166 } 167 if (n > count) 168 n = count; 169 } 170 171 n -= copy_to_user(buf, start < page ? page : start, n); 172 if (n == 0) { 173 if (retval == 0) 174 retval = -EFAULT; 175 break; 176 } 177 178 *ppos += start < page ? (unsigned long)start : n; 179 nbytes -= n; 180 buf += n; 181 retval += n; 182 } 183 free_page((unsigned long) page); 184 return retval; 185 } 186 187 static ssize_t 188 proc_file_read(struct file *file, char __user *buf, size_t nbytes, 189 loff_t *ppos) 190 { 191 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 192 ssize_t rv = -EIO; 193 194 spin_lock(&pde->pde_unload_lock); 195 if (!pde->proc_fops) { 196 spin_unlock(&pde->pde_unload_lock); 197 return rv; 198 } 199 pde->pde_users++; 200 spin_unlock(&pde->pde_unload_lock); 201 202 rv = __proc_file_read(file, buf, nbytes, ppos); 203 204 pde_users_dec(pde); 205 return rv; 206 } 207 208 static ssize_t 209 proc_file_write(struct file *file, const char __user *buffer, 210 size_t count, loff_t *ppos) 211 { 212 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode); 213 ssize_t rv = -EIO; 214 215 if (pde->write_proc) { 216 spin_lock(&pde->pde_unload_lock); 217 if (!pde->proc_fops) { 218 spin_unlock(&pde->pde_unload_lock); 219 return rv; 220 } 221 pde->pde_users++; 222 spin_unlock(&pde->pde_unload_lock); 223 224 /* FIXME: does this routine need ppos? probably... */ 225 rv = pde->write_proc(file, buffer, count, pde->data); 226 pde_users_dec(pde); 227 } 228 return rv; 229 } 230 231 232 static loff_t 233 proc_file_lseek(struct file *file, loff_t offset, int orig) 234 { 235 loff_t retval = -EINVAL; 236 switch (orig) { 237 case 1: 238 offset += file->f_pos; 239 /* fallthrough */ 240 case 0: 241 if (offset < 0 || offset > MAX_NON_LFS) 242 break; 243 file->f_pos = retval = offset; 244 } 245 return retval; 246 } 247 248 static const struct file_operations proc_file_operations = { 249 .llseek = proc_file_lseek, 250 .read = proc_file_read, 251 .write = proc_file_write, 252 }; 253 254 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr) 255 { 256 struct inode *inode = dentry->d_inode; 257 struct proc_dir_entry *de = PDE(inode); 258 int error; 259 260 error = inode_change_ok(inode, iattr); 261 if (error) 262 return error; 263 264 setattr_copy(inode, iattr); 265 mark_inode_dirty(inode); 266 267 de->uid = inode->i_uid; 268 de->gid = inode->i_gid; 269 de->mode = inode->i_mode; 270 return 0; 271 } 272 273 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry, 274 struct kstat *stat) 275 { 276 struct inode *inode = dentry->d_inode; 277 struct proc_dir_entry *de = PROC_I(inode)->pde; 278 if (de && de->nlink) 279 set_nlink(inode, de->nlink); 280 281 generic_fillattr(inode, stat); 282 return 0; 283 } 284 285 static const struct inode_operations proc_file_inode_operations = { 286 .setattr = proc_notify_change, 287 }; 288 289 /* 290 * This function parses a name such as "tty/driver/serial", and 291 * returns the struct proc_dir_entry for "/proc/tty/driver", and 292 * returns "serial" in residual. 293 */ 294 static int __xlate_proc_name(const char *name, struct proc_dir_entry **ret, 295 const char **residual) 296 { 297 const char *cp = name, *next; 298 struct proc_dir_entry *de; 299 unsigned int len; 300 301 de = *ret; 302 if (!de) 303 de = &proc_root; 304 305 while (1) { 306 next = strchr(cp, '/'); 307 if (!next) 308 break; 309 310 len = next - cp; 311 for (de = de->subdir; de ; de = de->next) { 312 if (proc_match(len, cp, de)) 313 break; 314 } 315 if (!de) { 316 WARN(1, "name '%s'\n", name); 317 return -ENOENT; 318 } 319 cp += len + 1; 320 } 321 *residual = cp; 322 *ret = de; 323 return 0; 324 } 325 326 static int xlate_proc_name(const char *name, struct proc_dir_entry **ret, 327 const char **residual) 328 { 329 int rv; 330 331 spin_lock(&proc_subdir_lock); 332 rv = __xlate_proc_name(name, ret, residual); 333 spin_unlock(&proc_subdir_lock); 334 return rv; 335 } 336 337 static DEFINE_IDA(proc_inum_ida); 338 static DEFINE_SPINLOCK(proc_inum_lock); /* protects the above */ 339 340 #define PROC_DYNAMIC_FIRST 0xF0000000U 341 342 /* 343 * Return an inode number between PROC_DYNAMIC_FIRST and 344 * 0xffffffff, or zero on failure. 345 */ 346 int proc_alloc_inum(unsigned int *inum) 347 { 348 unsigned int i; 349 int error; 350 351 retry: 352 if (!ida_pre_get(&proc_inum_ida, GFP_KERNEL)) 353 return -ENOMEM; 354 355 spin_lock_irq(&proc_inum_lock); 356 error = ida_get_new(&proc_inum_ida, &i); 357 spin_unlock_irq(&proc_inum_lock); 358 if (error == -EAGAIN) 359 goto retry; 360 else if (error) 361 return error; 362 363 if (i > UINT_MAX - PROC_DYNAMIC_FIRST) { 364 spin_lock_irq(&proc_inum_lock); 365 ida_remove(&proc_inum_ida, i); 366 spin_unlock_irq(&proc_inum_lock); 367 return -ENOSPC; 368 } 369 *inum = PROC_DYNAMIC_FIRST + i; 370 return 0; 371 } 372 373 void proc_free_inum(unsigned int inum) 374 { 375 unsigned long flags; 376 spin_lock_irqsave(&proc_inum_lock, flags); 377 ida_remove(&proc_inum_ida, inum - PROC_DYNAMIC_FIRST); 378 spin_unlock_irqrestore(&proc_inum_lock, flags); 379 } 380 381 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd) 382 { 383 nd_set_link(nd, PDE(dentry->d_inode)->data); 384 return NULL; 385 } 386 387 static const struct inode_operations proc_link_inode_operations = { 388 .readlink = generic_readlink, 389 .follow_link = proc_follow_link, 390 }; 391 392 /* 393 * As some entries in /proc are volatile, we want to 394 * get rid of unused dentries. This could be made 395 * smarter: we could keep a "volatile" flag in the 396 * inode to indicate which ones to keep. 397 */ 398 static int proc_delete_dentry(const struct dentry * dentry) 399 { 400 return 1; 401 } 402 403 static const struct dentry_operations proc_dentry_operations = 404 { 405 .d_delete = proc_delete_dentry, 406 }; 407 408 /* 409 * Don't create negative dentries here, return -ENOENT by hand 410 * instead. 411 */ 412 struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir, 413 struct dentry *dentry) 414 { 415 struct inode *inode = NULL; 416 int error = -ENOENT; 417 418 spin_lock(&proc_subdir_lock); 419 for (de = de->subdir; de ; de = de->next) { 420 if (de->namelen != dentry->d_name.len) 421 continue; 422 if (!memcmp(dentry->d_name.name, de->name, de->namelen)) { 423 pde_get(de); 424 spin_unlock(&proc_subdir_lock); 425 error = -ENOMEM; 426 inode = proc_get_inode(dir->i_sb, de); 427 goto out_unlock; 428 } 429 } 430 spin_unlock(&proc_subdir_lock); 431 out_unlock: 432 433 if (inode) { 434 d_set_d_op(dentry, &proc_dentry_operations); 435 d_add(dentry, inode); 436 return NULL; 437 } 438 if (de) 439 pde_put(de); 440 return ERR_PTR(error); 441 } 442 443 struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry, 444 unsigned int flags) 445 { 446 return proc_lookup_de(PDE(dir), dir, dentry); 447 } 448 449 /* 450 * This returns non-zero if at EOF, so that the /proc 451 * root directory can use this and check if it should 452 * continue with the <pid> entries.. 453 * 454 * Note that the VFS-layer doesn't care about the return 455 * value of the readdir() call, as long as it's non-negative 456 * for success.. 457 */ 458 int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent, 459 filldir_t filldir) 460 { 461 unsigned int ino; 462 int i; 463 struct inode *inode = filp->f_path.dentry->d_inode; 464 int ret = 0; 465 466 ino = inode->i_ino; 467 i = filp->f_pos; 468 switch (i) { 469 case 0: 470 if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0) 471 goto out; 472 i++; 473 filp->f_pos++; 474 /* fall through */ 475 case 1: 476 if (filldir(dirent, "..", 2, i, 477 parent_ino(filp->f_path.dentry), 478 DT_DIR) < 0) 479 goto out; 480 i++; 481 filp->f_pos++; 482 /* fall through */ 483 default: 484 spin_lock(&proc_subdir_lock); 485 de = de->subdir; 486 i -= 2; 487 for (;;) { 488 if (!de) { 489 ret = 1; 490 spin_unlock(&proc_subdir_lock); 491 goto out; 492 } 493 if (!i) 494 break; 495 de = de->next; 496 i--; 497 } 498 499 do { 500 struct proc_dir_entry *next; 501 502 /* filldir passes info to user space */ 503 pde_get(de); 504 spin_unlock(&proc_subdir_lock); 505 if (filldir(dirent, de->name, de->namelen, filp->f_pos, 506 de->low_ino, de->mode >> 12) < 0) { 507 pde_put(de); 508 goto out; 509 } 510 spin_lock(&proc_subdir_lock); 511 filp->f_pos++; 512 next = de->next; 513 pde_put(de); 514 de = next; 515 } while (de); 516 spin_unlock(&proc_subdir_lock); 517 } 518 ret = 1; 519 out: 520 return ret; 521 } 522 523 int proc_readdir(struct file *filp, void *dirent, filldir_t filldir) 524 { 525 struct inode *inode = filp->f_path.dentry->d_inode; 526 527 return proc_readdir_de(PDE(inode), filp, dirent, filldir); 528 } 529 530 /* 531 * These are the generic /proc directory operations. They 532 * use the in-memory "struct proc_dir_entry" tree to parse 533 * the /proc directory. 534 */ 535 static const struct file_operations proc_dir_operations = { 536 .llseek = generic_file_llseek, 537 .read = generic_read_dir, 538 .readdir = proc_readdir, 539 }; 540 541 /* 542 * proc directories can do almost nothing.. 543 */ 544 static const struct inode_operations proc_dir_inode_operations = { 545 .lookup = proc_lookup, 546 .getattr = proc_getattr, 547 .setattr = proc_notify_change, 548 }; 549 550 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp) 551 { 552 struct proc_dir_entry *tmp; 553 int ret; 554 555 ret = proc_alloc_inum(&dp->low_ino); 556 if (ret) 557 return ret; 558 559 if (S_ISDIR(dp->mode)) { 560 if (dp->proc_iops == NULL) { 561 dp->proc_fops = &proc_dir_operations; 562 dp->proc_iops = &proc_dir_inode_operations; 563 } 564 dir->nlink++; 565 } else if (S_ISLNK(dp->mode)) { 566 if (dp->proc_iops == NULL) 567 dp->proc_iops = &proc_link_inode_operations; 568 } else if (S_ISREG(dp->mode)) { 569 if (dp->proc_fops == NULL) 570 dp->proc_fops = &proc_file_operations; 571 if (dp->proc_iops == NULL) 572 dp->proc_iops = &proc_file_inode_operations; 573 } 574 575 spin_lock(&proc_subdir_lock); 576 577 for (tmp = dir->subdir; tmp; tmp = tmp->next) 578 if (strcmp(tmp->name, dp->name) == 0) { 579 WARN(1, KERN_WARNING "proc_dir_entry '%s/%s' already registered\n", 580 dir->name, dp->name); 581 break; 582 } 583 584 dp->next = dir->subdir; 585 dp->parent = dir; 586 dir->subdir = dp; 587 spin_unlock(&proc_subdir_lock); 588 589 return 0; 590 } 591 592 static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent, 593 const char *name, 594 umode_t mode, 595 nlink_t nlink) 596 { 597 struct proc_dir_entry *ent = NULL; 598 const char *fn = name; 599 unsigned int len; 600 601 /* make sure name is valid */ 602 if (!name || !strlen(name)) 603 goto out; 604 605 if (xlate_proc_name(name, parent, &fn) != 0) 606 goto out; 607 608 /* At this point there must not be any '/' characters beyond *fn */ 609 if (strchr(fn, '/')) 610 goto out; 611 612 len = strlen(fn); 613 614 ent = kzalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL); 615 if (!ent) 616 goto out; 617 618 memcpy(ent->name, fn, len + 1); 619 ent->namelen = len; 620 ent->mode = mode; 621 ent->nlink = nlink; 622 atomic_set(&ent->count, 1); 623 spin_lock_init(&ent->pde_unload_lock); 624 INIT_LIST_HEAD(&ent->pde_openers); 625 out: 626 return ent; 627 } 628 629 struct proc_dir_entry *proc_symlink(const char *name, 630 struct proc_dir_entry *parent, const char *dest) 631 { 632 struct proc_dir_entry *ent; 633 634 ent = __proc_create(&parent, name, 635 (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1); 636 637 if (ent) { 638 ent->data = kmalloc((ent->size=strlen(dest))+1, GFP_KERNEL); 639 if (ent->data) { 640 strcpy((char*)ent->data,dest); 641 if (proc_register(parent, ent) < 0) { 642 kfree(ent->data); 643 kfree(ent); 644 ent = NULL; 645 } 646 } else { 647 kfree(ent); 648 ent = NULL; 649 } 650 } 651 return ent; 652 } 653 EXPORT_SYMBOL(proc_symlink); 654 655 struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode, 656 struct proc_dir_entry *parent) 657 { 658 struct proc_dir_entry *ent; 659 660 ent = __proc_create(&parent, name, S_IFDIR | mode, 2); 661 if (ent) { 662 if (proc_register(parent, ent) < 0) { 663 kfree(ent); 664 ent = NULL; 665 } 666 } 667 return ent; 668 } 669 EXPORT_SYMBOL(proc_mkdir_mode); 670 671 struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name, 672 struct proc_dir_entry *parent) 673 { 674 struct proc_dir_entry *ent; 675 676 ent = __proc_create(&parent, name, S_IFDIR | S_IRUGO | S_IXUGO, 2); 677 if (ent) { 678 ent->data = net; 679 if (proc_register(parent, ent) < 0) { 680 kfree(ent); 681 ent = NULL; 682 } 683 } 684 return ent; 685 } 686 EXPORT_SYMBOL_GPL(proc_net_mkdir); 687 688 struct proc_dir_entry *proc_mkdir(const char *name, 689 struct proc_dir_entry *parent) 690 { 691 return proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent); 692 } 693 EXPORT_SYMBOL(proc_mkdir); 694 695 struct proc_dir_entry *create_proc_entry(const char *name, umode_t mode, 696 struct proc_dir_entry *parent) 697 { 698 struct proc_dir_entry *ent; 699 nlink_t nlink; 700 701 if (S_ISDIR(mode)) { 702 if ((mode & S_IALLUGO) == 0) 703 mode |= S_IRUGO | S_IXUGO; 704 nlink = 2; 705 } else { 706 if ((mode & S_IFMT) == 0) 707 mode |= S_IFREG; 708 if ((mode & S_IALLUGO) == 0) 709 mode |= S_IRUGO; 710 nlink = 1; 711 } 712 713 ent = __proc_create(&parent, name, mode, nlink); 714 if (ent) { 715 if (proc_register(parent, ent) < 0) { 716 kfree(ent); 717 ent = NULL; 718 } 719 } 720 return ent; 721 } 722 EXPORT_SYMBOL(create_proc_entry); 723 724 struct proc_dir_entry *proc_create_data(const char *name, umode_t mode, 725 struct proc_dir_entry *parent, 726 const struct file_operations *proc_fops, 727 void *data) 728 { 729 struct proc_dir_entry *pde; 730 nlink_t nlink; 731 732 if (S_ISDIR(mode)) { 733 if ((mode & S_IALLUGO) == 0) 734 mode |= S_IRUGO | S_IXUGO; 735 nlink = 2; 736 } else { 737 if ((mode & S_IFMT) == 0) 738 mode |= S_IFREG; 739 if ((mode & S_IALLUGO) == 0) 740 mode |= S_IRUGO; 741 nlink = 1; 742 } 743 744 pde = __proc_create(&parent, name, mode, nlink); 745 if (!pde) 746 goto out; 747 pde->proc_fops = proc_fops; 748 pde->data = data; 749 if (proc_register(parent, pde) < 0) 750 goto out_free; 751 return pde; 752 out_free: 753 kfree(pde); 754 out: 755 return NULL; 756 } 757 EXPORT_SYMBOL(proc_create_data); 758 759 static void free_proc_entry(struct proc_dir_entry *de) 760 { 761 proc_free_inum(de->low_ino); 762 763 if (S_ISLNK(de->mode)) 764 kfree(de->data); 765 kfree(de); 766 } 767 768 void pde_put(struct proc_dir_entry *pde) 769 { 770 if (atomic_dec_and_test(&pde->count)) 771 free_proc_entry(pde); 772 } 773 774 /* 775 * Remove a /proc entry and free it if it's not currently in use. 776 */ 777 void remove_proc_entry(const char *name, struct proc_dir_entry *parent) 778 { 779 struct proc_dir_entry **p; 780 struct proc_dir_entry *de = NULL; 781 const char *fn = name; 782 unsigned int len; 783 784 spin_lock(&proc_subdir_lock); 785 if (__xlate_proc_name(name, &parent, &fn) != 0) { 786 spin_unlock(&proc_subdir_lock); 787 return; 788 } 789 len = strlen(fn); 790 791 for (p = &parent->subdir; *p; p=&(*p)->next ) { 792 if (proc_match(len, fn, *p)) { 793 de = *p; 794 *p = de->next; 795 de->next = NULL; 796 break; 797 } 798 } 799 spin_unlock(&proc_subdir_lock); 800 if (!de) { 801 WARN(1, "name '%s'\n", name); 802 return; 803 } 804 805 spin_lock(&de->pde_unload_lock); 806 /* 807 * Stop accepting new callers into module. If you're 808 * dynamically allocating ->proc_fops, save a pointer somewhere. 809 */ 810 de->proc_fops = NULL; 811 /* Wait until all existing callers into module are done. */ 812 if (de->pde_users > 0) { 813 DECLARE_COMPLETION_ONSTACK(c); 814 815 if (!de->pde_unload_completion) 816 de->pde_unload_completion = &c; 817 818 spin_unlock(&de->pde_unload_lock); 819 820 wait_for_completion(de->pde_unload_completion); 821 822 spin_lock(&de->pde_unload_lock); 823 } 824 825 while (!list_empty(&de->pde_openers)) { 826 struct pde_opener *pdeo; 827 828 pdeo = list_first_entry(&de->pde_openers, struct pde_opener, lh); 829 list_del(&pdeo->lh); 830 spin_unlock(&de->pde_unload_lock); 831 pdeo->release(pdeo->inode, pdeo->file); 832 kfree(pdeo); 833 spin_lock(&de->pde_unload_lock); 834 } 835 spin_unlock(&de->pde_unload_lock); 836 837 if (S_ISDIR(de->mode)) 838 parent->nlink--; 839 de->nlink = 0; 840 WARN(de->subdir, KERN_WARNING "%s: removing non-empty directory " 841 "'%s/%s', leaking at least '%s'\n", __func__, 842 de->parent->name, de->name, de->subdir->name); 843 pde_put(de); 844 } 845 EXPORT_SYMBOL(remove_proc_entry); 846