fs/configfs/dir.c

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