fs/configfs/dir.c

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