1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * dir.c - Operations for configfs directories. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public 8 * License as published by the Free Software Foundation; either 9 * version 2 of the License, or (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public 17 * License along with this program; if not, write to the 18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 19 * Boston, MA 021110-1307, USA. 20 * 21 * Based on sysfs: 22 * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel 23 * 24 * configfs Copyright (C) 2005 Oracle. All rights reserved. 25 */ 26 27 #undef DEBUG 28 29 #include <linux/fs.h> 30 #include <linux/mount.h> 31 #include <linux/module.h> 32 #include <linux/slab.h> 33 #include <linux/err.h> 34 35 #include <linux/configfs.h> 36 #include "configfs_internal.h" 37 38 DECLARE_RWSEM(configfs_rename_sem); 39 /* 40 * Protects mutations of configfs_dirent linkage together with proper i_mutex 41 * Also protects mutations of symlinks linkage to target configfs_dirent 42 * Mutators of configfs_dirent linkage must *both* have the proper inode locked 43 * and configfs_dirent_lock locked, in that order. 44 * This allows one to safely traverse configfs_dirent trees and symlinks without 45 * having to lock inodes. 46 * 47 * Protects setting of CONFIGFS_USET_DROPPING: checking the flag 48 * unlocked is not reliable unless in detach_groups() called from 49 * rmdir()/unregister() and from configfs_attach_group() 50 */ 51 DEFINE_SPINLOCK(configfs_dirent_lock); 52 53 static void configfs_d_iput(struct dentry * dentry, 54 struct inode * inode) 55 { 56 struct configfs_dirent *sd = dentry->d_fsdata; 57 58 if (sd) { 59 /* Coordinate with configfs_readdir */ 60 spin_lock(&configfs_dirent_lock); 61 /* Coordinate with configfs_attach_attr where will increase 62 * sd->s_count and update sd->s_dentry to new allocated one. 63 * Only set sd->dentry to null when this dentry is the only 64 * sd owner. 65 * If not do so, configfs_d_iput may run just after 66 * configfs_attach_attr and set sd->s_dentry to null 67 * even it's still in use. 68 */ 69 if (atomic_read(&sd->s_count) <= 2) 70 sd->s_dentry = NULL; 71 72 spin_unlock(&configfs_dirent_lock); 73 configfs_put(sd); 74 } 75 iput(inode); 76 } 77 78 const struct dentry_operations configfs_dentry_ops = { 79 .d_iput = configfs_d_iput, 80 .d_delete = always_delete_dentry, 81 }; 82 83 #ifdef CONFIG_LOCKDEP 84 85 /* 86 * Helpers to make lockdep happy with our recursive locking of default groups' 87 * inodes (see configfs_attach_group() and configfs_detach_group()). 88 * We put default groups i_mutexes in separate classes according to their depth 89 * from the youngest non-default group ancestor. 90 * 91 * For a non-default group A having default groups A/B, A/C, and A/C/D, default 92 * groups A/B and A/C will have their inode's mutex in class 93 * default_group_class[0], and default group A/C/D will be in 94 * default_group_class[1]. 95 * 96 * The lock classes are declared and assigned in inode.c, according to the 97 * s_depth value. 98 * The s_depth value is initialized to -1, adjusted to >= 0 when attaching 99 * default groups, and reset to -1 when all default groups are attached. During 100 * attachment, if configfs_create() sees s_depth > 0, the lock class of the new 101 * inode's mutex is set to default_group_class[s_depth - 1]. 102 */ 103 104 static void configfs_init_dirent_depth(struct configfs_dirent *sd) 105 { 106 sd->s_depth = -1; 107 } 108 109 static void configfs_set_dir_dirent_depth(struct configfs_dirent *parent_sd, 110 struct configfs_dirent *sd) 111 { 112 int parent_depth = parent_sd->s_depth; 113 114 if (parent_depth >= 0) 115 sd->s_depth = parent_depth + 1; 116 } 117 118 static void 119 configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent *sd) 120 { 121 /* 122 * item's i_mutex class is already setup, so s_depth is now only 123 * used to set new sub-directories s_depth, which is always done 124 * with item's i_mutex locked. 125 */ 126 /* 127 * sd->s_depth == -1 iff we are a non default group. 128 * else (we are a default group) sd->s_depth > 0 (see 129 * create_dir()). 130 */ 131 if (sd->s_depth == -1) 132 /* 133 * We are a non default group and we are going to create 134 * default groups. 135 */ 136 sd->s_depth = 0; 137 } 138 139 static void 140 configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent *sd) 141 { 142 /* We will not create default groups anymore. */ 143 sd->s_depth = -1; 144 } 145 146 #else /* CONFIG_LOCKDEP */ 147 148 static void configfs_init_dirent_depth(struct configfs_dirent *sd) 149 { 150 } 151 152 static void configfs_set_dir_dirent_depth(struct configfs_dirent *parent_sd, 153 struct configfs_dirent *sd) 154 { 155 } 156 157 static void 158 configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent *sd) 159 { 160 } 161 162 static void 163 configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent *sd) 164 { 165 } 166 167 #endif /* CONFIG_LOCKDEP */ 168 169 /* 170 * Allocates a new configfs_dirent and links it to the parent configfs_dirent 171 */ 172 static struct configfs_dirent *configfs_new_dirent(struct configfs_dirent *parent_sd, 173 void *element, int type) 174 { 175 struct configfs_dirent * sd; 176 177 sd = kmem_cache_zalloc(configfs_dir_cachep, GFP_KERNEL); 178 if (!sd) 179 return ERR_PTR(-ENOMEM); 180 181 atomic_set(&sd->s_count, 1); 182 INIT_LIST_HEAD(&sd->s_links); 183 INIT_LIST_HEAD(&sd->s_children); 184 sd->s_element = element; 185 sd->s_type = type; 186 configfs_init_dirent_depth(sd); 187 spin_lock(&configfs_dirent_lock); 188 if (parent_sd->s_type & CONFIGFS_USET_DROPPING) { 189 spin_unlock(&configfs_dirent_lock); 190 kmem_cache_free(configfs_dir_cachep, sd); 191 return ERR_PTR(-ENOENT); 192 } 193 list_add(&sd->s_sibling, &parent_sd->s_children); 194 spin_unlock(&configfs_dirent_lock); 195 196 return sd; 197 } 198 199 /* 200 * 201 * Return -EEXIST if there is already a configfs element with the same 202 * name for the same parent. 203 * 204 * called with parent inode's i_mutex held 205 */ 206 static int configfs_dirent_exists(struct configfs_dirent *parent_sd, 207 const unsigned char *new) 208 { 209 struct configfs_dirent * sd; 210 211 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 212 if (sd->s_element) { 213 const unsigned char *existing = configfs_get_name(sd); 214 if (strcmp(existing, new)) 215 continue; 216 else 217 return -EEXIST; 218 } 219 } 220 221 return 0; 222 } 223 224 225 int configfs_make_dirent(struct configfs_dirent * parent_sd, 226 struct dentry * dentry, void * element, 227 umode_t mode, int type) 228 { 229 struct configfs_dirent * sd; 230 231 sd = configfs_new_dirent(parent_sd, element, type); 232 if (IS_ERR(sd)) 233 return PTR_ERR(sd); 234 235 sd->s_mode = mode; 236 sd->s_dentry = dentry; 237 if (dentry) 238 dentry->d_fsdata = configfs_get(sd); 239 240 return 0; 241 } 242 243 static void init_dir(struct inode * inode) 244 { 245 inode->i_op = &configfs_dir_inode_operations; 246 inode->i_fop = &configfs_dir_operations; 247 248 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 249 inc_nlink(inode); 250 } 251 252 static void configfs_init_file(struct inode * inode) 253 { 254 inode->i_size = PAGE_SIZE; 255 inode->i_fop = &configfs_file_operations; 256 } 257 258 static void configfs_init_bin_file(struct inode *inode) 259 { 260 inode->i_size = 0; 261 inode->i_fop = &configfs_bin_file_operations; 262 } 263 264 static void init_symlink(struct inode * inode) 265 { 266 inode->i_op = &configfs_symlink_inode_operations; 267 } 268 269 /** 270 * configfs_create_dir - create a directory for an config_item. 271 * @item: config_itemwe're creating directory for. 272 * @dentry: config_item's dentry. 273 * 274 * Note: user-created entries won't be allowed under this new directory 275 * until it is validated by configfs_dir_set_ready() 276 */ 277 278 static int configfs_create_dir(struct config_item *item, struct dentry *dentry) 279 { 280 int error; 281 umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO; 282 struct dentry *p = dentry->d_parent; 283 284 BUG_ON(!item); 285 286 error = configfs_dirent_exists(p->d_fsdata, dentry->d_name.name); 287 if (unlikely(error)) 288 return error; 289 290 error = configfs_make_dirent(p->d_fsdata, dentry, item, mode, 291 CONFIGFS_DIR | CONFIGFS_USET_CREATING); 292 if (unlikely(error)) 293 return error; 294 295 configfs_set_dir_dirent_depth(p->d_fsdata, dentry->d_fsdata); 296 error = configfs_create(dentry, mode, init_dir); 297 if (!error) { 298 inc_nlink(d_inode(p)); 299 item->ci_dentry = dentry; 300 } else { 301 struct configfs_dirent *sd = dentry->d_fsdata; 302 if (sd) { 303 spin_lock(&configfs_dirent_lock); 304 list_del_init(&sd->s_sibling); 305 spin_unlock(&configfs_dirent_lock); 306 configfs_put(sd); 307 } 308 } 309 return error; 310 } 311 312 /* 313 * Allow userspace to create new entries under a new directory created with 314 * configfs_create_dir(), and under all of its chidlren directories recursively. 315 * @sd configfs_dirent of the new directory to validate 316 * 317 * Caller must hold configfs_dirent_lock. 318 */ 319 static void configfs_dir_set_ready(struct configfs_dirent *sd) 320 { 321 struct configfs_dirent *child_sd; 322 323 sd->s_type &= ~CONFIGFS_USET_CREATING; 324 list_for_each_entry(child_sd, &sd->s_children, s_sibling) 325 if (child_sd->s_type & CONFIGFS_USET_CREATING) 326 configfs_dir_set_ready(child_sd); 327 } 328 329 /* 330 * Check that a directory does not belong to a directory hierarchy being 331 * attached and not validated yet. 332 * @sd configfs_dirent of the directory to check 333 * 334 * @return non-zero iff the directory was validated 335 * 336 * Note: takes configfs_dirent_lock, so the result may change from false to true 337 * in two consecutive calls, but never from true to false. 338 */ 339 int configfs_dirent_is_ready(struct configfs_dirent *sd) 340 { 341 int ret; 342 343 spin_lock(&configfs_dirent_lock); 344 ret = !(sd->s_type & CONFIGFS_USET_CREATING); 345 spin_unlock(&configfs_dirent_lock); 346 347 return ret; 348 } 349 350 int configfs_create_link(struct configfs_symlink *sl, 351 struct dentry *parent, 352 struct dentry *dentry) 353 { 354 int err = 0; 355 umode_t mode = S_IFLNK | S_IRWXUGO; 356 357 err = configfs_make_dirent(parent->d_fsdata, dentry, sl, mode, 358 CONFIGFS_ITEM_LINK); 359 if (!err) { 360 err = configfs_create(dentry, mode, init_symlink); 361 if (err) { 362 struct configfs_dirent *sd = dentry->d_fsdata; 363 if (sd) { 364 spin_lock(&configfs_dirent_lock); 365 list_del_init(&sd->s_sibling); 366 spin_unlock(&configfs_dirent_lock); 367 configfs_put(sd); 368 } 369 } 370 } 371 return err; 372 } 373 374 static void remove_dir(struct dentry * d) 375 { 376 struct dentry * parent = dget(d->d_parent); 377 struct configfs_dirent * sd; 378 379 sd = d->d_fsdata; 380 spin_lock(&configfs_dirent_lock); 381 list_del_init(&sd->s_sibling); 382 spin_unlock(&configfs_dirent_lock); 383 configfs_put(sd); 384 if (d_really_is_positive(d)) 385 simple_rmdir(d_inode(parent),d); 386 387 pr_debug(" o %pd removing done (%d)\n", d, d_count(d)); 388 389 dput(parent); 390 } 391 392 /** 393 * configfs_remove_dir - remove an config_item's directory. 394 * @item: config_item we're removing. 395 * 396 * The only thing special about this is that we remove any files in 397 * the directory before we remove the directory, and we've inlined 398 * what used to be configfs_rmdir() below, instead of calling separately. 399 * 400 * Caller holds the mutex of the item's inode 401 */ 402 403 static void configfs_remove_dir(struct config_item * item) 404 { 405 struct dentry * dentry = dget(item->ci_dentry); 406 407 if (!dentry) 408 return; 409 410 remove_dir(dentry); 411 /** 412 * Drop reference from dget() on entrance. 413 */ 414 dput(dentry); 415 } 416 417 418 /* attaches attribute's configfs_dirent to the dentry corresponding to the 419 * attribute file 420 */ 421 static int configfs_attach_attr(struct configfs_dirent * sd, struct dentry * dentry) 422 { 423 struct configfs_attribute * attr = sd->s_element; 424 int error; 425 426 spin_lock(&configfs_dirent_lock); 427 dentry->d_fsdata = configfs_get(sd); 428 sd->s_dentry = dentry; 429 spin_unlock(&configfs_dirent_lock); 430 431 error = configfs_create(dentry, (attr->ca_mode & S_IALLUGO) | S_IFREG, 432 (sd->s_type & CONFIGFS_ITEM_BIN_ATTR) ? 433 configfs_init_bin_file : 434 configfs_init_file); 435 if (error) { 436 configfs_put(sd); 437 return error; 438 } 439 440 d_rehash(dentry); 441 442 return 0; 443 } 444 445 static struct dentry * configfs_lookup(struct inode *dir, 446 struct dentry *dentry, 447 unsigned int flags) 448 { 449 struct configfs_dirent * parent_sd = dentry->d_parent->d_fsdata; 450 struct configfs_dirent * sd; 451 int found = 0; 452 int err; 453 454 /* 455 * Fake invisibility if dir belongs to a group/default groups hierarchy 456 * being attached 457 * 458 * This forbids userspace to read/write attributes of items which may 459 * not complete their initialization, since the dentries of the 460 * attributes won't be instantiated. 461 */ 462 err = -ENOENT; 463 if (!configfs_dirent_is_ready(parent_sd)) 464 goto out; 465 466 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 467 if (sd->s_type & CONFIGFS_NOT_PINNED) { 468 const unsigned char * name = configfs_get_name(sd); 469 470 if (strcmp(name, dentry->d_name.name)) 471 continue; 472 473 found = 1; 474 err = configfs_attach_attr(sd, dentry); 475 break; 476 } 477 } 478 479 if (!found) { 480 /* 481 * If it doesn't exist and it isn't a NOT_PINNED item, 482 * it must be negative. 483 */ 484 if (dentry->d_name.len > NAME_MAX) 485 return ERR_PTR(-ENAMETOOLONG); 486 d_add(dentry, NULL); 487 return NULL; 488 } 489 490 out: 491 return ERR_PTR(err); 492 } 493 494 /* 495 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are 496 * attributes and are removed by rmdir(). We recurse, setting 497 * CONFIGFS_USET_DROPPING on all children that are candidates for 498 * default detach. 499 * If there is an error, the caller will reset the flags via 500 * configfs_detach_rollback(). 501 */ 502 static int configfs_detach_prep(struct dentry *dentry, struct mutex **wait_mutex) 503 { 504 struct configfs_dirent *parent_sd = dentry->d_fsdata; 505 struct configfs_dirent *sd; 506 int ret; 507 508 /* Mark that we're trying to drop the group */ 509 parent_sd->s_type |= CONFIGFS_USET_DROPPING; 510 511 ret = -EBUSY; 512 if (!list_empty(&parent_sd->s_links)) 513 goto out; 514 515 ret = 0; 516 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 517 if (!sd->s_element || 518 (sd->s_type & CONFIGFS_NOT_PINNED)) 519 continue; 520 if (sd->s_type & CONFIGFS_USET_DEFAULT) { 521 /* Abort if racing with mkdir() */ 522 if (sd->s_type & CONFIGFS_USET_IN_MKDIR) { 523 if (wait_mutex) 524 *wait_mutex = &d_inode(sd->s_dentry)->i_mutex; 525 return -EAGAIN; 526 } 527 528 /* 529 * Yup, recursive. If there's a problem, blame 530 * deep nesting of default_groups 531 */ 532 ret = configfs_detach_prep(sd->s_dentry, wait_mutex); 533 if (!ret) 534 continue; 535 } else 536 ret = -ENOTEMPTY; 537 538 break; 539 } 540 541 out: 542 return ret; 543 } 544 545 /* 546 * Walk the tree, resetting CONFIGFS_USET_DROPPING wherever it was 547 * set. 548 */ 549 static void configfs_detach_rollback(struct dentry *dentry) 550 { 551 struct configfs_dirent *parent_sd = dentry->d_fsdata; 552 struct configfs_dirent *sd; 553 554 parent_sd->s_type &= ~CONFIGFS_USET_DROPPING; 555 556 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) 557 if (sd->s_type & CONFIGFS_USET_DEFAULT) 558 configfs_detach_rollback(sd->s_dentry); 559 } 560 561 static void detach_attrs(struct config_item * item) 562 { 563 struct dentry * dentry = dget(item->ci_dentry); 564 struct configfs_dirent * parent_sd; 565 struct configfs_dirent * sd, * tmp; 566 567 if (!dentry) 568 return; 569 570 pr_debug("configfs %s: dropping attrs for dir\n", 571 dentry->d_name.name); 572 573 parent_sd = dentry->d_fsdata; 574 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) { 575 if (!sd->s_element || !(sd->s_type & CONFIGFS_NOT_PINNED)) 576 continue; 577 spin_lock(&configfs_dirent_lock); 578 list_del_init(&sd->s_sibling); 579 spin_unlock(&configfs_dirent_lock); 580 configfs_drop_dentry(sd, dentry); 581 configfs_put(sd); 582 } 583 584 /** 585 * Drop reference from dget() on entrance. 586 */ 587 dput(dentry); 588 } 589 590 static int populate_attrs(struct config_item *item) 591 { 592 struct config_item_type *t = item->ci_type; 593 struct configfs_attribute *attr; 594 struct configfs_bin_attribute *bin_attr; 595 int error = 0; 596 int i; 597 598 if (!t) 599 return -EINVAL; 600 if (t->ct_attrs) { 601 for (i = 0; (attr = t->ct_attrs[i]) != NULL; i++) { 602 if ((error = configfs_create_file(item, attr))) 603 break; 604 } 605 } 606 if (t->ct_bin_attrs) { 607 for (i = 0; (bin_attr = t->ct_bin_attrs[i]) != NULL; i++) { 608 error = configfs_create_bin_file(item, bin_attr); 609 if (error) 610 break; 611 } 612 } 613 614 if (error) 615 detach_attrs(item); 616 617 return error; 618 } 619 620 static int configfs_attach_group(struct config_item *parent_item, 621 struct config_item *item, 622 struct dentry *dentry); 623 static void configfs_detach_group(struct config_item *item); 624 625 static void detach_groups(struct config_group *group) 626 { 627 struct dentry * dentry = dget(group->cg_item.ci_dentry); 628 struct dentry *child; 629 struct configfs_dirent *parent_sd; 630 struct configfs_dirent *sd, *tmp; 631 632 if (!dentry) 633 return; 634 635 parent_sd = dentry->d_fsdata; 636 list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) { 637 if (!sd->s_element || 638 !(sd->s_type & CONFIGFS_USET_DEFAULT)) 639 continue; 640 641 child = sd->s_dentry; 642 643 inode_lock(d_inode(child)); 644 645 configfs_detach_group(sd->s_element); 646 d_inode(child)->i_flags |= S_DEAD; 647 dont_mount(child); 648 649 inode_unlock(d_inode(child)); 650 651 d_delete(child); 652 dput(child); 653 } 654 655 /** 656 * Drop reference from dget() on entrance. 657 */ 658 dput(dentry); 659 } 660 661 /* 662 * This fakes mkdir(2) on a default_groups[] entry. It 663 * creates a dentry, attachs it, and then does fixup 664 * on the sd->s_type. 665 * 666 * We could, perhaps, tweak our parent's ->mkdir for a minute and 667 * try using vfs_mkdir. Just a thought. 668 */ 669 static int create_default_group(struct config_group *parent_group, 670 struct config_group *group) 671 { 672 int ret; 673 struct configfs_dirent *sd; 674 /* We trust the caller holds a reference to parent */ 675 struct dentry *child, *parent = parent_group->cg_item.ci_dentry; 676 677 if (!group->cg_item.ci_name) 678 group->cg_item.ci_name = group->cg_item.ci_namebuf; 679 680 ret = -ENOMEM; 681 child = d_alloc_name(parent, group->cg_item.ci_name); 682 if (child) { 683 d_add(child, NULL); 684 685 ret = configfs_attach_group(&parent_group->cg_item, 686 &group->cg_item, child); 687 if (!ret) { 688 sd = child->d_fsdata; 689 sd->s_type |= CONFIGFS_USET_DEFAULT; 690 } else { 691 BUG_ON(d_inode(child)); 692 d_drop(child); 693 dput(child); 694 } 695 } 696 697 return ret; 698 } 699 700 static int populate_groups(struct config_group *group) 701 { 702 struct config_group *new_group; 703 int ret = 0; 704 int i; 705 706 if (group->default_groups) { 707 for (i = 0; group->default_groups[i]; i++) { 708 new_group = group->default_groups[i]; 709 710 ret = create_default_group(group, new_group); 711 if (ret) { 712 detach_groups(group); 713 break; 714 } 715 } 716 } 717 718 return ret; 719 } 720 721 /* 722 * All of link_obj/unlink_obj/link_group/unlink_group require that 723 * subsys->su_mutex is held. 724 */ 725 726 static void unlink_obj(struct config_item *item) 727 { 728 struct config_group *group; 729 730 group = item->ci_group; 731 if (group) { 732 list_del_init(&item->ci_entry); 733 734 item->ci_group = NULL; 735 item->ci_parent = NULL; 736 737 /* Drop the reference for ci_entry */ 738 config_item_put(item); 739 740 /* Drop the reference for ci_parent */ 741 config_group_put(group); 742 } 743 } 744 745 static void link_obj(struct config_item *parent_item, struct config_item *item) 746 { 747 /* 748 * Parent seems redundant with group, but it makes certain 749 * traversals much nicer. 750 */ 751 item->ci_parent = parent_item; 752 753 /* 754 * We hold a reference on the parent for the child's ci_parent 755 * link. 756 */ 757 item->ci_group = config_group_get(to_config_group(parent_item)); 758 list_add_tail(&item->ci_entry, &item->ci_group->cg_children); 759 760 /* 761 * We hold a reference on the child for ci_entry on the parent's 762 * cg_children 763 */ 764 config_item_get(item); 765 } 766 767 static void unlink_group(struct config_group *group) 768 { 769 int i; 770 struct config_group *new_group; 771 772 if (group->default_groups) { 773 for (i = 0; group->default_groups[i]; i++) { 774 new_group = group->default_groups[i]; 775 unlink_group(new_group); 776 } 777 } 778 779 group->cg_subsys = NULL; 780 unlink_obj(&group->cg_item); 781 } 782 783 static void link_group(struct config_group *parent_group, struct config_group *group) 784 { 785 int i; 786 struct config_group *new_group; 787 struct configfs_subsystem *subsys = NULL; /* gcc is a turd */ 788 789 link_obj(&parent_group->cg_item, &group->cg_item); 790 791 if (parent_group->cg_subsys) 792 subsys = parent_group->cg_subsys; 793 else if (configfs_is_root(&parent_group->cg_item)) 794 subsys = to_configfs_subsystem(group); 795 else 796 BUG(); 797 group->cg_subsys = subsys; 798 799 if (group->default_groups) { 800 for (i = 0; group->default_groups[i]; i++) { 801 new_group = group->default_groups[i]; 802 link_group(group, new_group); 803 } 804 } 805 } 806 807 /* 808 * The goal is that configfs_attach_item() (and 809 * configfs_attach_group()) can be called from either the VFS or this 810 * module. That is, they assume that the items have been created, 811 * the dentry allocated, and the dcache is all ready to go. 812 * 813 * If they fail, they must clean up after themselves as if they 814 * had never been called. The caller (VFS or local function) will 815 * handle cleaning up the dcache bits. 816 * 817 * configfs_detach_group() and configfs_detach_item() behave similarly on 818 * the way out. They assume that the proper semaphores are held, they 819 * clean up the configfs items, and they expect their callers will 820 * handle the dcache bits. 821 */ 822 static int configfs_attach_item(struct config_item *parent_item, 823 struct config_item *item, 824 struct dentry *dentry) 825 { 826 int ret; 827 828 ret = configfs_create_dir(item, dentry); 829 if (!ret) { 830 ret = populate_attrs(item); 831 if (ret) { 832 /* 833 * We are going to remove an inode and its dentry but 834 * the VFS may already have hit and used them. Thus, 835 * we must lock them as rmdir() would. 836 */ 837 inode_lock(d_inode(dentry)); 838 configfs_remove_dir(item); 839 d_inode(dentry)->i_flags |= S_DEAD; 840 dont_mount(dentry); 841 inode_unlock(d_inode(dentry)); 842 d_delete(dentry); 843 } 844 } 845 846 return ret; 847 } 848 849 /* Caller holds the mutex of the item's inode */ 850 static void configfs_detach_item(struct config_item *item) 851 { 852 detach_attrs(item); 853 configfs_remove_dir(item); 854 } 855 856 static int configfs_attach_group(struct config_item *parent_item, 857 struct config_item *item, 858 struct dentry *dentry) 859 { 860 int ret; 861 struct configfs_dirent *sd; 862 863 ret = configfs_attach_item(parent_item, item, dentry); 864 if (!ret) { 865 sd = dentry->d_fsdata; 866 sd->s_type |= CONFIGFS_USET_DIR; 867 868 /* 869 * FYI, we're faking mkdir in populate_groups() 870 * We must lock the group's inode to avoid races with the VFS 871 * which can already hit the inode and try to add/remove entries 872 * under it. 873 * 874 * We must also lock the inode to remove it safely in case of 875 * error, as rmdir() would. 876 */ 877 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD); 878 configfs_adjust_dir_dirent_depth_before_populate(sd); 879 ret = populate_groups(to_config_group(item)); 880 if (ret) { 881 configfs_detach_item(item); 882 d_inode(dentry)->i_flags |= S_DEAD; 883 dont_mount(dentry); 884 } 885 configfs_adjust_dir_dirent_depth_after_populate(sd); 886 inode_unlock(d_inode(dentry)); 887 if (ret) 888 d_delete(dentry); 889 } 890 891 return ret; 892 } 893 894 /* Caller holds the mutex of the group's inode */ 895 static void configfs_detach_group(struct config_item *item) 896 { 897 detach_groups(to_config_group(item)); 898 configfs_detach_item(item); 899 } 900 901 /* 902 * After the item has been detached from the filesystem view, we are 903 * ready to tear it out of the hierarchy. Notify the client before 904 * we do that so they can perform any cleanup that requires 905 * navigating the hierarchy. A client does not need to provide this 906 * callback. The subsystem semaphore MUST be held by the caller, and 907 * references must be valid for both items. It also assumes the 908 * caller has validated ci_type. 909 */ 910 static void client_disconnect_notify(struct config_item *parent_item, 911 struct config_item *item) 912 { 913 struct config_item_type *type; 914 915 type = parent_item->ci_type; 916 BUG_ON(!type); 917 918 if (type->ct_group_ops && type->ct_group_ops->disconnect_notify) 919 type->ct_group_ops->disconnect_notify(to_config_group(parent_item), 920 item); 921 } 922 923 /* 924 * Drop the initial reference from make_item()/make_group() 925 * This function assumes that reference is held on item 926 * and that item holds a valid reference to the parent. Also, it 927 * assumes the caller has validated ci_type. 928 */ 929 static void client_drop_item(struct config_item *parent_item, 930 struct config_item *item) 931 { 932 struct config_item_type *type; 933 934 type = parent_item->ci_type; 935 BUG_ON(!type); 936 937 /* 938 * If ->drop_item() exists, it is responsible for the 939 * config_item_put(). 940 */ 941 if (type->ct_group_ops && type->ct_group_ops->drop_item) 942 type->ct_group_ops->drop_item(to_config_group(parent_item), 943 item); 944 else 945 config_item_put(item); 946 } 947 948 #ifdef DEBUG 949 static void configfs_dump_one(struct configfs_dirent *sd, int level) 950 { 951 pr_info("%*s\"%s\":\n", level, " ", configfs_get_name(sd)); 952 953 #define type_print(_type) if (sd->s_type & _type) pr_info("%*s %s\n", level, " ", #_type); 954 type_print(CONFIGFS_ROOT); 955 type_print(CONFIGFS_DIR); 956 type_print(CONFIGFS_ITEM_ATTR); 957 type_print(CONFIGFS_ITEM_LINK); 958 type_print(CONFIGFS_USET_DIR); 959 type_print(CONFIGFS_USET_DEFAULT); 960 type_print(CONFIGFS_USET_DROPPING); 961 #undef type_print 962 } 963 964 static int configfs_dump(struct configfs_dirent *sd, int level) 965 { 966 struct configfs_dirent *child_sd; 967 int ret = 0; 968 969 configfs_dump_one(sd, level); 970 971 if (!(sd->s_type & (CONFIGFS_DIR|CONFIGFS_ROOT))) 972 return 0; 973 974 list_for_each_entry(child_sd, &sd->s_children, s_sibling) { 975 ret = configfs_dump(child_sd, level + 2); 976 if (ret) 977 break; 978 } 979 980 return ret; 981 } 982 #endif 983 984 985 /* 986 * configfs_depend_item() and configfs_undepend_item() 987 * 988 * WARNING: Do not call these from a configfs callback! 989 * 990 * This describes these functions and their helpers. 991 * 992 * Allow another kernel system to depend on a config_item. If this 993 * happens, the item cannot go away until the dependent can live without 994 * it. The idea is to give client modules as simple an interface as 995 * possible. When a system asks them to depend on an item, they just 996 * call configfs_depend_item(). If the item is live and the client 997 * driver is in good shape, we'll happily do the work for them. 998 * 999 * Why is the locking complex? Because configfs uses the VFS to handle 1000 * all locking, but this function is called outside the normal 1001 * VFS->configfs path. So it must take VFS locks to prevent the 1002 * VFS->configfs stuff (configfs_mkdir(), configfs_rmdir(), etc). This is 1003 * why you can't call these functions underneath configfs callbacks. 1004 * 1005 * Note, btw, that this can be called at *any* time, even when a configfs 1006 * subsystem isn't registered, or when configfs is loading or unloading. 1007 * Just like configfs_register_subsystem(). So we take the same 1008 * precautions. We pin the filesystem. We lock configfs_dirent_lock. 1009 * If we can find the target item in the 1010 * configfs tree, it must be part of the subsystem tree as well, so we 1011 * do not need the subsystem semaphore. Holding configfs_dirent_lock helps 1012 * locking out mkdir() and rmdir(), who might be racing us. 1013 */ 1014 1015 /* 1016 * configfs_depend_prep() 1017 * 1018 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are 1019 * attributes. This is similar but not the same to configfs_detach_prep(). 1020 * Note that configfs_detach_prep() expects the parent to be locked when it 1021 * is called, but we lock the parent *inside* configfs_depend_prep(). We 1022 * do that so we can unlock it if we find nothing. 1023 * 1024 * Here we do a depth-first search of the dentry hierarchy looking for 1025 * our object. 1026 * We deliberately ignore items tagged as dropping since they are virtually 1027 * dead, as well as items in the middle of attachment since they virtually 1028 * do not exist yet. This completes the locking out of racing mkdir() and 1029 * rmdir(). 1030 * Note: subdirectories in the middle of attachment start with s_type = 1031 * CONFIGFS_DIR|CONFIGFS_USET_CREATING set by create_dir(). When 1032 * CONFIGFS_USET_CREATING is set, we ignore the item. The actual set of 1033 * s_type is in configfs_new_dirent(), which has configfs_dirent_lock. 1034 * 1035 * If the target is not found, -ENOENT is bubbled up. 1036 * 1037 * This adds a requirement that all config_items be unique! 1038 * 1039 * This is recursive. There isn't 1040 * much on the stack, though, so folks that need this function - be careful 1041 * about your stack! Patches will be accepted to make it iterative. 1042 */ 1043 static int configfs_depend_prep(struct dentry *origin, 1044 struct config_item *target) 1045 { 1046 struct configfs_dirent *child_sd, *sd; 1047 int ret = 0; 1048 1049 BUG_ON(!origin || !origin->d_fsdata); 1050 sd = origin->d_fsdata; 1051 1052 if (sd->s_element == target) /* Boo-yah */ 1053 goto out; 1054 1055 list_for_each_entry(child_sd, &sd->s_children, s_sibling) { 1056 if ((child_sd->s_type & CONFIGFS_DIR) && 1057 !(child_sd->s_type & CONFIGFS_USET_DROPPING) && 1058 !(child_sd->s_type & CONFIGFS_USET_CREATING)) { 1059 ret = configfs_depend_prep(child_sd->s_dentry, 1060 target); 1061 if (!ret) 1062 goto out; /* Child path boo-yah */ 1063 } 1064 } 1065 1066 /* We looped all our children and didn't find target */ 1067 ret = -ENOENT; 1068 1069 out: 1070 return ret; 1071 } 1072 1073 static int configfs_do_depend_item(struct dentry *subsys_dentry, 1074 struct config_item *target) 1075 { 1076 struct configfs_dirent *p; 1077 int ret; 1078 1079 spin_lock(&configfs_dirent_lock); 1080 /* Scan the tree, return 0 if found */ 1081 ret = configfs_depend_prep(subsys_dentry, target); 1082 if (ret) 1083 goto out_unlock_dirent_lock; 1084 1085 /* 1086 * We are sure that the item is not about to be removed by rmdir(), and 1087 * not in the middle of attachment by mkdir(). 1088 */ 1089 p = target->ci_dentry->d_fsdata; 1090 p->s_dependent_count += 1; 1091 1092 out_unlock_dirent_lock: 1093 spin_unlock(&configfs_dirent_lock); 1094 1095 return ret; 1096 } 1097 1098 static inline struct configfs_dirent * 1099 configfs_find_subsys_dentry(struct configfs_dirent *root_sd, 1100 struct config_item *subsys_item) 1101 { 1102 struct configfs_dirent *p; 1103 struct configfs_dirent *ret = NULL; 1104 1105 list_for_each_entry(p, &root_sd->s_children, s_sibling) { 1106 if (p->s_type & CONFIGFS_DIR && 1107 p->s_element == subsys_item) { 1108 ret = p; 1109 break; 1110 } 1111 } 1112 1113 return ret; 1114 } 1115 1116 1117 int configfs_depend_item(struct configfs_subsystem *subsys, 1118 struct config_item *target) 1119 { 1120 int ret; 1121 struct configfs_dirent *subsys_sd; 1122 struct config_item *s_item = &subsys->su_group.cg_item; 1123 struct dentry *root; 1124 1125 /* 1126 * Pin the configfs filesystem. This means we can safely access 1127 * the root of the configfs filesystem. 1128 */ 1129 root = configfs_pin_fs(); 1130 if (IS_ERR(root)) 1131 return PTR_ERR(root); 1132 1133 /* 1134 * Next, lock the root directory. We're going to check that the 1135 * subsystem is really registered, and so we need to lock out 1136 * configfs_[un]register_subsystem(). 1137 */ 1138 inode_lock(d_inode(root)); 1139 1140 subsys_sd = configfs_find_subsys_dentry(root->d_fsdata, s_item); 1141 if (!subsys_sd) { 1142 ret = -ENOENT; 1143 goto out_unlock_fs; 1144 } 1145 1146 /* Ok, now we can trust subsys/s_item */ 1147 ret = configfs_do_depend_item(subsys_sd->s_dentry, target); 1148 1149 out_unlock_fs: 1150 inode_unlock(d_inode(root)); 1151 1152 /* 1153 * If we succeeded, the fs is pinned via other methods. If not, 1154 * we're done with it anyway. So release_fs() is always right. 1155 */ 1156 configfs_release_fs(); 1157 1158 return ret; 1159 } 1160 EXPORT_SYMBOL(configfs_depend_item); 1161 1162 /* 1163 * Release the dependent linkage. This is much simpler than 1164 * configfs_depend_item() because we know that that the client driver is 1165 * pinned, thus the subsystem is pinned, and therefore configfs is pinned. 1166 */ 1167 void configfs_undepend_item(struct config_item *target) 1168 { 1169 struct configfs_dirent *sd; 1170 1171 /* 1172 * Since we can trust everything is pinned, we just need 1173 * configfs_dirent_lock. 1174 */ 1175 spin_lock(&configfs_dirent_lock); 1176 1177 sd = target->ci_dentry->d_fsdata; 1178 BUG_ON(sd->s_dependent_count < 1); 1179 1180 sd->s_dependent_count -= 1; 1181 1182 /* 1183 * After this unlock, we cannot trust the item to stay alive! 1184 * DO NOT REFERENCE item after this unlock. 1185 */ 1186 spin_unlock(&configfs_dirent_lock); 1187 } 1188 EXPORT_SYMBOL(configfs_undepend_item); 1189 1190 /* 1191 * caller_subsys is a caller's subsystem not target's. This is used to 1192 * determine if we should lock root and check subsys or not. When we are 1193 * in the same subsystem as our target there is no need to do locking as 1194 * we know that subsys is valid and is not unregistered during this function 1195 * as we are called from callback of one of his children and VFS holds a lock 1196 * on some inode. Otherwise we have to lock our root to ensure that target's 1197 * subsystem it is not unregistered during this function. 1198 */ 1199 int configfs_depend_item_unlocked(struct configfs_subsystem *caller_subsys, 1200 struct config_item *target) 1201 { 1202 struct configfs_subsystem *target_subsys; 1203 struct config_group *root, *parent; 1204 struct configfs_dirent *subsys_sd; 1205 int ret = -ENOENT; 1206 1207 /* Disallow this function for configfs root */ 1208 if (configfs_is_root(target)) 1209 return -EINVAL; 1210 1211 parent = target->ci_group; 1212 /* 1213 * This may happen when someone is trying to depend root 1214 * directory of some subsystem 1215 */ 1216 if (configfs_is_root(&parent->cg_item)) { 1217 target_subsys = to_configfs_subsystem(to_config_group(target)); 1218 root = parent; 1219 } else { 1220 target_subsys = parent->cg_subsys; 1221 /* Find a cofnigfs root as we may need it for locking */ 1222 for (root = parent; !configfs_is_root(&root->cg_item); 1223 root = root->cg_item.ci_group) 1224 ; 1225 } 1226 1227 if (target_subsys != caller_subsys) { 1228 /* 1229 * We are in other configfs subsystem, so we have to do 1230 * additional locking to prevent other subsystem from being 1231 * unregistered 1232 */ 1233 inode_lock(d_inode(root->cg_item.ci_dentry)); 1234 1235 /* 1236 * As we are trying to depend item from other subsystem 1237 * we have to check if this subsystem is still registered 1238 */ 1239 subsys_sd = configfs_find_subsys_dentry( 1240 root->cg_item.ci_dentry->d_fsdata, 1241 &target_subsys->su_group.cg_item); 1242 if (!subsys_sd) 1243 goto out_root_unlock; 1244 } else { 1245 subsys_sd = target_subsys->su_group.cg_item.ci_dentry->d_fsdata; 1246 } 1247 1248 /* Now we can execute core of depend item */ 1249 ret = configfs_do_depend_item(subsys_sd->s_dentry, target); 1250 1251 if (target_subsys != caller_subsys) 1252 out_root_unlock: 1253 /* 1254 * We were called from subsystem other than our target so we 1255 * took some locks so now it's time to release them 1256 */ 1257 inode_unlock(d_inode(root->cg_item.ci_dentry)); 1258 1259 return ret; 1260 } 1261 EXPORT_SYMBOL(configfs_depend_item_unlocked); 1262 1263 static int configfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1264 { 1265 int ret = 0; 1266 int module_got = 0; 1267 struct config_group *group = NULL; 1268 struct config_item *item = NULL; 1269 struct config_item *parent_item; 1270 struct configfs_subsystem *subsys; 1271 struct configfs_dirent *sd; 1272 struct config_item_type *type; 1273 struct module *subsys_owner = NULL, *new_item_owner = NULL; 1274 char *name; 1275 1276 sd = dentry->d_parent->d_fsdata; 1277 1278 /* 1279 * Fake invisibility if dir belongs to a group/default groups hierarchy 1280 * being attached 1281 */ 1282 if (!configfs_dirent_is_ready(sd)) { 1283 ret = -ENOENT; 1284 goto out; 1285 } 1286 1287 if (!(sd->s_type & CONFIGFS_USET_DIR)) { 1288 ret = -EPERM; 1289 goto out; 1290 } 1291 1292 /* Get a working ref for the duration of this function */ 1293 parent_item = configfs_get_config_item(dentry->d_parent); 1294 type = parent_item->ci_type; 1295 subsys = to_config_group(parent_item)->cg_subsys; 1296 BUG_ON(!subsys); 1297 1298 if (!type || !type->ct_group_ops || 1299 (!type->ct_group_ops->make_group && 1300 !type->ct_group_ops->make_item)) { 1301 ret = -EPERM; /* Lack-of-mkdir returns -EPERM */ 1302 goto out_put; 1303 } 1304 1305 /* 1306 * The subsystem may belong to a different module than the item 1307 * being created. We don't want to safely pin the new item but 1308 * fail to pin the subsystem it sits under. 1309 */ 1310 if (!subsys->su_group.cg_item.ci_type) { 1311 ret = -EINVAL; 1312 goto out_put; 1313 } 1314 subsys_owner = subsys->su_group.cg_item.ci_type->ct_owner; 1315 if (!try_module_get(subsys_owner)) { 1316 ret = -EINVAL; 1317 goto out_put; 1318 } 1319 1320 name = kmalloc(dentry->d_name.len + 1, GFP_KERNEL); 1321 if (!name) { 1322 ret = -ENOMEM; 1323 goto out_subsys_put; 1324 } 1325 1326 snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name); 1327 1328 mutex_lock(&subsys->su_mutex); 1329 if (type->ct_group_ops->make_group) { 1330 group = type->ct_group_ops->make_group(to_config_group(parent_item), name); 1331 if (!group) 1332 group = ERR_PTR(-ENOMEM); 1333 if (!IS_ERR(group)) { 1334 link_group(to_config_group(parent_item), group); 1335 item = &group->cg_item; 1336 } else 1337 ret = PTR_ERR(group); 1338 } else { 1339 item = type->ct_group_ops->make_item(to_config_group(parent_item), name); 1340 if (!item) 1341 item = ERR_PTR(-ENOMEM); 1342 if (!IS_ERR(item)) 1343 link_obj(parent_item, item); 1344 else 1345 ret = PTR_ERR(item); 1346 } 1347 mutex_unlock(&subsys->su_mutex); 1348 1349 kfree(name); 1350 if (ret) { 1351 /* 1352 * If ret != 0, then link_obj() was never called. 1353 * There are no extra references to clean up. 1354 */ 1355 goto out_subsys_put; 1356 } 1357 1358 /* 1359 * link_obj() has been called (via link_group() for groups). 1360 * From here on out, errors must clean that up. 1361 */ 1362 1363 type = item->ci_type; 1364 if (!type) { 1365 ret = -EINVAL; 1366 goto out_unlink; 1367 } 1368 1369 new_item_owner = type->ct_owner; 1370 if (!try_module_get(new_item_owner)) { 1371 ret = -EINVAL; 1372 goto out_unlink; 1373 } 1374 1375 /* 1376 * I hate doing it this way, but if there is 1377 * an error, module_put() probably should 1378 * happen after any cleanup. 1379 */ 1380 module_got = 1; 1381 1382 /* 1383 * Make racing rmdir() fail if it did not tag parent with 1384 * CONFIGFS_USET_DROPPING 1385 * Note: if CONFIGFS_USET_DROPPING is already set, attach_group() will 1386 * fail and let rmdir() terminate correctly 1387 */ 1388 spin_lock(&configfs_dirent_lock); 1389 /* This will make configfs_detach_prep() fail */ 1390 sd->s_type |= CONFIGFS_USET_IN_MKDIR; 1391 spin_unlock(&configfs_dirent_lock); 1392 1393 if (group) 1394 ret = configfs_attach_group(parent_item, item, dentry); 1395 else 1396 ret = configfs_attach_item(parent_item, item, dentry); 1397 1398 spin_lock(&configfs_dirent_lock); 1399 sd->s_type &= ~CONFIGFS_USET_IN_MKDIR; 1400 if (!ret) 1401 configfs_dir_set_ready(dentry->d_fsdata); 1402 spin_unlock(&configfs_dirent_lock); 1403 1404 out_unlink: 1405 if (ret) { 1406 /* Tear down everything we built up */ 1407 mutex_lock(&subsys->su_mutex); 1408 1409 client_disconnect_notify(parent_item, item); 1410 if (group) 1411 unlink_group(group); 1412 else 1413 unlink_obj(item); 1414 client_drop_item(parent_item, item); 1415 1416 mutex_unlock(&subsys->su_mutex); 1417 1418 if (module_got) 1419 module_put(new_item_owner); 1420 } 1421 1422 out_subsys_put: 1423 if (ret) 1424 module_put(subsys_owner); 1425 1426 out_put: 1427 /* 1428 * link_obj()/link_group() took a reference from child->parent, 1429 * so the parent is safely pinned. We can drop our working 1430 * reference. 1431 */ 1432 config_item_put(parent_item); 1433 1434 out: 1435 return ret; 1436 } 1437 1438 static int configfs_rmdir(struct inode *dir, struct dentry *dentry) 1439 { 1440 struct config_item *parent_item; 1441 struct config_item *item; 1442 struct configfs_subsystem *subsys; 1443 struct configfs_dirent *sd; 1444 struct module *subsys_owner = NULL, *dead_item_owner = NULL; 1445 int ret; 1446 1447 sd = dentry->d_fsdata; 1448 if (sd->s_type & CONFIGFS_USET_DEFAULT) 1449 return -EPERM; 1450 1451 /* Get a working ref until we have the child */ 1452 parent_item = configfs_get_config_item(dentry->d_parent); 1453 subsys = to_config_group(parent_item)->cg_subsys; 1454 BUG_ON(!subsys); 1455 1456 if (!parent_item->ci_type) { 1457 config_item_put(parent_item); 1458 return -EINVAL; 1459 } 1460 1461 /* configfs_mkdir() shouldn't have allowed this */ 1462 BUG_ON(!subsys->su_group.cg_item.ci_type); 1463 subsys_owner = subsys->su_group.cg_item.ci_type->ct_owner; 1464 1465 /* 1466 * Ensure that no racing symlink() will make detach_prep() fail while 1467 * the new link is temporarily attached 1468 */ 1469 do { 1470 struct mutex *wait_mutex; 1471 1472 mutex_lock(&configfs_symlink_mutex); 1473 spin_lock(&configfs_dirent_lock); 1474 /* 1475 * Here's where we check for dependents. We're protected by 1476 * configfs_dirent_lock. 1477 * If no dependent, atomically tag the item as dropping. 1478 */ 1479 ret = sd->s_dependent_count ? -EBUSY : 0; 1480 if (!ret) { 1481 ret = configfs_detach_prep(dentry, &wait_mutex); 1482 if (ret) 1483 configfs_detach_rollback(dentry); 1484 } 1485 spin_unlock(&configfs_dirent_lock); 1486 mutex_unlock(&configfs_symlink_mutex); 1487 1488 if (ret) { 1489 if (ret != -EAGAIN) { 1490 config_item_put(parent_item); 1491 return ret; 1492 } 1493 1494 /* Wait until the racing operation terminates */ 1495 mutex_lock(wait_mutex); 1496 mutex_unlock(wait_mutex); 1497 } 1498 } while (ret == -EAGAIN); 1499 1500 /* Get a working ref for the duration of this function */ 1501 item = configfs_get_config_item(dentry); 1502 1503 /* Drop reference from above, item already holds one. */ 1504 config_item_put(parent_item); 1505 1506 if (item->ci_type) 1507 dead_item_owner = item->ci_type->ct_owner; 1508 1509 if (sd->s_type & CONFIGFS_USET_DIR) { 1510 configfs_detach_group(item); 1511 1512 mutex_lock(&subsys->su_mutex); 1513 client_disconnect_notify(parent_item, item); 1514 unlink_group(to_config_group(item)); 1515 } else { 1516 configfs_detach_item(item); 1517 1518 mutex_lock(&subsys->su_mutex); 1519 client_disconnect_notify(parent_item, item); 1520 unlink_obj(item); 1521 } 1522 1523 client_drop_item(parent_item, item); 1524 mutex_unlock(&subsys->su_mutex); 1525 1526 /* Drop our reference from above */ 1527 config_item_put(item); 1528 1529 module_put(dead_item_owner); 1530 module_put(subsys_owner); 1531 1532 return 0; 1533 } 1534 1535 const struct inode_operations configfs_dir_inode_operations = { 1536 .mkdir = configfs_mkdir, 1537 .rmdir = configfs_rmdir, 1538 .symlink = configfs_symlink, 1539 .unlink = configfs_unlink, 1540 .lookup = configfs_lookup, 1541 .setattr = configfs_setattr, 1542 }; 1543 1544 const struct inode_operations configfs_root_inode_operations = { 1545 .lookup = configfs_lookup, 1546 .setattr = configfs_setattr, 1547 }; 1548 1549 #if 0 1550 int configfs_rename_dir(struct config_item * item, const char *new_name) 1551 { 1552 int error = 0; 1553 struct dentry * new_dentry, * parent; 1554 1555 if (!strcmp(config_item_name(item), new_name)) 1556 return -EINVAL; 1557 1558 if (!item->parent) 1559 return -EINVAL; 1560 1561 down_write(&configfs_rename_sem); 1562 parent = item->parent->dentry; 1563 1564 inode_lock(d_inode(parent)); 1565 1566 new_dentry = lookup_one_len(new_name, parent, strlen(new_name)); 1567 if (!IS_ERR(new_dentry)) { 1568 if (d_really_is_negative(new_dentry)) { 1569 error = config_item_set_name(item, "%s", new_name); 1570 if (!error) { 1571 d_add(new_dentry, NULL); 1572 d_move(item->dentry, new_dentry); 1573 } 1574 else 1575 d_delete(new_dentry); 1576 } else 1577 error = -EEXIST; 1578 dput(new_dentry); 1579 } 1580 inode_unlock(d_inode(parent)); 1581 up_write(&configfs_rename_sem); 1582 1583 return error; 1584 } 1585 #endif 1586 1587 static int configfs_dir_open(struct inode *inode, struct file *file) 1588 { 1589 struct dentry * dentry = file->f_path.dentry; 1590 struct configfs_dirent * parent_sd = dentry->d_fsdata; 1591 int err; 1592 1593 inode_lock(d_inode(dentry)); 1594 /* 1595 * Fake invisibility if dir belongs to a group/default groups hierarchy 1596 * being attached 1597 */ 1598 err = -ENOENT; 1599 if (configfs_dirent_is_ready(parent_sd)) { 1600 file->private_data = configfs_new_dirent(parent_sd, NULL, 0); 1601 if (IS_ERR(file->private_data)) 1602 err = PTR_ERR(file->private_data); 1603 else 1604 err = 0; 1605 } 1606 inode_unlock(d_inode(dentry)); 1607 1608 return err; 1609 } 1610 1611 static int configfs_dir_close(struct inode *inode, struct file *file) 1612 { 1613 struct dentry * dentry = file->f_path.dentry; 1614 struct configfs_dirent * cursor = file->private_data; 1615 1616 inode_lock(d_inode(dentry)); 1617 spin_lock(&configfs_dirent_lock); 1618 list_del_init(&cursor->s_sibling); 1619 spin_unlock(&configfs_dirent_lock); 1620 inode_unlock(d_inode(dentry)); 1621 1622 release_configfs_dirent(cursor); 1623 1624 return 0; 1625 } 1626 1627 /* Relationship between s_mode and the DT_xxx types */ 1628 static inline unsigned char dt_type(struct configfs_dirent *sd) 1629 { 1630 return (sd->s_mode >> 12) & 15; 1631 } 1632 1633 static int configfs_readdir(struct file *file, struct dir_context *ctx) 1634 { 1635 struct dentry *dentry = file->f_path.dentry; 1636 struct super_block *sb = dentry->d_sb; 1637 struct configfs_dirent * parent_sd = dentry->d_fsdata; 1638 struct configfs_dirent *cursor = file->private_data; 1639 struct list_head *p, *q = &cursor->s_sibling; 1640 ino_t ino = 0; 1641 1642 if (!dir_emit_dots(file, ctx)) 1643 return 0; 1644 if (ctx->pos == 2) { 1645 spin_lock(&configfs_dirent_lock); 1646 list_move(q, &parent_sd->s_children); 1647 spin_unlock(&configfs_dirent_lock); 1648 } 1649 for (p = q->next; p != &parent_sd->s_children; p = p->next) { 1650 struct configfs_dirent *next; 1651 const char *name; 1652 int len; 1653 struct inode *inode = NULL; 1654 1655 next = list_entry(p, struct configfs_dirent, s_sibling); 1656 if (!next->s_element) 1657 continue; 1658 1659 name = configfs_get_name(next); 1660 len = strlen(name); 1661 1662 /* 1663 * We'll have a dentry and an inode for 1664 * PINNED items and for open attribute 1665 * files. We lock here to prevent a race 1666 * with configfs_d_iput() clearing 1667 * s_dentry before calling iput(). 1668 * 1669 * Why do we go to the trouble? If 1670 * someone has an attribute file open, 1671 * the inode number should match until 1672 * they close it. Beyond that, we don't 1673 * care. 1674 */ 1675 spin_lock(&configfs_dirent_lock); 1676 dentry = next->s_dentry; 1677 if (dentry) 1678 inode = d_inode(dentry); 1679 if (inode) 1680 ino = inode->i_ino; 1681 spin_unlock(&configfs_dirent_lock); 1682 if (!inode) 1683 ino = iunique(sb, 2); 1684 1685 if (!dir_emit(ctx, name, len, ino, dt_type(next))) 1686 return 0; 1687 1688 spin_lock(&configfs_dirent_lock); 1689 list_move(q, p); 1690 spin_unlock(&configfs_dirent_lock); 1691 p = q; 1692 ctx->pos++; 1693 } 1694 return 0; 1695 } 1696 1697 static loff_t configfs_dir_lseek(struct file *file, loff_t offset, int whence) 1698 { 1699 struct dentry * dentry = file->f_path.dentry; 1700 1701 inode_lock(d_inode(dentry)); 1702 switch (whence) { 1703 case 1: 1704 offset += file->f_pos; 1705 case 0: 1706 if (offset >= 0) 1707 break; 1708 default: 1709 inode_unlock(d_inode(dentry)); 1710 return -EINVAL; 1711 } 1712 if (offset != file->f_pos) { 1713 file->f_pos = offset; 1714 if (file->f_pos >= 2) { 1715 struct configfs_dirent *sd = dentry->d_fsdata; 1716 struct configfs_dirent *cursor = file->private_data; 1717 struct list_head *p; 1718 loff_t n = file->f_pos - 2; 1719 1720 spin_lock(&configfs_dirent_lock); 1721 list_del(&cursor->s_sibling); 1722 p = sd->s_children.next; 1723 while (n && p != &sd->s_children) { 1724 struct configfs_dirent *next; 1725 next = list_entry(p, struct configfs_dirent, 1726 s_sibling); 1727 if (next->s_element) 1728 n--; 1729 p = p->next; 1730 } 1731 list_add_tail(&cursor->s_sibling, p); 1732 spin_unlock(&configfs_dirent_lock); 1733 } 1734 } 1735 inode_unlock(d_inode(dentry)); 1736 return offset; 1737 } 1738 1739 const struct file_operations configfs_dir_operations = { 1740 .open = configfs_dir_open, 1741 .release = configfs_dir_close, 1742 .llseek = configfs_dir_lseek, 1743 .read = generic_read_dir, 1744 .iterate = configfs_readdir, 1745 }; 1746 1747 /** 1748 * configfs_register_group - creates a parent-child relation between two groups 1749 * @parent_group: parent group 1750 * @group: child group 1751 * 1752 * link groups, creates dentry for the child and attaches it to the 1753 * parent dentry. 1754 * 1755 * Return: 0 on success, negative errno code on error 1756 */ 1757 int configfs_register_group(struct config_group *parent_group, 1758 struct config_group *group) 1759 { 1760 struct configfs_subsystem *subsys = parent_group->cg_subsys; 1761 struct dentry *parent; 1762 int ret; 1763 1764 mutex_lock(&subsys->su_mutex); 1765 link_group(parent_group, group); 1766 mutex_unlock(&subsys->su_mutex); 1767 1768 parent = parent_group->cg_item.ci_dentry; 1769 1770 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); 1771 ret = create_default_group(parent_group, group); 1772 if (!ret) { 1773 spin_lock(&configfs_dirent_lock); 1774 configfs_dir_set_ready(group->cg_item.ci_dentry->d_fsdata); 1775 spin_unlock(&configfs_dirent_lock); 1776 } 1777 inode_unlock(d_inode(parent)); 1778 return ret; 1779 } 1780 EXPORT_SYMBOL(configfs_register_group); 1781 1782 /** 1783 * configfs_unregister_group() - unregisters a child group from its parent 1784 * @group: parent group to be unregistered 1785 * 1786 * Undoes configfs_register_group() 1787 */ 1788 void configfs_unregister_group(struct config_group *group) 1789 { 1790 struct configfs_subsystem *subsys = group->cg_subsys; 1791 struct dentry *dentry = group->cg_item.ci_dentry; 1792 struct dentry *parent = group->cg_item.ci_parent->ci_dentry; 1793 1794 inode_lock_nested(d_inode(parent), I_MUTEX_PARENT); 1795 spin_lock(&configfs_dirent_lock); 1796 configfs_detach_prep(dentry, NULL); 1797 spin_unlock(&configfs_dirent_lock); 1798 1799 configfs_detach_group(&group->cg_item); 1800 d_inode(dentry)->i_flags |= S_DEAD; 1801 dont_mount(dentry); 1802 d_delete(dentry); 1803 inode_unlock(d_inode(parent)); 1804 1805 dput(dentry); 1806 1807 mutex_lock(&subsys->su_mutex); 1808 unlink_group(group); 1809 mutex_unlock(&subsys->su_mutex); 1810 } 1811 EXPORT_SYMBOL(configfs_unregister_group); 1812 1813 /** 1814 * configfs_register_default_group() - allocates and registers a child group 1815 * @parent_group: parent group 1816 * @name: child group name 1817 * @item_type: child item type description 1818 * 1819 * boilerplate to allocate and register a child group with its parent. We need 1820 * kzalloc'ed memory because child's default_group is initially empty. 1821 * 1822 * Return: allocated config group or ERR_PTR() on error 1823 */ 1824 struct config_group * 1825 configfs_register_default_group(struct config_group *parent_group, 1826 const char *name, 1827 struct config_item_type *item_type) 1828 { 1829 int ret; 1830 struct config_group *group; 1831 1832 group = kzalloc(sizeof(*group), GFP_KERNEL); 1833 if (!group) 1834 return ERR_PTR(-ENOMEM); 1835 config_group_init_type_name(group, name, item_type); 1836 1837 ret = configfs_register_group(parent_group, group); 1838 if (ret) { 1839 kfree(group); 1840 return ERR_PTR(ret); 1841 } 1842 return group; 1843 } 1844 EXPORT_SYMBOL(configfs_register_default_group); 1845 1846 /** 1847 * configfs_unregister_default_group() - unregisters and frees a child group 1848 * @group: the group to act on 1849 */ 1850 void configfs_unregister_default_group(struct config_group *group) 1851 { 1852 configfs_unregister_group(group); 1853 kfree(group); 1854 } 1855 EXPORT_SYMBOL(configfs_unregister_default_group); 1856 1857 int configfs_register_subsystem(struct configfs_subsystem *subsys) 1858 { 1859 int err; 1860 struct config_group *group = &subsys->su_group; 1861 struct dentry *dentry; 1862 struct dentry *root; 1863 struct configfs_dirent *sd; 1864 1865 root = configfs_pin_fs(); 1866 if (IS_ERR(root)) 1867 return PTR_ERR(root); 1868 1869 if (!group->cg_item.ci_name) 1870 group->cg_item.ci_name = group->cg_item.ci_namebuf; 1871 1872 sd = root->d_fsdata; 1873 link_group(to_config_group(sd->s_element), group); 1874 1875 inode_lock_nested(d_inode(root), I_MUTEX_PARENT); 1876 1877 err = -ENOMEM; 1878 dentry = d_alloc_name(root, group->cg_item.ci_name); 1879 if (dentry) { 1880 d_add(dentry, NULL); 1881 1882 err = configfs_attach_group(sd->s_element, &group->cg_item, 1883 dentry); 1884 if (err) { 1885 BUG_ON(d_inode(dentry)); 1886 d_drop(dentry); 1887 dput(dentry); 1888 } else { 1889 spin_lock(&configfs_dirent_lock); 1890 configfs_dir_set_ready(dentry->d_fsdata); 1891 spin_unlock(&configfs_dirent_lock); 1892 } 1893 } 1894 1895 inode_unlock(d_inode(root)); 1896 1897 if (err) { 1898 unlink_group(group); 1899 configfs_release_fs(); 1900 } 1901 1902 return err; 1903 } 1904 1905 void configfs_unregister_subsystem(struct configfs_subsystem *subsys) 1906 { 1907 struct config_group *group = &subsys->su_group; 1908 struct dentry *dentry = group->cg_item.ci_dentry; 1909 struct dentry *root = dentry->d_sb->s_root; 1910 1911 if (dentry->d_parent != root) { 1912 pr_err("Tried to unregister non-subsystem!\n"); 1913 return; 1914 } 1915 1916 inode_lock_nested(d_inode(root), 1917 I_MUTEX_PARENT); 1918 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD); 1919 mutex_lock(&configfs_symlink_mutex); 1920 spin_lock(&configfs_dirent_lock); 1921 if (configfs_detach_prep(dentry, NULL)) { 1922 pr_err("Tried to unregister non-empty subsystem!\n"); 1923 } 1924 spin_unlock(&configfs_dirent_lock); 1925 mutex_unlock(&configfs_symlink_mutex); 1926 configfs_detach_group(&group->cg_item); 1927 d_inode(dentry)->i_flags |= S_DEAD; 1928 dont_mount(dentry); 1929 inode_unlock(d_inode(dentry)); 1930 1931 d_delete(dentry); 1932 1933 inode_unlock(d_inode(root)); 1934 1935 dput(dentry); 1936 1937 unlink_group(group); 1938 configfs_release_fs(); 1939 } 1940 1941 EXPORT_SYMBOL(configfs_register_subsystem); 1942 EXPORT_SYMBOL(configfs_unregister_subsystem); 1943