LCOV - code coverage report
Current view: top level - lkbce/fs/configfs - dir.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 670 783 85.6 %
Date: 2017-01-25 Functions: 45 50 90.0 %

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

Generated by: LCOV version 1.10