1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
4 * dir.c - Operations for configfs directories.
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.
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.
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.
22 * sysfs is Copyright (C) 2001, 2002, 2003 Patrick Mochel
24 * configfs Copyright (C) 2005 Oracle. All rights reserved.
30 #include <linux/mount.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/err.h>
35 #include <linux/configfs.h>
36 #include "configfs_internal.h"
38 DECLARE_RWSEM(configfs_rename_sem
);
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.
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()
51 DEFINE_SPINLOCK(configfs_dirent_lock
);
53 static void configfs_d_iput(struct dentry
* dentry
,
56 struct configfs_dirent
* sd
= dentry
->d_fsdata
;
59 BUG_ON(sd
->s_dentry
!= dentry
);
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.
70 static int configfs_d_delete(const struct dentry
*dentry
)
75 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
,
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.
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].
94 * The lock classes are declared and assigned in inode.c, according to the
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].
102 static void configfs_init_dirent_depth(struct configfs_dirent
*sd
)
107 static void configfs_set_dir_dirent_depth(struct configfs_dirent
*parent_sd
,
108 struct configfs_dirent
*sd
)
110 int parent_depth
= parent_sd
->s_depth
;
112 if (parent_depth
>= 0)
113 sd
->s_depth
= parent_depth
+ 1;
117 configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent
*sd
)
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.
125 * sd->s_depth == -1 iff we are a non default group.
126 * else (we are a default group) sd->s_depth > 0 (see
129 if (sd
->s_depth
== -1)
131 * We are a non default group and we are going to create
138 configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent
*sd
)
140 /* We will not create default groups anymore. */
144 #else /* CONFIG_LOCKDEP */
146 static void configfs_init_dirent_depth(struct configfs_dirent
*sd
)
150 static void configfs_set_dir_dirent_depth(struct configfs_dirent
*parent_sd
,
151 struct configfs_dirent
*sd
)
156 configfs_adjust_dir_dirent_depth_before_populate(struct configfs_dirent
*sd
)
161 configfs_adjust_dir_dirent_depth_after_populate(struct configfs_dirent
*sd
)
165 #endif /* CONFIG_LOCKDEP */
168 * Allocates a new configfs_dirent and links it to the parent configfs_dirent
170 static struct configfs_dirent
*configfs_new_dirent(struct configfs_dirent
*parent_sd
,
171 void *element
, int type
)
173 struct configfs_dirent
* sd
;
175 sd
= kmem_cache_zalloc(configfs_dir_cachep
, GFP_KERNEL
);
177 return ERR_PTR(-ENOMEM
);
179 atomic_set(&sd
->s_count
, 1);
180 INIT_LIST_HEAD(&sd
->s_links
);
181 INIT_LIST_HEAD(&sd
->s_children
);
182 sd
->s_element
= element
;
184 configfs_init_dirent_depth(sd
);
185 spin_lock(&configfs_dirent_lock
);
186 if (parent_sd
->s_type
& CONFIGFS_USET_DROPPING
) {
187 spin_unlock(&configfs_dirent_lock
);
188 kmem_cache_free(configfs_dir_cachep
, sd
);
189 return ERR_PTR(-ENOENT
);
191 list_add(&sd
->s_sibling
, &parent_sd
->s_children
);
192 spin_unlock(&configfs_dirent_lock
);
199 * Return -EEXIST if there is already a configfs element with the same
200 * name for the same parent.
202 * called with parent inode's i_mutex held
204 static int configfs_dirent_exists(struct configfs_dirent
*parent_sd
,
205 const unsigned char *new)
207 struct configfs_dirent
* sd
;
209 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
211 const unsigned char *existing
= configfs_get_name(sd
);
212 if (strcmp(existing
, new))
223 int configfs_make_dirent(struct configfs_dirent
* parent_sd
,
224 struct dentry
* dentry
, void * element
,
225 umode_t mode
, int type
)
227 struct configfs_dirent
* sd
;
229 sd
= configfs_new_dirent(parent_sd
, element
, type
);
234 sd
->s_dentry
= dentry
;
236 dentry
->d_fsdata
= configfs_get(sd
);
241 static int init_dir(struct inode
* inode
)
243 inode
->i_op
= &configfs_dir_inode_operations
;
244 inode
->i_fop
= &configfs_dir_operations
;
246 /* directory inodes start off with i_nlink == 2 (for "." entry) */
251 static int configfs_init_file(struct inode
* inode
)
253 inode
->i_size
= PAGE_SIZE
;
254 inode
->i_fop
= &configfs_file_operations
;
258 static int init_symlink(struct inode
* inode
)
260 inode
->i_op
= &configfs_symlink_inode_operations
;
264 static int create_dir(struct config_item
* k
, struct dentry
* p
,
268 umode_t mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
270 error
= configfs_dirent_exists(p
->d_fsdata
, d
->d_name
.name
);
272 error
= configfs_make_dirent(p
->d_fsdata
, d
, k
, mode
,
273 CONFIGFS_DIR
| CONFIGFS_USET_CREATING
);
275 configfs_set_dir_dirent_depth(p
->d_fsdata
, d
->d_fsdata
);
276 error
= configfs_create(d
, mode
, init_dir
);
278 inc_nlink(p
->d_inode
);
280 struct configfs_dirent
*sd
= d
->d_fsdata
;
282 spin_lock(&configfs_dirent_lock
);
283 list_del_init(&sd
->s_sibling
);
284 spin_unlock(&configfs_dirent_lock
);
294 * configfs_create_dir - create a directory for an config_item.
295 * @item: config_itemwe're creating directory for.
296 * @dentry: config_item's dentry.
298 * Note: user-created entries won't be allowed under this new directory
299 * until it is validated by configfs_dir_set_ready()
302 static int configfs_create_dir(struct config_item
* item
, struct dentry
*dentry
)
304 struct dentry
* parent
;
310 parent
= item
->ci_parent
->ci_dentry
;
311 else if (configfs_mount
&& configfs_mount
->mnt_sb
)
312 parent
= configfs_mount
->mnt_sb
->s_root
;
316 error
= create_dir(item
,parent
,dentry
);
318 item
->ci_dentry
= dentry
;
323 * Allow userspace to create new entries under a new directory created with
324 * configfs_create_dir(), and under all of its chidlren directories recursively.
325 * @sd configfs_dirent of the new directory to validate
327 * Caller must hold configfs_dirent_lock.
329 static void configfs_dir_set_ready(struct configfs_dirent
*sd
)
331 struct configfs_dirent
*child_sd
;
333 sd
->s_type
&= ~CONFIGFS_USET_CREATING
;
334 list_for_each_entry(child_sd
, &sd
->s_children
, s_sibling
)
335 if (child_sd
->s_type
& CONFIGFS_USET_CREATING
)
336 configfs_dir_set_ready(child_sd
);
340 * Check that a directory does not belong to a directory hierarchy being
341 * attached and not validated yet.
342 * @sd configfs_dirent of the directory to check
344 * @return non-zero iff the directory was validated
346 * Note: takes configfs_dirent_lock, so the result may change from false to true
347 * in two consecutive calls, but never from true to false.
349 int configfs_dirent_is_ready(struct configfs_dirent
*sd
)
353 spin_lock(&configfs_dirent_lock
);
354 ret
= !(sd
->s_type
& CONFIGFS_USET_CREATING
);
355 spin_unlock(&configfs_dirent_lock
);
360 int configfs_create_link(struct configfs_symlink
*sl
,
361 struct dentry
*parent
,
362 struct dentry
*dentry
)
365 umode_t mode
= S_IFLNK
| S_IRWXUGO
;
367 err
= configfs_make_dirent(parent
->d_fsdata
, dentry
, sl
, mode
,
370 err
= configfs_create(dentry
, mode
, init_symlink
);
372 struct configfs_dirent
*sd
= dentry
->d_fsdata
;
374 spin_lock(&configfs_dirent_lock
);
375 list_del_init(&sd
->s_sibling
);
376 spin_unlock(&configfs_dirent_lock
);
384 static void remove_dir(struct dentry
* d
)
386 struct dentry
* parent
= dget(d
->d_parent
);
387 struct configfs_dirent
* sd
;
390 spin_lock(&configfs_dirent_lock
);
391 list_del_init(&sd
->s_sibling
);
392 spin_unlock(&configfs_dirent_lock
);
395 simple_rmdir(parent
->d_inode
,d
);
397 pr_debug(" o %s removing done (%d)\n",d
->d_name
.name
, d
->d_count
);
403 * configfs_remove_dir - remove an config_item's directory.
404 * @item: config_item we're removing.
406 * The only thing special about this is that we remove any files in
407 * the directory before we remove the directory, and we've inlined
408 * what used to be configfs_rmdir() below, instead of calling separately.
410 * Caller holds the mutex of the item's inode
413 static void configfs_remove_dir(struct config_item
* item
)
415 struct dentry
* dentry
= dget(item
->ci_dentry
);
422 * Drop reference from dget() on entrance.
428 /* attaches attribute's configfs_dirent to the dentry corresponding to the
431 static int configfs_attach_attr(struct configfs_dirent
* sd
, struct dentry
* dentry
)
433 struct configfs_attribute
* attr
= sd
->s_element
;
436 dentry
->d_fsdata
= configfs_get(sd
);
437 sd
->s_dentry
= dentry
;
438 error
= configfs_create(dentry
, (attr
->ca_mode
& S_IALLUGO
) | S_IFREG
,
445 dentry
->d_op
= &configfs_dentry_ops
;
451 static struct dentry
* configfs_lookup(struct inode
*dir
,
452 struct dentry
*dentry
,
453 struct nameidata
*nd
)
455 struct configfs_dirent
* parent_sd
= dentry
->d_parent
->d_fsdata
;
456 struct configfs_dirent
* sd
;
461 * Fake invisibility if dir belongs to a group/default groups hierarchy
464 * This forbids userspace to read/write attributes of items which may
465 * not complete their initialization, since the dentries of the
466 * attributes won't be instantiated.
469 if (!configfs_dirent_is_ready(parent_sd
))
472 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
473 if (sd
->s_type
& CONFIGFS_NOT_PINNED
) {
474 const unsigned char * name
= configfs_get_name(sd
);
476 if (strcmp(name
, dentry
->d_name
.name
))
480 err
= configfs_attach_attr(sd
, dentry
);
487 * If it doesn't exist and it isn't a NOT_PINNED item,
488 * it must be negative.
490 if (dentry
->d_name
.len
> NAME_MAX
)
491 return ERR_PTR(-ENAMETOOLONG
);
492 dentry
->d_op
= &configfs_dentry_ops
;
502 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are
503 * attributes and are removed by rmdir(). We recurse, setting
504 * CONFIGFS_USET_DROPPING on all children that are candidates for
506 * If there is an error, the caller will reset the flags via
507 * configfs_detach_rollback().
509 static int configfs_detach_prep(struct dentry
*dentry
, struct mutex
**wait_mutex
)
511 struct configfs_dirent
*parent_sd
= dentry
->d_fsdata
;
512 struct configfs_dirent
*sd
;
515 /* Mark that we're trying to drop the group */
516 parent_sd
->s_type
|= CONFIGFS_USET_DROPPING
;
519 if (!list_empty(&parent_sd
->s_links
))
523 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
524 if (!sd
->s_element
||
525 (sd
->s_type
& CONFIGFS_NOT_PINNED
))
527 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
) {
528 /* Abort if racing with mkdir() */
529 if (sd
->s_type
& CONFIGFS_USET_IN_MKDIR
) {
531 *wait_mutex
= &sd
->s_dentry
->d_inode
->i_mutex
;
536 * Yup, recursive. If there's a problem, blame
537 * deep nesting of default_groups
539 ret
= configfs_detach_prep(sd
->s_dentry
, wait_mutex
);
553 * Walk the tree, resetting CONFIGFS_USET_DROPPING wherever it was
556 static void configfs_detach_rollback(struct dentry
*dentry
)
558 struct configfs_dirent
*parent_sd
= dentry
->d_fsdata
;
559 struct configfs_dirent
*sd
;
561 parent_sd
->s_type
&= ~CONFIGFS_USET_DROPPING
;
563 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
)
564 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
)
565 configfs_detach_rollback(sd
->s_dentry
);
568 static void detach_attrs(struct config_item
* item
)
570 struct dentry
* dentry
= dget(item
->ci_dentry
);
571 struct configfs_dirent
* parent_sd
;
572 struct configfs_dirent
* sd
, * tmp
;
577 pr_debug("configfs %s: dropping attrs for dir\n",
578 dentry
->d_name
.name
);
580 parent_sd
= dentry
->d_fsdata
;
581 list_for_each_entry_safe(sd
, tmp
, &parent_sd
->s_children
, s_sibling
) {
582 if (!sd
->s_element
|| !(sd
->s_type
& CONFIGFS_NOT_PINNED
))
584 spin_lock(&configfs_dirent_lock
);
585 list_del_init(&sd
->s_sibling
);
586 spin_unlock(&configfs_dirent_lock
);
587 configfs_drop_dentry(sd
, dentry
);
592 * Drop reference from dget() on entrance.
597 static int populate_attrs(struct config_item
*item
)
599 struct config_item_type
*t
= item
->ci_type
;
600 struct configfs_attribute
*attr
;
607 for (i
= 0; (attr
= t
->ct_attrs
[i
]) != NULL
; i
++) {
608 if ((error
= configfs_create_file(item
, attr
)))
619 static int configfs_attach_group(struct config_item
*parent_item
,
620 struct config_item
*item
,
621 struct dentry
*dentry
);
622 static void configfs_detach_group(struct config_item
*item
);
624 static void detach_groups(struct config_group
*group
)
626 struct dentry
* dentry
= dget(group
->cg_item
.ci_dentry
);
627 struct dentry
*child
;
628 struct configfs_dirent
*parent_sd
;
629 struct configfs_dirent
*sd
, *tmp
;
634 parent_sd
= dentry
->d_fsdata
;
635 list_for_each_entry_safe(sd
, tmp
, &parent_sd
->s_children
, s_sibling
) {
636 if (!sd
->s_element
||
637 !(sd
->s_type
& CONFIGFS_USET_DEFAULT
))
640 child
= sd
->s_dentry
;
642 mutex_lock(&child
->d_inode
->i_mutex
);
644 configfs_detach_group(sd
->s_element
);
645 child
->d_inode
->i_flags
|= S_DEAD
;
648 mutex_unlock(&child
->d_inode
->i_mutex
);
655 * Drop reference from dget() on entrance.
661 * This fakes mkdir(2) on a default_groups[] entry. It
662 * creates a dentry, attachs it, and then does fixup
665 * We could, perhaps, tweak our parent's ->mkdir for a minute and
666 * try using vfs_mkdir. Just a thought.
668 static int create_default_group(struct config_group
*parent_group
,
669 struct config_group
*group
)
673 struct configfs_dirent
*sd
;
674 /* We trust the caller holds a reference to parent */
675 struct dentry
*child
, *parent
= parent_group
->cg_item
.ci_dentry
;
677 if (!group
->cg_item
.ci_name
)
678 group
->cg_item
.ci_name
= group
->cg_item
.ci_namebuf
;
679 name
.name
= group
->cg_item
.ci_name
;
680 name
.len
= strlen(name
.name
);
681 name
.hash
= full_name_hash(name
.name
, name
.len
);
684 child
= d_alloc(parent
, &name
);
686 child
->d_op
= &configfs_dentry_ops
;
689 ret
= configfs_attach_group(&parent_group
->cg_item
,
690 &group
->cg_item
, child
);
692 sd
= child
->d_fsdata
;
693 sd
->s_type
|= CONFIGFS_USET_DEFAULT
;
703 static int populate_groups(struct config_group
*group
)
705 struct config_group
*new_group
;
709 if (group
->default_groups
) {
710 for (i
= 0; group
->default_groups
[i
]; i
++) {
711 new_group
= group
->default_groups
[i
];
713 ret
= create_default_group(group
, new_group
);
715 detach_groups(group
);
725 * All of link_obj/unlink_obj/link_group/unlink_group require that
726 * subsys->su_mutex is held.
729 static void unlink_obj(struct config_item
*item
)
731 struct config_group
*group
;
733 group
= item
->ci_group
;
735 list_del_init(&item
->ci_entry
);
737 item
->ci_group
= NULL
;
738 item
->ci_parent
= NULL
;
740 /* Drop the reference for ci_entry */
741 config_item_put(item
);
743 /* Drop the reference for ci_parent */
744 config_group_put(group
);
748 static void link_obj(struct config_item
*parent_item
, struct config_item
*item
)
751 * Parent seems redundant with group, but it makes certain
752 * traversals much nicer.
754 item
->ci_parent
= parent_item
;
757 * We hold a reference on the parent for the child's ci_parent
760 item
->ci_group
= config_group_get(to_config_group(parent_item
));
761 list_add_tail(&item
->ci_entry
, &item
->ci_group
->cg_children
);
764 * We hold a reference on the child for ci_entry on the parent's
767 config_item_get(item
);
770 static void unlink_group(struct config_group
*group
)
773 struct config_group
*new_group
;
775 if (group
->default_groups
) {
776 for (i
= 0; group
->default_groups
[i
]; i
++) {
777 new_group
= group
->default_groups
[i
];
778 unlink_group(new_group
);
782 group
->cg_subsys
= NULL
;
783 unlink_obj(&group
->cg_item
);
786 static void link_group(struct config_group
*parent_group
, struct config_group
*group
)
789 struct config_group
*new_group
;
790 struct configfs_subsystem
*subsys
= NULL
; /* gcc is a turd */
792 link_obj(&parent_group
->cg_item
, &group
->cg_item
);
794 if (parent_group
->cg_subsys
)
795 subsys
= parent_group
->cg_subsys
;
796 else if (configfs_is_root(&parent_group
->cg_item
))
797 subsys
= to_configfs_subsystem(group
);
800 group
->cg_subsys
= subsys
;
802 if (group
->default_groups
) {
803 for (i
= 0; group
->default_groups
[i
]; i
++) {
804 new_group
= group
->default_groups
[i
];
805 link_group(group
, new_group
);
811 * 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.
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.
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.
825 static int configfs_attach_item(struct config_item
*parent_item
,
826 struct config_item
*item
,
827 struct dentry
*dentry
)
831 ret
= configfs_create_dir(item
, dentry
);
833 ret
= populate_attrs(item
);
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.
840 mutex_lock(&dentry
->d_inode
->i_mutex
);
841 configfs_remove_dir(item
);
842 dentry
->d_inode
->i_flags
|= S_DEAD
;
844 mutex_unlock(&dentry
->d_inode
->i_mutex
);
852 /* Caller holds the mutex of the item's inode */
853 static void configfs_detach_item(struct config_item
*item
)
856 configfs_remove_dir(item
);
859 static int configfs_attach_group(struct config_item
*parent_item
,
860 struct config_item
*item
,
861 struct dentry
*dentry
)
864 struct configfs_dirent
*sd
;
866 ret
= configfs_attach_item(parent_item
, item
, dentry
);
868 sd
= dentry
->d_fsdata
;
869 sd
->s_type
|= CONFIGFS_USET_DIR
;
872 * FYI, we're faking mkdir in populate_groups()
873 * We must lock the group's inode to avoid races with the VFS
874 * which can already hit the inode and try to add/remove entries
877 * We must also lock the inode to remove it safely in case of
878 * error, as rmdir() would.
880 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
881 configfs_adjust_dir_dirent_depth_before_populate(sd
);
882 ret
= populate_groups(to_config_group(item
));
884 configfs_detach_item(item
);
885 dentry
->d_inode
->i_flags
|= S_DEAD
;
888 configfs_adjust_dir_dirent_depth_after_populate(sd
);
889 mutex_unlock(&dentry
->d_inode
->i_mutex
);
897 /* Caller holds the mutex of the group's inode */
898 static void configfs_detach_group(struct config_item
*item
)
900 detach_groups(to_config_group(item
));
901 configfs_detach_item(item
);
905 * After the item has been detached from the filesystem view, we are
906 * ready to tear it out of the hierarchy. Notify the client before
907 * we do that so they can perform any cleanup that requires
908 * navigating the hierarchy. A client does not need to provide this
909 * callback. The subsystem semaphore MUST be held by the caller, and
910 * references must be valid for both items. It also assumes the
911 * caller has validated ci_type.
913 static void client_disconnect_notify(struct config_item
*parent_item
,
914 struct config_item
*item
)
916 struct config_item_type
*type
;
918 type
= parent_item
->ci_type
;
921 if (type
->ct_group_ops
&& type
->ct_group_ops
->disconnect_notify
)
922 type
->ct_group_ops
->disconnect_notify(to_config_group(parent_item
),
927 * Drop the initial reference from make_item()/make_group()
928 * This function assumes that reference is held on item
929 * and that item holds a valid reference to the parent. Also, it
930 * assumes the caller has validated ci_type.
932 static void client_drop_item(struct config_item
*parent_item
,
933 struct config_item
*item
)
935 struct config_item_type
*type
;
937 type
= parent_item
->ci_type
;
941 * If ->drop_item() exists, it is responsible for the
944 if (type
->ct_group_ops
&& type
->ct_group_ops
->drop_item
)
945 type
->ct_group_ops
->drop_item(to_config_group(parent_item
),
948 config_item_put(item
);
952 static void configfs_dump_one(struct configfs_dirent
*sd
, int level
)
954 printk(KERN_INFO
"%*s\"%s\":\n", level
, " ", configfs_get_name(sd
));
956 #define type_print(_type) if (sd->s_type & _type) printk(KERN_INFO "%*s %s\n", level, " ", #_type);
957 type_print(CONFIGFS_ROOT
);
958 type_print(CONFIGFS_DIR
);
959 type_print(CONFIGFS_ITEM_ATTR
);
960 type_print(CONFIGFS_ITEM_LINK
);
961 type_print(CONFIGFS_USET_DIR
);
962 type_print(CONFIGFS_USET_DEFAULT
);
963 type_print(CONFIGFS_USET_DROPPING
);
967 static int configfs_dump(struct configfs_dirent
*sd
, int level
)
969 struct configfs_dirent
*child_sd
;
972 configfs_dump_one(sd
, level
);
974 if (!(sd
->s_type
& (CONFIGFS_DIR
|CONFIGFS_ROOT
)))
977 list_for_each_entry(child_sd
, &sd
->s_children
, s_sibling
) {
978 ret
= configfs_dump(child_sd
, level
+ 2);
989 * configfs_depend_item() and configfs_undepend_item()
991 * WARNING: Do not call these from a configfs callback!
993 * This describes these functions and their helpers.
995 * Allow another kernel system to depend on a config_item. If this
996 * happens, the item cannot go away until the dependant can live without
997 * it. The idea is to give client modules as simple an interface as
998 * possible. When a system asks them to depend on an item, they just
999 * call configfs_depend_item(). If the item is live and the client
1000 * driver is in good shape, we'll happily do the work for them.
1002 * Why is the locking complex? Because configfs uses the VFS to handle
1003 * all locking, but this function is called outside the normal
1004 * VFS->configfs path. So it must take VFS locks to prevent the
1005 * VFS->configfs stuff (configfs_mkdir(), configfs_rmdir(), etc). This is
1006 * why you can't call these functions underneath configfs callbacks.
1008 * Note, btw, that this can be called at *any* time, even when a configfs
1009 * subsystem isn't registered, or when configfs is loading or unloading.
1010 * Just like configfs_register_subsystem(). So we take the same
1011 * precautions. We pin the filesystem. We lock configfs_dirent_lock.
1012 * If we can find the target item in the
1013 * configfs tree, it must be part of the subsystem tree as well, so we
1014 * do not need the subsystem semaphore. Holding configfs_dirent_lock helps
1015 * locking out mkdir() and rmdir(), who might be racing us.
1019 * configfs_depend_prep()
1021 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are
1022 * attributes. This is similar but not the same to configfs_detach_prep().
1023 * Note that configfs_detach_prep() expects the parent to be locked when it
1024 * is called, but we lock the parent *inside* configfs_depend_prep(). We
1025 * do that so we can unlock it if we find nothing.
1027 * Here we do a depth-first search of the dentry hierarchy looking for
1029 * We deliberately ignore items tagged as dropping since they are virtually
1030 * dead, as well as items in the middle of attachment since they virtually
1031 * do not exist yet. This completes the locking out of racing mkdir() and
1033 * Note: subdirectories in the middle of attachment start with s_type =
1034 * CONFIGFS_DIR|CONFIGFS_USET_CREATING set by create_dir(). When
1035 * CONFIGFS_USET_CREATING is set, we ignore the item. The actual set of
1036 * s_type is in configfs_new_dirent(), which has configfs_dirent_lock.
1038 * If the target is not found, -ENOENT is bubbled up.
1040 * This adds a requirement that all config_items be unique!
1042 * This is recursive. There isn't
1043 * much on the stack, though, so folks that need this function - be careful
1044 * about your stack! Patches will be accepted to make it iterative.
1046 static int configfs_depend_prep(struct dentry
*origin
,
1047 struct config_item
*target
)
1049 struct configfs_dirent
*child_sd
, *sd
= origin
->d_fsdata
;
1052 BUG_ON(!origin
|| !sd
);
1054 if (sd
->s_element
== target
) /* Boo-yah */
1057 list_for_each_entry(child_sd
, &sd
->s_children
, s_sibling
) {
1058 if ((child_sd
->s_type
& CONFIGFS_DIR
) &&
1059 !(child_sd
->s_type
& CONFIGFS_USET_DROPPING
) &&
1060 !(child_sd
->s_type
& CONFIGFS_USET_CREATING
)) {
1061 ret
= configfs_depend_prep(child_sd
->s_dentry
,
1064 goto out
; /* Child path boo-yah */
1068 /* We looped all our children and didn't find target */
1075 int configfs_depend_item(struct configfs_subsystem
*subsys
,
1076 struct config_item
*target
)
1079 struct configfs_dirent
*p
, *root_sd
, *subsys_sd
= NULL
;
1080 struct config_item
*s_item
= &subsys
->su_group
.cg_item
;
1083 * Pin the configfs filesystem. This means we can safely access
1084 * the root of the configfs filesystem.
1086 ret
= configfs_pin_fs();
1091 * Next, lock the root directory. We're going to check that the
1092 * subsystem is really registered, and so we need to lock out
1093 * configfs_[un]register_subsystem().
1095 mutex_lock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1097 root_sd
= configfs_sb
->s_root
->d_fsdata
;
1099 list_for_each_entry(p
, &root_sd
->s_children
, s_sibling
) {
1100 if (p
->s_type
& CONFIGFS_DIR
) {
1101 if (p
->s_element
== s_item
) {
1113 /* Ok, now we can trust subsys/s_item */
1115 spin_lock(&configfs_dirent_lock
);
1116 /* Scan the tree, return 0 if found */
1117 ret
= configfs_depend_prep(subsys_sd
->s_dentry
, target
);
1119 goto out_unlock_dirent_lock
;
1122 * We are sure that the item is not about to be removed by rmdir(), and
1123 * not in the middle of attachment by mkdir().
1125 p
= target
->ci_dentry
->d_fsdata
;
1126 p
->s_dependent_count
+= 1;
1128 out_unlock_dirent_lock
:
1129 spin_unlock(&configfs_dirent_lock
);
1131 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1134 * If we succeeded, the fs is pinned via other methods. If not,
1135 * we're done with it anyway. So release_fs() is always right.
1137 configfs_release_fs();
1141 EXPORT_SYMBOL(configfs_depend_item
);
1144 * Release the dependent linkage. This is much simpler than
1145 * configfs_depend_item() because we know that that the client driver is
1146 * pinned, thus the subsystem is pinned, and therefore configfs is pinned.
1148 void configfs_undepend_item(struct configfs_subsystem
*subsys
,
1149 struct config_item
*target
)
1151 struct configfs_dirent
*sd
;
1154 * Since we can trust everything is pinned, we just need
1155 * configfs_dirent_lock.
1157 spin_lock(&configfs_dirent_lock
);
1159 sd
= target
->ci_dentry
->d_fsdata
;
1160 BUG_ON(sd
->s_dependent_count
< 1);
1162 sd
->s_dependent_count
-= 1;
1165 * After this unlock, we cannot trust the item to stay alive!
1166 * DO NOT REFERENCE item after this unlock.
1168 spin_unlock(&configfs_dirent_lock
);
1170 EXPORT_SYMBOL(configfs_undepend_item
);
1172 static int configfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
1176 struct config_group
*group
= NULL
;
1177 struct config_item
*item
= NULL
;
1178 struct config_item
*parent_item
;
1179 struct configfs_subsystem
*subsys
;
1180 struct configfs_dirent
*sd
;
1181 struct config_item_type
*type
;
1182 struct module
*subsys_owner
= NULL
, *new_item_owner
= NULL
;
1185 if (dentry
->d_parent
== configfs_sb
->s_root
) {
1190 sd
= dentry
->d_parent
->d_fsdata
;
1193 * Fake invisibility if dir belongs to a group/default groups hierarchy
1196 if (!configfs_dirent_is_ready(sd
)) {
1201 if (!(sd
->s_type
& CONFIGFS_USET_DIR
)) {
1206 /* Get a working ref for the duration of this function */
1207 parent_item
= configfs_get_config_item(dentry
->d_parent
);
1208 type
= parent_item
->ci_type
;
1209 subsys
= to_config_group(parent_item
)->cg_subsys
;
1212 if (!type
|| !type
->ct_group_ops
||
1213 (!type
->ct_group_ops
->make_group
&&
1214 !type
->ct_group_ops
->make_item
)) {
1215 ret
= -EPERM
; /* Lack-of-mkdir returns -EPERM */
1220 * The subsystem may belong to a different module than the item
1221 * being created. We don't want to safely pin the new item but
1222 * fail to pin the subsystem it sits under.
1224 if (!subsys
->su_group
.cg_item
.ci_type
) {
1228 subsys_owner
= subsys
->su_group
.cg_item
.ci_type
->ct_owner
;
1229 if (!try_module_get(subsys_owner
)) {
1234 name
= kmalloc(dentry
->d_name
.len
+ 1, GFP_KERNEL
);
1237 goto out_subsys_put
;
1240 snprintf(name
, dentry
->d_name
.len
+ 1, "%s", dentry
->d_name
.name
);
1242 mutex_lock(&subsys
->su_mutex
);
1243 if (type
->ct_group_ops
->make_group
) {
1244 group
= type
->ct_group_ops
->make_group(to_config_group(parent_item
), name
);
1246 group
= ERR_PTR(-ENOMEM
);
1247 if (!IS_ERR(group
)) {
1248 link_group(to_config_group(parent_item
), group
);
1249 item
= &group
->cg_item
;
1251 ret
= PTR_ERR(group
);
1253 item
= type
->ct_group_ops
->make_item(to_config_group(parent_item
), name
);
1255 item
= ERR_PTR(-ENOMEM
);
1257 link_obj(parent_item
, item
);
1259 ret
= PTR_ERR(item
);
1261 mutex_unlock(&subsys
->su_mutex
);
1266 * If ret != 0, then link_obj() was never called.
1267 * There are no extra references to clean up.
1269 goto out_subsys_put
;
1273 * link_obj() has been called (via link_group() for groups).
1274 * From here on out, errors must clean that up.
1277 type
= item
->ci_type
;
1283 new_item_owner
= type
->ct_owner
;
1284 if (!try_module_get(new_item_owner
)) {
1290 * I hate doing it this way, but if there is
1291 * an error, module_put() probably should
1292 * happen after any cleanup.
1297 * Make racing rmdir() fail if it did not tag parent with
1298 * CONFIGFS_USET_DROPPING
1299 * Note: if CONFIGFS_USET_DROPPING is already set, attach_group() will
1300 * fail and let rmdir() terminate correctly
1302 spin_lock(&configfs_dirent_lock
);
1303 /* This will make configfs_detach_prep() fail */
1304 sd
->s_type
|= CONFIGFS_USET_IN_MKDIR
;
1305 spin_unlock(&configfs_dirent_lock
);
1308 ret
= configfs_attach_group(parent_item
, item
, dentry
);
1310 ret
= configfs_attach_item(parent_item
, item
, dentry
);
1312 spin_lock(&configfs_dirent_lock
);
1313 sd
->s_type
&= ~CONFIGFS_USET_IN_MKDIR
;
1315 configfs_dir_set_ready(dentry
->d_fsdata
);
1316 spin_unlock(&configfs_dirent_lock
);
1320 /* Tear down everything we built up */
1321 mutex_lock(&subsys
->su_mutex
);
1323 client_disconnect_notify(parent_item
, item
);
1325 unlink_group(group
);
1328 client_drop_item(parent_item
, item
);
1330 mutex_unlock(&subsys
->su_mutex
);
1333 module_put(new_item_owner
);
1338 module_put(subsys_owner
);
1342 * link_obj()/link_group() took a reference from child->parent,
1343 * so the parent is safely pinned. We can drop our working
1346 config_item_put(parent_item
);
1352 static int configfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1354 struct config_item
*parent_item
;
1355 struct config_item
*item
;
1356 struct configfs_subsystem
*subsys
;
1357 struct configfs_dirent
*sd
;
1358 struct module
*subsys_owner
= NULL
, *dead_item_owner
= NULL
;
1361 if (dentry
->d_parent
== configfs_sb
->s_root
)
1364 sd
= dentry
->d_fsdata
;
1365 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
)
1368 /* Get a working ref until we have the child */
1369 parent_item
= configfs_get_config_item(dentry
->d_parent
);
1370 subsys
= to_config_group(parent_item
)->cg_subsys
;
1373 if (!parent_item
->ci_type
) {
1374 config_item_put(parent_item
);
1378 /* configfs_mkdir() shouldn't have allowed this */
1379 BUG_ON(!subsys
->su_group
.cg_item
.ci_type
);
1380 subsys_owner
= subsys
->su_group
.cg_item
.ci_type
->ct_owner
;
1383 * Ensure that no racing symlink() will make detach_prep() fail while
1384 * the new link is temporarily attached
1387 struct mutex
*wait_mutex
;
1389 mutex_lock(&configfs_symlink_mutex
);
1390 spin_lock(&configfs_dirent_lock
);
1392 * Here's where we check for dependents. We're protected by
1393 * configfs_dirent_lock.
1394 * If no dependent, atomically tag the item as dropping.
1396 ret
= sd
->s_dependent_count
? -EBUSY
: 0;
1398 ret
= configfs_detach_prep(dentry
, &wait_mutex
);
1400 configfs_detach_rollback(dentry
);
1402 spin_unlock(&configfs_dirent_lock
);
1403 mutex_unlock(&configfs_symlink_mutex
);
1406 if (ret
!= -EAGAIN
) {
1407 config_item_put(parent_item
);
1411 /* Wait until the racing operation terminates */
1412 mutex_lock(wait_mutex
);
1413 mutex_unlock(wait_mutex
);
1415 } while (ret
== -EAGAIN
);
1417 /* Get a working ref for the duration of this function */
1418 item
= configfs_get_config_item(dentry
);
1420 /* Drop reference from above, item already holds one. */
1421 config_item_put(parent_item
);
1424 dead_item_owner
= item
->ci_type
->ct_owner
;
1426 if (sd
->s_type
& CONFIGFS_USET_DIR
) {
1427 configfs_detach_group(item
);
1429 mutex_lock(&subsys
->su_mutex
);
1430 client_disconnect_notify(parent_item
, item
);
1431 unlink_group(to_config_group(item
));
1433 configfs_detach_item(item
);
1435 mutex_lock(&subsys
->su_mutex
);
1436 client_disconnect_notify(parent_item
, item
);
1440 client_drop_item(parent_item
, item
);
1441 mutex_unlock(&subsys
->su_mutex
);
1443 /* Drop our reference from above */
1444 config_item_put(item
);
1446 module_put(dead_item_owner
);
1447 module_put(subsys_owner
);
1452 const struct inode_operations configfs_dir_inode_operations
= {
1453 .mkdir
= configfs_mkdir
,
1454 .rmdir
= configfs_rmdir
,
1455 .symlink
= configfs_symlink
,
1456 .unlink
= configfs_unlink
,
1457 .lookup
= configfs_lookup
,
1458 .setattr
= configfs_setattr
,
1462 int configfs_rename_dir(struct config_item
* item
, const char *new_name
)
1465 struct dentry
* new_dentry
, * parent
;
1467 if (!strcmp(config_item_name(item
), new_name
))
1473 down_write(&configfs_rename_sem
);
1474 parent
= item
->parent
->dentry
;
1476 mutex_lock(&parent
->d_inode
->i_mutex
);
1478 new_dentry
= lookup_one_len(new_name
, parent
, strlen(new_name
));
1479 if (!IS_ERR(new_dentry
)) {
1480 if (!new_dentry
->d_inode
) {
1481 error
= config_item_set_name(item
, "%s", new_name
);
1483 d_add(new_dentry
, NULL
);
1484 d_move(item
->dentry
, new_dentry
);
1487 d_delete(new_dentry
);
1492 mutex_unlock(&parent
->d_inode
->i_mutex
);
1493 up_write(&configfs_rename_sem
);
1499 static int configfs_dir_open(struct inode
*inode
, struct file
*file
)
1501 struct dentry
* dentry
= file
->f_path
.dentry
;
1502 struct configfs_dirent
* parent_sd
= dentry
->d_fsdata
;
1505 mutex_lock(&dentry
->d_inode
->i_mutex
);
1507 * Fake invisibility if dir belongs to a group/default groups hierarchy
1511 if (configfs_dirent_is_ready(parent_sd
)) {
1512 file
->private_data
= configfs_new_dirent(parent_sd
, NULL
, 0);
1513 if (IS_ERR(file
->private_data
))
1514 err
= PTR_ERR(file
->private_data
);
1518 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1523 static int configfs_dir_close(struct inode
*inode
, struct file
*file
)
1525 struct dentry
* dentry
= file
->f_path
.dentry
;
1526 struct configfs_dirent
* cursor
= file
->private_data
;
1528 mutex_lock(&dentry
->d_inode
->i_mutex
);
1529 spin_lock(&configfs_dirent_lock
);
1530 list_del_init(&cursor
->s_sibling
);
1531 spin_unlock(&configfs_dirent_lock
);
1532 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1534 release_configfs_dirent(cursor
);
1539 /* Relationship between s_mode and the DT_xxx types */
1540 static inline unsigned char dt_type(struct configfs_dirent
*sd
)
1542 return (sd
->s_mode
>> 12) & 15;
1545 static int configfs_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
1547 struct dentry
*dentry
= filp
->f_path
.dentry
;
1548 struct configfs_dirent
* parent_sd
= dentry
->d_fsdata
;
1549 struct configfs_dirent
*cursor
= filp
->private_data
;
1550 struct list_head
*p
, *q
= &cursor
->s_sibling
;
1552 int i
= filp
->f_pos
;
1556 ino
= dentry
->d_inode
->i_ino
;
1557 if (filldir(dirent
, ".", 1, i
, ino
, DT_DIR
) < 0)
1563 ino
= parent_ino(dentry
);
1564 if (filldir(dirent
, "..", 2, i
, ino
, DT_DIR
) < 0)
1570 if (filp
->f_pos
== 2) {
1571 spin_lock(&configfs_dirent_lock
);
1572 list_move(q
, &parent_sd
->s_children
);
1573 spin_unlock(&configfs_dirent_lock
);
1575 for (p
=q
->next
; p
!= &parent_sd
->s_children
; p
=p
->next
) {
1576 struct configfs_dirent
*next
;
1580 next
= list_entry(p
, struct configfs_dirent
,
1582 if (!next
->s_element
)
1585 name
= configfs_get_name(next
);
1588 ino
= next
->s_dentry
->d_inode
->i_ino
;
1590 ino
= iunique(configfs_sb
, 2);
1592 if (filldir(dirent
, name
, len
, filp
->f_pos
, ino
,
1596 spin_lock(&configfs_dirent_lock
);
1598 spin_unlock(&configfs_dirent_lock
);
1606 static loff_t
configfs_dir_lseek(struct file
* file
, loff_t offset
, int origin
)
1608 struct dentry
* dentry
= file
->f_path
.dentry
;
1610 mutex_lock(&dentry
->d_inode
->i_mutex
);
1613 offset
+= file
->f_pos
;
1618 mutex_unlock(&file
->f_path
.dentry
->d_inode
->i_mutex
);
1621 if (offset
!= file
->f_pos
) {
1622 file
->f_pos
= offset
;
1623 if (file
->f_pos
>= 2) {
1624 struct configfs_dirent
*sd
= dentry
->d_fsdata
;
1625 struct configfs_dirent
*cursor
= file
->private_data
;
1626 struct list_head
*p
;
1627 loff_t n
= file
->f_pos
- 2;
1629 spin_lock(&configfs_dirent_lock
);
1630 list_del(&cursor
->s_sibling
);
1631 p
= sd
->s_children
.next
;
1632 while (n
&& p
!= &sd
->s_children
) {
1633 struct configfs_dirent
*next
;
1634 next
= list_entry(p
, struct configfs_dirent
,
1636 if (next
->s_element
)
1640 list_add_tail(&cursor
->s_sibling
, p
);
1641 spin_unlock(&configfs_dirent_lock
);
1644 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1648 const struct file_operations configfs_dir_operations
= {
1649 .open
= configfs_dir_open
,
1650 .release
= configfs_dir_close
,
1651 .llseek
= configfs_dir_lseek
,
1652 .read
= generic_read_dir
,
1653 .readdir
= configfs_readdir
,
1656 int configfs_register_subsystem(struct configfs_subsystem
*subsys
)
1659 struct config_group
*group
= &subsys
->su_group
;
1661 struct dentry
*dentry
;
1662 struct configfs_dirent
*sd
;
1664 err
= configfs_pin_fs();
1668 if (!group
->cg_item
.ci_name
)
1669 group
->cg_item
.ci_name
= group
->cg_item
.ci_namebuf
;
1671 sd
= configfs_sb
->s_root
->d_fsdata
;
1672 link_group(to_config_group(sd
->s_element
), group
);
1674 mutex_lock_nested(&configfs_sb
->s_root
->d_inode
->i_mutex
,
1677 name
.name
= group
->cg_item
.ci_name
;
1678 name
.len
= strlen(name
.name
);
1679 name
.hash
= full_name_hash(name
.name
, name
.len
);
1682 dentry
= d_alloc(configfs_sb
->s_root
, &name
);
1684 dentry
->d_op
= &configfs_dentry_ops
;
1685 d_add(dentry
, NULL
);
1687 err
= configfs_attach_group(sd
->s_element
, &group
->cg_item
,
1693 spin_lock(&configfs_dirent_lock
);
1694 configfs_dir_set_ready(dentry
->d_fsdata
);
1695 spin_unlock(&configfs_dirent_lock
);
1699 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1702 unlink_group(group
);
1703 configfs_release_fs();
1709 void configfs_unregister_subsystem(struct configfs_subsystem
*subsys
)
1711 struct config_group
*group
= &subsys
->su_group
;
1712 struct dentry
*dentry
= group
->cg_item
.ci_dentry
;
1714 if (dentry
->d_parent
!= configfs_sb
->s_root
) {
1715 printk(KERN_ERR
"configfs: Tried to unregister non-subsystem!\n");
1719 mutex_lock_nested(&configfs_sb
->s_root
->d_inode
->i_mutex
,
1721 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
1722 mutex_lock(&configfs_symlink_mutex
);
1723 spin_lock(&configfs_dirent_lock
);
1724 if (configfs_detach_prep(dentry
, NULL
)) {
1725 printk(KERN_ERR
"configfs: Tried to unregister non-empty subsystem!\n");
1727 spin_unlock(&configfs_dirent_lock
);
1728 mutex_unlock(&configfs_symlink_mutex
);
1729 configfs_detach_group(&group
->cg_item
);
1730 dentry
->d_inode
->i_flags
|= S_DEAD
;
1732 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1736 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1740 unlink_group(group
);
1741 configfs_release_fs();
1744 EXPORT_SYMBOL(configfs_register_subsystem
);
1745 EXPORT_SYMBOL(configfs_unregister_subsystem
);