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>
34 #include <linux/configfs.h>
35 #include "configfs_internal.h"
37 DECLARE_RWSEM(configfs_rename_sem
);
39 * Protects mutations of configfs_dirent linkage together with proper i_mutex
40 * Mutators of configfs_dirent linkage must *both* have the proper inode locked
41 * and configfs_dirent_lock locked, in that order.
42 * This allows one to safely traverse configfs_dirent trees without having to
45 DEFINE_SPINLOCK(configfs_dirent_lock
);
47 static void configfs_d_iput(struct dentry
* dentry
,
50 struct configfs_dirent
* sd
= dentry
->d_fsdata
;
53 BUG_ON(sd
->s_dentry
!= dentry
);
61 * We _must_ delete our dentries on last dput, as the chain-to-parent
62 * behavior is required to clear the parents of default_groups.
64 static int configfs_d_delete(struct dentry
*dentry
)
69 static struct dentry_operations configfs_dentry_ops
= {
70 .d_iput
= configfs_d_iput
,
71 /* simple_delete_dentry() isn't exported */
72 .d_delete
= configfs_d_delete
,
76 * Allocates a new configfs_dirent and links it to the parent configfs_dirent
78 static struct configfs_dirent
*configfs_new_dirent(struct configfs_dirent
* parent_sd
,
81 struct configfs_dirent
* sd
;
83 sd
= kmem_cache_zalloc(configfs_dir_cachep
, GFP_KERNEL
);
87 atomic_set(&sd
->s_count
, 1);
88 INIT_LIST_HEAD(&sd
->s_links
);
89 INIT_LIST_HEAD(&sd
->s_children
);
90 sd
->s_element
= element
;
91 spin_lock(&configfs_dirent_lock
);
92 list_add(&sd
->s_sibling
, &parent_sd
->s_children
);
93 spin_unlock(&configfs_dirent_lock
);
100 * Return -EEXIST if there is already a configfs element with the same
101 * name for the same parent.
103 * called with parent inode's i_mutex held
105 static int configfs_dirent_exists(struct configfs_dirent
*parent_sd
,
106 const unsigned char *new)
108 struct configfs_dirent
* sd
;
110 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
112 const unsigned char *existing
= configfs_get_name(sd
);
113 if (strcmp(existing
, new))
124 int configfs_make_dirent(struct configfs_dirent
* parent_sd
,
125 struct dentry
* dentry
, void * element
,
126 umode_t mode
, int type
)
128 struct configfs_dirent
* sd
;
130 sd
= configfs_new_dirent(parent_sd
, element
);
136 sd
->s_dentry
= dentry
;
138 dentry
->d_fsdata
= configfs_get(sd
);
139 dentry
->d_op
= &configfs_dentry_ops
;
145 static int init_dir(struct inode
* inode
)
147 inode
->i_op
= &configfs_dir_inode_operations
;
148 inode
->i_fop
= &configfs_dir_operations
;
150 /* directory inodes start off with i_nlink == 2 (for "." entry) */
155 static int configfs_init_file(struct inode
* inode
)
157 inode
->i_size
= PAGE_SIZE
;
158 inode
->i_fop
= &configfs_file_operations
;
162 static int init_symlink(struct inode
* inode
)
164 inode
->i_op
= &configfs_symlink_inode_operations
;
168 static int create_dir(struct config_item
* k
, struct dentry
* p
,
172 umode_t mode
= S_IFDIR
| S_IRWXU
| S_IRUGO
| S_IXUGO
;
174 error
= configfs_dirent_exists(p
->d_fsdata
, d
->d_name
.name
);
176 error
= configfs_make_dirent(p
->d_fsdata
, d
, k
, mode
,
179 error
= configfs_create(d
, mode
, init_dir
);
181 inc_nlink(p
->d_inode
);
182 (d
)->d_op
= &configfs_dentry_ops
;
184 struct configfs_dirent
*sd
= d
->d_fsdata
;
186 spin_lock(&configfs_dirent_lock
);
187 list_del_init(&sd
->s_sibling
);
188 spin_unlock(&configfs_dirent_lock
);
198 * configfs_create_dir - create a directory for an config_item.
199 * @item: config_itemwe're creating directory for.
200 * @dentry: config_item's dentry.
203 static int configfs_create_dir(struct config_item
* item
, struct dentry
*dentry
)
205 struct dentry
* parent
;
211 parent
= item
->ci_parent
->ci_dentry
;
212 else if (configfs_mount
&& configfs_mount
->mnt_sb
)
213 parent
= configfs_mount
->mnt_sb
->s_root
;
217 error
= create_dir(item
,parent
,dentry
);
219 item
->ci_dentry
= dentry
;
223 int configfs_create_link(struct configfs_symlink
*sl
,
224 struct dentry
*parent
,
225 struct dentry
*dentry
)
228 umode_t mode
= S_IFLNK
| S_IRWXUGO
;
230 err
= configfs_make_dirent(parent
->d_fsdata
, dentry
, sl
, mode
,
233 err
= configfs_create(dentry
, mode
, init_symlink
);
235 dentry
->d_op
= &configfs_dentry_ops
;
237 struct configfs_dirent
*sd
= dentry
->d_fsdata
;
239 spin_lock(&configfs_dirent_lock
);
240 list_del_init(&sd
->s_sibling
);
241 spin_unlock(&configfs_dirent_lock
);
249 static void remove_dir(struct dentry
* d
)
251 struct dentry
* parent
= dget(d
->d_parent
);
252 struct configfs_dirent
* sd
;
255 spin_lock(&configfs_dirent_lock
);
256 list_del_init(&sd
->s_sibling
);
257 spin_unlock(&configfs_dirent_lock
);
260 simple_rmdir(parent
->d_inode
,d
);
262 pr_debug(" o %s removing done (%d)\n",d
->d_name
.name
,
263 atomic_read(&d
->d_count
));
269 * configfs_remove_dir - remove an config_item's directory.
270 * @item: config_item we're removing.
272 * The only thing special about this is that we remove any files in
273 * the directory before we remove the directory, and we've inlined
274 * what used to be configfs_rmdir() below, instead of calling separately.
277 static void configfs_remove_dir(struct config_item
* item
)
279 struct dentry
* dentry
= dget(item
->ci_dentry
);
286 * Drop reference from dget() on entrance.
292 /* attaches attribute's configfs_dirent to the dentry corresponding to the
295 static int configfs_attach_attr(struct configfs_dirent
* sd
, struct dentry
* dentry
)
297 struct configfs_attribute
* attr
= sd
->s_element
;
300 dentry
->d_fsdata
= configfs_get(sd
);
301 sd
->s_dentry
= dentry
;
302 error
= configfs_create(dentry
, (attr
->ca_mode
& S_IALLUGO
) | S_IFREG
,
309 dentry
->d_op
= &configfs_dentry_ops
;
315 static struct dentry
* configfs_lookup(struct inode
*dir
,
316 struct dentry
*dentry
,
317 struct nameidata
*nd
)
319 struct configfs_dirent
* parent_sd
= dentry
->d_parent
->d_fsdata
;
320 struct configfs_dirent
* sd
;
324 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
325 if (sd
->s_type
& CONFIGFS_NOT_PINNED
) {
326 const unsigned char * name
= configfs_get_name(sd
);
328 if (strcmp(name
, dentry
->d_name
.name
))
332 err
= configfs_attach_attr(sd
, dentry
);
339 * If it doesn't exist and it isn't a NOT_PINNED item,
340 * it must be negative.
342 return simple_lookup(dir
, dentry
, nd
);
349 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are
350 * attributes and are removed by rmdir(). We recurse, taking i_mutex
351 * on all children that are candidates for default detach. If the
352 * result is clean, then configfs_detach_group() will handle dropping
353 * i_mutex. If there is an error, the caller will clean up the i_mutex
354 * holders via configfs_detach_rollback().
356 static int configfs_detach_prep(struct dentry
*dentry
)
358 struct configfs_dirent
*parent_sd
= dentry
->d_fsdata
;
359 struct configfs_dirent
*sd
;
363 if (!list_empty(&parent_sd
->s_links
))
367 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
368 if (sd
->s_type
& CONFIGFS_NOT_PINNED
)
370 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
) {
371 mutex_lock(&sd
->s_dentry
->d_inode
->i_mutex
);
372 /* Mark that we've taken i_mutex */
373 sd
->s_type
|= CONFIGFS_USET_DROPPING
;
376 * Yup, recursive. If there's a problem, blame
377 * deep nesting of default_groups
379 ret
= configfs_detach_prep(sd
->s_dentry
);
393 * Walk the tree, dropping i_mutex wherever CONFIGFS_USET_DROPPING is
396 static void configfs_detach_rollback(struct dentry
*dentry
)
398 struct configfs_dirent
*parent_sd
= dentry
->d_fsdata
;
399 struct configfs_dirent
*sd
;
401 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
402 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
) {
403 configfs_detach_rollback(sd
->s_dentry
);
405 if (sd
->s_type
& CONFIGFS_USET_DROPPING
) {
406 sd
->s_type
&= ~CONFIGFS_USET_DROPPING
;
407 mutex_unlock(&sd
->s_dentry
->d_inode
->i_mutex
);
413 static void detach_attrs(struct config_item
* item
)
415 struct dentry
* dentry
= dget(item
->ci_dentry
);
416 struct configfs_dirent
* parent_sd
;
417 struct configfs_dirent
* sd
, * tmp
;
422 pr_debug("configfs %s: dropping attrs for dir\n",
423 dentry
->d_name
.name
);
425 parent_sd
= dentry
->d_fsdata
;
426 list_for_each_entry_safe(sd
, tmp
, &parent_sd
->s_children
, s_sibling
) {
427 if (!sd
->s_element
|| !(sd
->s_type
& CONFIGFS_NOT_PINNED
))
429 spin_lock(&configfs_dirent_lock
);
430 list_del_init(&sd
->s_sibling
);
431 spin_unlock(&configfs_dirent_lock
);
432 configfs_drop_dentry(sd
, dentry
);
437 * Drop reference from dget() on entrance.
442 static int populate_attrs(struct config_item
*item
)
444 struct config_item_type
*t
= item
->ci_type
;
445 struct configfs_attribute
*attr
;
452 for (i
= 0; (attr
= t
->ct_attrs
[i
]) != NULL
; i
++) {
453 if ((error
= configfs_create_file(item
, attr
)))
464 static int configfs_attach_group(struct config_item
*parent_item
,
465 struct config_item
*item
,
466 struct dentry
*dentry
);
467 static void configfs_detach_group(struct config_item
*item
);
469 static void detach_groups(struct config_group
*group
)
471 struct dentry
* dentry
= dget(group
->cg_item
.ci_dentry
);
472 struct dentry
*child
;
473 struct configfs_dirent
*parent_sd
;
474 struct configfs_dirent
*sd
, *tmp
;
479 parent_sd
= dentry
->d_fsdata
;
480 list_for_each_entry_safe(sd
, tmp
, &parent_sd
->s_children
, s_sibling
) {
481 if (!sd
->s_element
||
482 !(sd
->s_type
& CONFIGFS_USET_DEFAULT
))
485 child
= sd
->s_dentry
;
487 configfs_detach_group(sd
->s_element
);
488 child
->d_inode
->i_flags
|= S_DEAD
;
491 * From rmdir/unregister, a configfs_detach_prep() pass
492 * has taken our i_mutex for us. Drop it.
493 * From mkdir/register cleanup, there is no sem held.
495 if (sd
->s_type
& CONFIGFS_USET_DROPPING
)
496 mutex_unlock(&child
->d_inode
->i_mutex
);
503 * Drop reference from dget() on entrance.
509 * This fakes mkdir(2) on a default_groups[] entry. It
510 * creates a dentry, attachs it, and then does fixup
513 * We could, perhaps, tweak our parent's ->mkdir for a minute and
514 * try using vfs_mkdir. Just a thought.
516 static int create_default_group(struct config_group
*parent_group
,
517 struct config_group
*group
)
521 struct configfs_dirent
*sd
;
522 /* We trust the caller holds a reference to parent */
523 struct dentry
*child
, *parent
= parent_group
->cg_item
.ci_dentry
;
525 if (!group
->cg_item
.ci_name
)
526 group
->cg_item
.ci_name
= group
->cg_item
.ci_namebuf
;
527 name
.name
= group
->cg_item
.ci_name
;
528 name
.len
= strlen(name
.name
);
529 name
.hash
= full_name_hash(name
.name
, name
.len
);
532 child
= d_alloc(parent
, &name
);
536 ret
= configfs_attach_group(&parent_group
->cg_item
,
537 &group
->cg_item
, child
);
539 sd
= child
->d_fsdata
;
540 sd
->s_type
|= CONFIGFS_USET_DEFAULT
;
550 static int populate_groups(struct config_group
*group
)
552 struct config_group
*new_group
;
553 struct dentry
*dentry
= group
->cg_item
.ci_dentry
;
557 if (group
->default_groups
) {
559 * FYI, we're faking mkdir here
560 * I'm not sure we need this semaphore, as we're called
561 * from our parent's mkdir. That holds our parent's
562 * i_mutex, so afaik lookup cannot continue through our
563 * parent to find us, let alone mess with our tree.
564 * That said, taking our i_mutex is closer to mkdir
565 * emulation, and shouldn't hurt.
567 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
569 for (i
= 0; group
->default_groups
[i
]; i
++) {
570 new_group
= group
->default_groups
[i
];
572 ret
= create_default_group(group
, new_group
);
577 mutex_unlock(&dentry
->d_inode
->i_mutex
);
581 detach_groups(group
);
587 * All of link_obj/unlink_obj/link_group/unlink_group require that
588 * subsys->su_mutex is held.
591 static void unlink_obj(struct config_item
*item
)
593 struct config_group
*group
;
595 group
= item
->ci_group
;
597 list_del_init(&item
->ci_entry
);
599 item
->ci_group
= NULL
;
600 item
->ci_parent
= NULL
;
602 /* Drop the reference for ci_entry */
603 config_item_put(item
);
605 /* Drop the reference for ci_parent */
606 config_group_put(group
);
610 static void link_obj(struct config_item
*parent_item
, struct config_item
*item
)
613 * Parent seems redundant with group, but it makes certain
614 * traversals much nicer.
616 item
->ci_parent
= parent_item
;
619 * We hold a reference on the parent for the child's ci_parent
622 item
->ci_group
= config_group_get(to_config_group(parent_item
));
623 list_add_tail(&item
->ci_entry
, &item
->ci_group
->cg_children
);
626 * We hold a reference on the child for ci_entry on the parent's
629 config_item_get(item
);
632 static void unlink_group(struct config_group
*group
)
635 struct config_group
*new_group
;
637 if (group
->default_groups
) {
638 for (i
= 0; group
->default_groups
[i
]; i
++) {
639 new_group
= group
->default_groups
[i
];
640 unlink_group(new_group
);
644 group
->cg_subsys
= NULL
;
645 unlink_obj(&group
->cg_item
);
648 static void link_group(struct config_group
*parent_group
, struct config_group
*group
)
651 struct config_group
*new_group
;
652 struct configfs_subsystem
*subsys
= NULL
; /* gcc is a turd */
654 link_obj(&parent_group
->cg_item
, &group
->cg_item
);
656 if (parent_group
->cg_subsys
)
657 subsys
= parent_group
->cg_subsys
;
658 else if (configfs_is_root(&parent_group
->cg_item
))
659 subsys
= to_configfs_subsystem(group
);
662 group
->cg_subsys
= subsys
;
664 if (group
->default_groups
) {
665 for (i
= 0; group
->default_groups
[i
]; i
++) {
666 new_group
= group
->default_groups
[i
];
667 link_group(group
, new_group
);
673 * The goal is that configfs_attach_item() (and
674 * configfs_attach_group()) can be called from either the VFS or this
675 * module. That is, they assume that the items have been created,
676 * the dentry allocated, and the dcache is all ready to go.
678 * If they fail, they must clean up after themselves as if they
679 * had never been called. The caller (VFS or local function) will
680 * handle cleaning up the dcache bits.
682 * configfs_detach_group() and configfs_detach_item() behave similarly on
683 * the way out. They assume that the proper semaphores are held, they
684 * clean up the configfs items, and they expect their callers will
685 * handle the dcache bits.
687 static int configfs_attach_item(struct config_item
*parent_item
,
688 struct config_item
*item
,
689 struct dentry
*dentry
)
693 ret
= configfs_create_dir(item
, dentry
);
695 ret
= populate_attrs(item
);
697 configfs_remove_dir(item
);
705 static void configfs_detach_item(struct config_item
*item
)
708 configfs_remove_dir(item
);
711 static int configfs_attach_group(struct config_item
*parent_item
,
712 struct config_item
*item
,
713 struct dentry
*dentry
)
716 struct configfs_dirent
*sd
;
718 ret
= configfs_attach_item(parent_item
, item
, dentry
);
720 sd
= dentry
->d_fsdata
;
721 sd
->s_type
|= CONFIGFS_USET_DIR
;
723 ret
= populate_groups(to_config_group(item
));
725 configfs_detach_item(item
);
733 static void configfs_detach_group(struct config_item
*item
)
735 detach_groups(to_config_group(item
));
736 configfs_detach_item(item
);
740 * After the item has been detached from the filesystem view, we are
741 * ready to tear it out of the hierarchy. Notify the client before
742 * we do that so they can perform any cleanup that requires
743 * navigating the hierarchy. A client does not need to provide this
744 * callback. The subsystem semaphore MUST be held by the caller, and
745 * references must be valid for both items. It also assumes the
746 * caller has validated ci_type.
748 static void client_disconnect_notify(struct config_item
*parent_item
,
749 struct config_item
*item
)
751 struct config_item_type
*type
;
753 type
= parent_item
->ci_type
;
756 if (type
->ct_group_ops
&& type
->ct_group_ops
->disconnect_notify
)
757 type
->ct_group_ops
->disconnect_notify(to_config_group(parent_item
),
762 * Drop the initial reference from make_item()/make_group()
763 * This function assumes that reference is held on item
764 * and that item holds a valid reference to the parent. Also, it
765 * assumes the caller has validated ci_type.
767 static void client_drop_item(struct config_item
*parent_item
,
768 struct config_item
*item
)
770 struct config_item_type
*type
;
772 type
= parent_item
->ci_type
;
776 * If ->drop_item() exists, it is responsible for the
779 if (type
->ct_group_ops
&& type
->ct_group_ops
->drop_item
)
780 type
->ct_group_ops
->drop_item(to_config_group(parent_item
),
783 config_item_put(item
);
787 static void configfs_dump_one(struct configfs_dirent
*sd
, int level
)
789 printk(KERN_INFO
"%*s\"%s\":\n", level
, " ", configfs_get_name(sd
));
791 #define type_print(_type) if (sd->s_type & _type) printk(KERN_INFO "%*s %s\n", level, " ", #_type);
792 type_print(CONFIGFS_ROOT
);
793 type_print(CONFIGFS_DIR
);
794 type_print(CONFIGFS_ITEM_ATTR
);
795 type_print(CONFIGFS_ITEM_LINK
);
796 type_print(CONFIGFS_USET_DIR
);
797 type_print(CONFIGFS_USET_DEFAULT
);
798 type_print(CONFIGFS_USET_DROPPING
);
802 static int configfs_dump(struct configfs_dirent
*sd
, int level
)
804 struct configfs_dirent
*child_sd
;
807 configfs_dump_one(sd
, level
);
809 if (!(sd
->s_type
& (CONFIGFS_DIR
|CONFIGFS_ROOT
)))
812 list_for_each_entry(child_sd
, &sd
->s_children
, s_sibling
) {
813 ret
= configfs_dump(child_sd
, level
+ 2);
824 * configfs_depend_item() and configfs_undepend_item()
826 * WARNING: Do not call these from a configfs callback!
828 * This describes these functions and their helpers.
830 * Allow another kernel system to depend on a config_item. If this
831 * happens, the item cannot go away until the dependant can live without
832 * it. The idea is to give client modules as simple an interface as
833 * possible. When a system asks them to depend on an item, they just
834 * call configfs_depend_item(). If the item is live and the client
835 * driver is in good shape, we'll happily do the work for them.
837 * Why is the locking complex? Because configfs uses the VFS to handle
838 * all locking, but this function is called outside the normal
839 * VFS->configfs path. So it must take VFS locks to prevent the
840 * VFS->configfs stuff (configfs_mkdir(), configfs_rmdir(), etc). This is
841 * why you can't call these functions underneath configfs callbacks.
843 * Note, btw, that this can be called at *any* time, even when a configfs
844 * subsystem isn't registered, or when configfs is loading or unloading.
845 * Just like configfs_register_subsystem(). So we take the same
846 * precautions. We pin the filesystem. We lock each i_mutex _in_order_
847 * on our way down the tree. If we can find the target item in the
848 * configfs tree, it must be part of the subsystem tree as well, so we
849 * do not need the subsystem semaphore. Holding the i_mutex chain locks
850 * out mkdir() and rmdir(), who might be racing us.
854 * configfs_depend_prep()
856 * Only subdirectories count here. Files (CONFIGFS_NOT_PINNED) are
857 * attributes. This is similar but not the same to configfs_detach_prep().
858 * Note that configfs_detach_prep() expects the parent to be locked when it
859 * is called, but we lock the parent *inside* configfs_depend_prep(). We
860 * do that so we can unlock it if we find nothing.
862 * Here we do a depth-first search of the dentry hierarchy looking for
863 * our object. We take i_mutex on each step of the way down. IT IS
864 * ESSENTIAL THAT i_mutex LOCKING IS ORDERED. If we come back up a branch,
865 * we'll drop the i_mutex.
867 * If the target is not found, -ENOENT is bubbled up and we have released
868 * all locks. If the target was found, the locks will be cleared by
869 * configfs_depend_rollback().
871 * This adds a requirement that all config_items be unique!
873 * This is recursive because the locking traversal is tricky. There isn't
874 * much on the stack, though, so folks that need this function - be careful
875 * about your stack! Patches will be accepted to make it iterative.
877 static int configfs_depend_prep(struct dentry
*origin
,
878 struct config_item
*target
)
880 struct configfs_dirent
*child_sd
, *sd
= origin
->d_fsdata
;
883 BUG_ON(!origin
|| !sd
);
885 /* Lock this guy on the way down */
886 mutex_lock(&sd
->s_dentry
->d_inode
->i_mutex
);
887 if (sd
->s_element
== target
) /* Boo-yah */
890 list_for_each_entry(child_sd
, &sd
->s_children
, s_sibling
) {
891 if (child_sd
->s_type
& CONFIGFS_DIR
) {
892 ret
= configfs_depend_prep(child_sd
->s_dentry
,
895 goto out
; /* Child path boo-yah */
899 /* We looped all our children and didn't find target */
900 mutex_unlock(&sd
->s_dentry
->d_inode
->i_mutex
);
908 * This is ONLY called if configfs_depend_prep() did its job. So we can
909 * trust the entire path from item back up to origin.
911 * We walk backwards from item, unlocking each i_mutex. We finish by
914 static void configfs_depend_rollback(struct dentry
*origin
,
915 struct config_item
*item
)
917 struct dentry
*dentry
= item
->ci_dentry
;
919 while (dentry
!= origin
) {
920 mutex_unlock(&dentry
->d_inode
->i_mutex
);
921 dentry
= dentry
->d_parent
;
924 mutex_unlock(&origin
->d_inode
->i_mutex
);
927 int configfs_depend_item(struct configfs_subsystem
*subsys
,
928 struct config_item
*target
)
931 struct configfs_dirent
*p
, *root_sd
, *subsys_sd
= NULL
;
932 struct config_item
*s_item
= &subsys
->su_group
.cg_item
;
935 * Pin the configfs filesystem. This means we can safely access
936 * the root of the configfs filesystem.
938 ret
= configfs_pin_fs();
943 * Next, lock the root directory. We're going to check that the
944 * subsystem is really registered, and so we need to lock out
945 * configfs_[un]register_subsystem().
947 mutex_lock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
949 root_sd
= configfs_sb
->s_root
->d_fsdata
;
951 list_for_each_entry(p
, &root_sd
->s_children
, s_sibling
) {
952 if (p
->s_type
& CONFIGFS_DIR
) {
953 if (p
->s_element
== s_item
) {
965 /* Ok, now we can trust subsys/s_item */
967 /* Scan the tree, locking i_mutex recursively, return 0 if found */
968 ret
= configfs_depend_prep(subsys_sd
->s_dentry
, target
);
972 /* We hold all i_mutexes from the subsystem down to the target */
973 p
= target
->ci_dentry
->d_fsdata
;
974 p
->s_dependent_count
+= 1;
976 configfs_depend_rollback(subsys_sd
->s_dentry
, target
);
979 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
982 * If we succeeded, the fs is pinned via other methods. If not,
983 * we're done with it anyway. So release_fs() is always right.
985 configfs_release_fs();
989 EXPORT_SYMBOL(configfs_depend_item
);
992 * Release the dependent linkage. This is much simpler than
993 * configfs_depend_item() because we know that that the client driver is
994 * pinned, thus the subsystem is pinned, and therefore configfs is pinned.
996 void configfs_undepend_item(struct configfs_subsystem
*subsys
,
997 struct config_item
*target
)
999 struct configfs_dirent
*sd
;
1002 * Since we can trust everything is pinned, we just need i_mutex
1005 mutex_lock(&target
->ci_dentry
->d_inode
->i_mutex
);
1007 sd
= target
->ci_dentry
->d_fsdata
;
1008 BUG_ON(sd
->s_dependent_count
< 1);
1010 sd
->s_dependent_count
-= 1;
1013 * After this unlock, we cannot trust the item to stay alive!
1014 * DO NOT REFERENCE item after this unlock.
1016 mutex_unlock(&target
->ci_dentry
->d_inode
->i_mutex
);
1018 EXPORT_SYMBOL(configfs_undepend_item
);
1020 static int configfs_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
1022 int ret
, module_got
= 0;
1023 struct config_group
*group
;
1024 struct config_item
*item
;
1025 struct config_item
*parent_item
;
1026 struct configfs_subsystem
*subsys
;
1027 struct configfs_dirent
*sd
;
1028 struct config_item_type
*type
;
1029 struct module
*owner
= NULL
;
1032 if (dentry
->d_parent
== configfs_sb
->s_root
) {
1037 sd
= dentry
->d_parent
->d_fsdata
;
1038 if (!(sd
->s_type
& CONFIGFS_USET_DIR
)) {
1043 /* Get a working ref for the duration of this function */
1044 parent_item
= configfs_get_config_item(dentry
->d_parent
);
1045 type
= parent_item
->ci_type
;
1046 subsys
= to_config_group(parent_item
)->cg_subsys
;
1049 if (!type
|| !type
->ct_group_ops
||
1050 (!type
->ct_group_ops
->make_group
&&
1051 !type
->ct_group_ops
->make_item
)) {
1052 ret
= -EPERM
; /* Lack-of-mkdir returns -EPERM */
1056 name
= kmalloc(dentry
->d_name
.len
+ 1, GFP_KERNEL
);
1062 snprintf(name
, dentry
->d_name
.len
+ 1, "%s", dentry
->d_name
.name
);
1064 mutex_lock(&subsys
->su_mutex
);
1067 if (type
->ct_group_ops
->make_group
) {
1068 group
= type
->ct_group_ops
->make_group(to_config_group(parent_item
), name
);
1070 link_group(to_config_group(parent_item
), group
);
1071 item
= &group
->cg_item
;
1074 item
= type
->ct_group_ops
->make_item(to_config_group(parent_item
), name
);
1076 link_obj(parent_item
, item
);
1078 mutex_unlock(&subsys
->su_mutex
);
1083 * If item == NULL, then link_obj() was never called.
1084 * There are no extra references to clean up.
1091 * link_obj() has been called (via link_group() for groups).
1092 * From here on out, errors must clean that up.
1095 type
= item
->ci_type
;
1101 owner
= type
->ct_owner
;
1102 if (!try_module_get(owner
)) {
1108 * I hate doing it this way, but if there is
1109 * an error, module_put() probably should
1110 * happen after any cleanup.
1115 ret
= configfs_attach_group(parent_item
, item
, dentry
);
1117 ret
= configfs_attach_item(parent_item
, item
, dentry
);
1121 /* Tear down everything we built up */
1122 mutex_lock(&subsys
->su_mutex
);
1124 client_disconnect_notify(parent_item
, item
);
1126 unlink_group(group
);
1129 client_drop_item(parent_item
, item
);
1131 mutex_unlock(&subsys
->su_mutex
);
1139 * link_obj()/link_group() took a reference from child->parent,
1140 * so the parent is safely pinned. We can drop our working
1143 config_item_put(parent_item
);
1149 static int configfs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1151 struct config_item
*parent_item
;
1152 struct config_item
*item
;
1153 struct configfs_subsystem
*subsys
;
1154 struct configfs_dirent
*sd
;
1155 struct module
*owner
= NULL
;
1158 if (dentry
->d_parent
== configfs_sb
->s_root
)
1161 sd
= dentry
->d_fsdata
;
1162 if (sd
->s_type
& CONFIGFS_USET_DEFAULT
)
1166 * Here's where we check for dependents. We're protected by
1169 if (sd
->s_dependent_count
)
1172 /* Get a working ref until we have the child */
1173 parent_item
= configfs_get_config_item(dentry
->d_parent
);
1174 subsys
= to_config_group(parent_item
)->cg_subsys
;
1177 if (!parent_item
->ci_type
) {
1178 config_item_put(parent_item
);
1182 ret
= configfs_detach_prep(dentry
);
1184 configfs_detach_rollback(dentry
);
1185 config_item_put(parent_item
);
1189 /* Get a working ref for the duration of this function */
1190 item
= configfs_get_config_item(dentry
);
1192 /* Drop reference from above, item already holds one. */
1193 config_item_put(parent_item
);
1196 owner
= item
->ci_type
->ct_owner
;
1198 if (sd
->s_type
& CONFIGFS_USET_DIR
) {
1199 configfs_detach_group(item
);
1201 mutex_lock(&subsys
->su_mutex
);
1202 client_disconnect_notify(parent_item
, item
);
1203 unlink_group(to_config_group(item
));
1205 configfs_detach_item(item
);
1207 mutex_lock(&subsys
->su_mutex
);
1208 client_disconnect_notify(parent_item
, item
);
1212 client_drop_item(parent_item
, item
);
1213 mutex_unlock(&subsys
->su_mutex
);
1215 /* Drop our reference from above */
1216 config_item_put(item
);
1223 const struct inode_operations configfs_dir_inode_operations
= {
1224 .mkdir
= configfs_mkdir
,
1225 .rmdir
= configfs_rmdir
,
1226 .symlink
= configfs_symlink
,
1227 .unlink
= configfs_unlink
,
1228 .lookup
= configfs_lookup
,
1229 .setattr
= configfs_setattr
,
1233 int configfs_rename_dir(struct config_item
* item
, const char *new_name
)
1236 struct dentry
* new_dentry
, * parent
;
1238 if (!strcmp(config_item_name(item
), new_name
))
1244 down_write(&configfs_rename_sem
);
1245 parent
= item
->parent
->dentry
;
1247 mutex_lock(&parent
->d_inode
->i_mutex
);
1249 new_dentry
= lookup_one_len(new_name
, parent
, strlen(new_name
));
1250 if (!IS_ERR(new_dentry
)) {
1251 if (!new_dentry
->d_inode
) {
1252 error
= config_item_set_name(item
, "%s", new_name
);
1254 d_add(new_dentry
, NULL
);
1255 d_move(item
->dentry
, new_dentry
);
1258 d_delete(new_dentry
);
1263 mutex_unlock(&parent
->d_inode
->i_mutex
);
1264 up_write(&configfs_rename_sem
);
1270 static int configfs_dir_open(struct inode
*inode
, struct file
*file
)
1272 struct dentry
* dentry
= file
->f_path
.dentry
;
1273 struct configfs_dirent
* parent_sd
= dentry
->d_fsdata
;
1275 mutex_lock(&dentry
->d_inode
->i_mutex
);
1276 file
->private_data
= configfs_new_dirent(parent_sd
, NULL
);
1277 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1279 return file
->private_data
? 0 : -ENOMEM
;
1283 static int configfs_dir_close(struct inode
*inode
, struct file
*file
)
1285 struct dentry
* dentry
= file
->f_path
.dentry
;
1286 struct configfs_dirent
* cursor
= file
->private_data
;
1288 mutex_lock(&dentry
->d_inode
->i_mutex
);
1289 spin_lock(&configfs_dirent_lock
);
1290 list_del_init(&cursor
->s_sibling
);
1291 spin_unlock(&configfs_dirent_lock
);
1292 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1294 release_configfs_dirent(cursor
);
1299 /* Relationship between s_mode and the DT_xxx types */
1300 static inline unsigned char dt_type(struct configfs_dirent
*sd
)
1302 return (sd
->s_mode
>> 12) & 15;
1305 static int configfs_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
)
1307 struct dentry
*dentry
= filp
->f_path
.dentry
;
1308 struct configfs_dirent
* parent_sd
= dentry
->d_fsdata
;
1309 struct configfs_dirent
*cursor
= filp
->private_data
;
1310 struct list_head
*p
, *q
= &cursor
->s_sibling
;
1312 int i
= filp
->f_pos
;
1316 ino
= dentry
->d_inode
->i_ino
;
1317 if (filldir(dirent
, ".", 1, i
, ino
, DT_DIR
) < 0)
1323 ino
= parent_ino(dentry
);
1324 if (filldir(dirent
, "..", 2, i
, ino
, DT_DIR
) < 0)
1330 if (filp
->f_pos
== 2) {
1331 spin_lock(&configfs_dirent_lock
);
1332 list_move(q
, &parent_sd
->s_children
);
1333 spin_unlock(&configfs_dirent_lock
);
1335 for (p
=q
->next
; p
!= &parent_sd
->s_children
; p
=p
->next
) {
1336 struct configfs_dirent
*next
;
1340 next
= list_entry(p
, struct configfs_dirent
,
1342 if (!next
->s_element
)
1345 name
= configfs_get_name(next
);
1348 ino
= next
->s_dentry
->d_inode
->i_ino
;
1350 ino
= iunique(configfs_sb
, 2);
1352 if (filldir(dirent
, name
, len
, filp
->f_pos
, ino
,
1356 spin_lock(&configfs_dirent_lock
);
1358 spin_unlock(&configfs_dirent_lock
);
1366 static loff_t
configfs_dir_lseek(struct file
* file
, loff_t offset
, int origin
)
1368 struct dentry
* dentry
= file
->f_path
.dentry
;
1370 mutex_lock(&dentry
->d_inode
->i_mutex
);
1373 offset
+= file
->f_pos
;
1378 mutex_unlock(&file
->f_path
.dentry
->d_inode
->i_mutex
);
1381 if (offset
!= file
->f_pos
) {
1382 file
->f_pos
= offset
;
1383 if (file
->f_pos
>= 2) {
1384 struct configfs_dirent
*sd
= dentry
->d_fsdata
;
1385 struct configfs_dirent
*cursor
= file
->private_data
;
1386 struct list_head
*p
;
1387 loff_t n
= file
->f_pos
- 2;
1389 spin_lock(&configfs_dirent_lock
);
1390 list_del(&cursor
->s_sibling
);
1391 p
= sd
->s_children
.next
;
1392 while (n
&& p
!= &sd
->s_children
) {
1393 struct configfs_dirent
*next
;
1394 next
= list_entry(p
, struct configfs_dirent
,
1396 if (next
->s_element
)
1400 list_add_tail(&cursor
->s_sibling
, p
);
1401 spin_unlock(&configfs_dirent_lock
);
1404 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1408 const struct file_operations configfs_dir_operations
= {
1409 .open
= configfs_dir_open
,
1410 .release
= configfs_dir_close
,
1411 .llseek
= configfs_dir_lseek
,
1412 .read
= generic_read_dir
,
1413 .readdir
= configfs_readdir
,
1416 int configfs_register_subsystem(struct configfs_subsystem
*subsys
)
1419 struct config_group
*group
= &subsys
->su_group
;
1421 struct dentry
*dentry
;
1422 struct configfs_dirent
*sd
;
1424 err
= configfs_pin_fs();
1428 if (!group
->cg_item
.ci_name
)
1429 group
->cg_item
.ci_name
= group
->cg_item
.ci_namebuf
;
1431 sd
= configfs_sb
->s_root
->d_fsdata
;
1432 link_group(to_config_group(sd
->s_element
), group
);
1434 mutex_lock_nested(&configfs_sb
->s_root
->d_inode
->i_mutex
,
1437 name
.name
= group
->cg_item
.ci_name
;
1438 name
.len
= strlen(name
.name
);
1439 name
.hash
= full_name_hash(name
.name
, name
.len
);
1442 dentry
= d_alloc(configfs_sb
->s_root
, &name
);
1444 d_add(dentry
, NULL
);
1446 err
= configfs_attach_group(sd
->s_element
, &group
->cg_item
,
1454 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1457 unlink_group(group
);
1458 configfs_release_fs();
1464 void configfs_unregister_subsystem(struct configfs_subsystem
*subsys
)
1466 struct config_group
*group
= &subsys
->su_group
;
1467 struct dentry
*dentry
= group
->cg_item
.ci_dentry
;
1469 if (dentry
->d_parent
!= configfs_sb
->s_root
) {
1470 printk(KERN_ERR
"configfs: Tried to unregister non-subsystem!\n");
1474 mutex_lock_nested(&configfs_sb
->s_root
->d_inode
->i_mutex
,
1476 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
1477 if (configfs_detach_prep(dentry
)) {
1478 printk(KERN_ERR
"configfs: Tried to unregister non-empty subsystem!\n");
1480 configfs_detach_group(&group
->cg_item
);
1481 dentry
->d_inode
->i_flags
|= S_DEAD
;
1482 mutex_unlock(&dentry
->d_inode
->i_mutex
);
1486 mutex_unlock(&configfs_sb
->s_root
->d_inode
->i_mutex
);
1490 unlink_group(group
);
1491 configfs_release_fs();
1494 EXPORT_SYMBOL(configfs_register_subsystem
);
1495 EXPORT_SYMBOL(configfs_unregister_subsystem
);