2 * inode.c - basic inode and dentry operations.
4 * sysfs is Copyright (c) 2001-3 Patrick Mochel
6 * Please see Documentation/filesystems/sysfs.txt for more information.
11 #include <linux/pagemap.h>
12 #include <linux/namei.h>
13 #include <linux/backing-dev.h>
14 #include <linux/capability.h>
15 #include <linux/errno.h>
16 #include <linux/sched.h>
17 #include <asm/semaphore.h>
20 extern struct super_block
* sysfs_sb
;
22 static const struct address_space_operations sysfs_aops
= {
23 .readpage
= simple_readpage
,
24 .prepare_write
= simple_prepare_write
,
25 .commit_write
= simple_commit_write
28 static struct backing_dev_info sysfs_backing_dev_info
= {
29 .ra_pages
= 0, /* No readahead */
30 .capabilities
= BDI_CAP_NO_ACCT_DIRTY
| BDI_CAP_NO_WRITEBACK
,
33 static const struct inode_operations sysfs_inode_operations
={
34 .setattr
= sysfs_setattr
,
37 void sysfs_delete_inode(struct inode
*inode
)
39 /* Free the shadowed directory inode operations */
40 if (sysfs_is_shadowed_inode(inode
)) {
44 return generic_delete_inode(inode
);
47 int sysfs_setattr(struct dentry
* dentry
, struct iattr
* iattr
)
49 struct inode
* inode
= dentry
->d_inode
;
50 struct sysfs_dirent
* sd
= dentry
->d_fsdata
;
51 struct iattr
* sd_iattr
;
52 unsigned int ia_valid
= iattr
->ia_valid
;
58 sd_iattr
= sd
->s_iattr
;
60 error
= inode_change_ok(inode
, iattr
);
64 error
= inode_setattr(inode
, iattr
);
69 /* setting attributes for the first time, allocate now */
70 sd_iattr
= kzalloc(sizeof(struct iattr
), GFP_KERNEL
);
73 /* assign default attributes */
74 sd_iattr
->ia_mode
= sd
->s_mode
;
77 sd_iattr
->ia_atime
= sd_iattr
->ia_mtime
= sd_iattr
->ia_ctime
= CURRENT_TIME
;
78 sd
->s_iattr
= sd_iattr
;
81 /* attributes were changed atleast once in past */
83 if (ia_valid
& ATTR_UID
)
84 sd_iattr
->ia_uid
= iattr
->ia_uid
;
85 if (ia_valid
& ATTR_GID
)
86 sd_iattr
->ia_gid
= iattr
->ia_gid
;
87 if (ia_valid
& ATTR_ATIME
)
88 sd_iattr
->ia_atime
= timespec_trunc(iattr
->ia_atime
,
89 inode
->i_sb
->s_time_gran
);
90 if (ia_valid
& ATTR_MTIME
)
91 sd_iattr
->ia_mtime
= timespec_trunc(iattr
->ia_mtime
,
92 inode
->i_sb
->s_time_gran
);
93 if (ia_valid
& ATTR_CTIME
)
94 sd_iattr
->ia_ctime
= timespec_trunc(iattr
->ia_ctime
,
95 inode
->i_sb
->s_time_gran
);
96 if (ia_valid
& ATTR_MODE
) {
97 umode_t mode
= iattr
->ia_mode
;
99 if (!in_group_p(inode
->i_gid
) && !capable(CAP_FSETID
))
101 sd_iattr
->ia_mode
= sd
->s_mode
= mode
;
107 static inline void set_default_inode_attr(struct inode
* inode
, mode_t mode
)
109 inode
->i_mode
= mode
;
112 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
115 static inline void set_inode_attr(struct inode
* inode
, struct iattr
* iattr
)
117 inode
->i_mode
= iattr
->ia_mode
;
118 inode
->i_uid
= iattr
->ia_uid
;
119 inode
->i_gid
= iattr
->ia_gid
;
120 inode
->i_atime
= iattr
->ia_atime
;
121 inode
->i_mtime
= iattr
->ia_mtime
;
122 inode
->i_ctime
= iattr
->ia_ctime
;
127 * sysfs has a different i_mutex lock order behavior for i_mutex than other
128 * filesystems; sysfs i_mutex is called in many places with subsystem locks
129 * held. At the same time, many of the VFS locking rules do not apply to
130 * sysfs at all (cross directory rename for example). To untangle this mess
131 * (which gives false positives in lockdep), we're giving sysfs inodes their
132 * own class for i_mutex.
134 static struct lock_class_key sysfs_inode_imutex_key
;
136 struct inode
* sysfs_new_inode(mode_t mode
, struct sysfs_dirent
* sd
)
138 struct inode
* inode
= new_inode(sysfs_sb
);
141 inode
->i_mapping
->a_ops
= &sysfs_aops
;
142 inode
->i_mapping
->backing_dev_info
= &sysfs_backing_dev_info
;
143 inode
->i_op
= &sysfs_inode_operations
;
144 inode
->i_ino
= sd
->s_ino
;
145 lockdep_set_class(&inode
->i_mutex
, &sysfs_inode_imutex_key
);
148 /* sysfs_dirent has non-default attributes
149 * get them for the new inode from persistent copy
152 set_inode_attr(inode
, sd
->s_iattr
);
154 set_default_inode_attr(inode
, mode
);
159 int sysfs_create(struct dentry
* dentry
, int mode
, int (*init
)(struct inode
*))
162 struct inode
* inode
= NULL
;
164 if (!dentry
->d_inode
) {
165 struct sysfs_dirent
* sd
= dentry
->d_fsdata
;
166 if ((inode
= sysfs_new_inode(mode
, sd
))) {
167 if (dentry
->d_parent
&& dentry
->d_parent
->d_inode
) {
168 struct inode
*p_inode
= dentry
->d_parent
->d_inode
;
169 p_inode
->i_mtime
= p_inode
->i_ctime
= CURRENT_TIME
;
185 d_instantiate(dentry
, inode
);
187 dget(dentry
); /* pin only directory dentry in core */
194 static inline void orphan_all_buffers(struct inode
*node
)
196 struct sysfs_buffer_collection
*set
;
197 struct sysfs_buffer
*buf
;
199 mutex_lock_nested(&node
->i_mutex
, I_MUTEX_CHILD
);
200 set
= node
->i_private
;
202 list_for_each_entry(buf
, &set
->associates
, associates
) {
208 mutex_unlock(&node
->i_mutex
);
213 * Unhashes the dentry corresponding to given sysfs_dirent
214 * Called with parent inode's i_mutex held.
216 void sysfs_drop_dentry(struct sysfs_dirent
* sd
, struct dentry
* parent
)
218 struct dentry
*dentry
= NULL
;
221 /* We're not holding a reference to ->s_dentry dentry but the
222 * field will stay valid as long as sysfs_lock is held.
224 spin_lock(&sysfs_lock
);
225 spin_lock(&dcache_lock
);
227 /* dget dentry if it's still alive */
228 if (sd
->s_dentry
&& sd
->s_dentry
->d_inode
)
229 dentry
= dget_locked(sd
->s_dentry
);
231 spin_unlock(&dcache_lock
);
232 spin_unlock(&sysfs_lock
);
236 spin_lock(&dcache_lock
);
237 spin_lock(&dentry
->d_lock
);
238 if (!d_unhashed(dentry
) && dentry
->d_inode
) {
239 inode
= dentry
->d_inode
;
240 spin_lock(&inode
->i_lock
);
242 spin_unlock(&inode
->i_lock
);
245 spin_unlock(&dentry
->d_lock
);
246 spin_unlock(&dcache_lock
);
247 simple_unlink(parent
->d_inode
, dentry
);
248 orphan_all_buffers(inode
);
251 spin_unlock(&dentry
->d_lock
);
252 spin_unlock(&dcache_lock
);
259 int sysfs_hash_and_remove(struct dentry
* dir
, const char * name
)
261 struct sysfs_dirent
* sd
;
262 struct sysfs_dirent
* parent_sd
;
268 if (dir
->d_inode
== NULL
)
269 /* no inode means this hasn't been made visible yet */
272 parent_sd
= dir
->d_fsdata
;
273 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_PARENT
);
274 list_for_each_entry(sd
, &parent_sd
->s_children
, s_sibling
) {
277 if (!strcmp(sd
->s_name
, name
)) {
278 list_del_init(&sd
->s_sibling
);
279 sysfs_drop_dentry(sd
, dir
);
284 mutex_unlock(&dir
->d_inode
->i_mutex
);
289 sysfs_deactivate(sd
);