2 * fs/kernfs/inode.c - kernfs inode implementation
4 * Copyright (c) 2001-3 Patrick Mochel
5 * Copyright (c) 2007 SUSE Linux Products GmbH
6 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
8 * This file is released under the GPLv2.
11 #include <linux/pagemap.h>
12 #include <linux/backing-dev.h>
13 #include <linux/capability.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/xattr.h>
17 #include <linux/security.h>
19 #include "kernfs-internal.h"
21 static const struct address_space_operations sysfs_aops
= {
22 .readpage
= simple_readpage
,
23 .write_begin
= simple_write_begin
,
24 .write_end
= simple_write_end
,
27 static struct backing_dev_info sysfs_backing_dev_info
= {
29 .ra_pages
= 0, /* No readahead */
30 .capabilities
= BDI_CAP_NO_ACCT_AND_WRITEBACK
,
33 static const struct inode_operations sysfs_inode_operations
= {
34 .permission
= sysfs_permission
,
35 .setattr
= sysfs_setattr
,
36 .getattr
= sysfs_getattr
,
37 .setxattr
= sysfs_setxattr
,
38 .removexattr
= sysfs_removexattr
,
39 .getxattr
= sysfs_getxattr
,
40 .listxattr
= sysfs_listxattr
,
43 void __init
sysfs_inode_init(void)
45 if (bdi_init(&sysfs_backing_dev_info
))
46 panic("failed to init sysfs_backing_dev_info");
49 static struct sysfs_inode_attrs
*sysfs_inode_attrs(struct sysfs_dirent
*sd
)
56 sd
->s_iattr
= kzalloc(sizeof(struct sysfs_inode_attrs
), GFP_KERNEL
);
59 iattrs
= &sd
->s_iattr
->ia_iattr
;
61 /* assign default attributes */
62 iattrs
->ia_mode
= sd
->s_mode
;
63 iattrs
->ia_uid
= GLOBAL_ROOT_UID
;
64 iattrs
->ia_gid
= GLOBAL_ROOT_GID
;
65 iattrs
->ia_atime
= iattrs
->ia_mtime
= iattrs
->ia_ctime
= CURRENT_TIME
;
67 simple_xattrs_init(&sd
->s_iattr
->xattrs
);
72 static int __kernfs_setattr(struct sysfs_dirent
*sd
, const struct iattr
*iattr
)
74 struct sysfs_inode_attrs
*attrs
;
76 unsigned int ia_valid
= iattr
->ia_valid
;
78 attrs
= sysfs_inode_attrs(sd
);
82 iattrs
= &attrs
->ia_iattr
;
84 if (ia_valid
& ATTR_UID
)
85 iattrs
->ia_uid
= iattr
->ia_uid
;
86 if (ia_valid
& ATTR_GID
)
87 iattrs
->ia_gid
= iattr
->ia_gid
;
88 if (ia_valid
& ATTR_ATIME
)
89 iattrs
->ia_atime
= iattr
->ia_atime
;
90 if (ia_valid
& ATTR_MTIME
)
91 iattrs
->ia_mtime
= iattr
->ia_mtime
;
92 if (ia_valid
& ATTR_CTIME
)
93 iattrs
->ia_ctime
= iattr
->ia_ctime
;
94 if (ia_valid
& ATTR_MODE
) {
95 umode_t mode
= iattr
->ia_mode
;
96 iattrs
->ia_mode
= sd
->s_mode
= mode
;
102 * kernfs_setattr - set iattr on a node
104 * @iattr: iattr to set
106 * Returns 0 on success, -errno on failure.
108 int kernfs_setattr(struct sysfs_dirent
*sd
, const struct iattr
*iattr
)
112 mutex_lock(&sysfs_mutex
);
113 ret
= __kernfs_setattr(sd
, iattr
);
114 mutex_unlock(&sysfs_mutex
);
118 int sysfs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
120 struct inode
*inode
= dentry
->d_inode
;
121 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
127 mutex_lock(&sysfs_mutex
);
128 error
= inode_change_ok(inode
, iattr
);
132 error
= __kernfs_setattr(sd
, iattr
);
136 /* this ignores size changes */
137 setattr_copy(inode
, iattr
);
140 mutex_unlock(&sysfs_mutex
);
144 static int sysfs_sd_setsecdata(struct sysfs_dirent
*sd
, void **secdata
,
147 struct sysfs_inode_attrs
*attrs
;
149 size_t old_secdata_len
;
151 attrs
= sysfs_inode_attrs(sd
);
155 old_secdata
= attrs
->ia_secdata
;
156 old_secdata_len
= attrs
->ia_secdata_len
;
158 attrs
->ia_secdata
= *secdata
;
159 attrs
->ia_secdata_len
= *secdata_len
;
161 *secdata
= old_secdata
;
162 *secdata_len
= old_secdata_len
;
166 int sysfs_setxattr(struct dentry
*dentry
, const char *name
, const void *value
,
167 size_t size
, int flags
)
169 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
170 struct sysfs_inode_attrs
*attrs
;
175 attrs
= sysfs_inode_attrs(sd
);
179 if (!strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
)) {
180 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
181 error
= security_inode_setsecurity(dentry
->d_inode
, suffix
,
185 error
= security_inode_getsecctx(dentry
->d_inode
,
186 &secdata
, &secdata_len
);
190 mutex_lock(&sysfs_mutex
);
191 error
= sysfs_sd_setsecdata(sd
, &secdata
, &secdata_len
);
192 mutex_unlock(&sysfs_mutex
);
195 security_release_secctx(secdata
, secdata_len
);
197 } else if (!strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
)) {
198 return simple_xattr_set(&attrs
->xattrs
, name
, value
, size
,
205 int sysfs_removexattr(struct dentry
*dentry
, const char *name
)
207 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
208 struct sysfs_inode_attrs
*attrs
;
210 attrs
= sysfs_inode_attrs(sd
);
214 return simple_xattr_remove(&attrs
->xattrs
, name
);
217 ssize_t
sysfs_getxattr(struct dentry
*dentry
, const char *name
, void *buf
,
220 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
221 struct sysfs_inode_attrs
*attrs
;
223 attrs
= sysfs_inode_attrs(sd
);
227 return simple_xattr_get(&attrs
->xattrs
, name
, buf
, size
);
230 ssize_t
sysfs_listxattr(struct dentry
*dentry
, char *buf
, size_t size
)
232 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
233 struct sysfs_inode_attrs
*attrs
;
235 attrs
= sysfs_inode_attrs(sd
);
239 return simple_xattr_list(&attrs
->xattrs
, buf
, size
);
242 static inline void set_default_inode_attr(struct inode
*inode
, umode_t mode
)
244 inode
->i_mode
= mode
;
245 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
248 static inline void set_inode_attr(struct inode
*inode
, struct iattr
*iattr
)
250 inode
->i_uid
= iattr
->ia_uid
;
251 inode
->i_gid
= iattr
->ia_gid
;
252 inode
->i_atime
= iattr
->ia_atime
;
253 inode
->i_mtime
= iattr
->ia_mtime
;
254 inode
->i_ctime
= iattr
->ia_ctime
;
257 static void sysfs_refresh_inode(struct sysfs_dirent
*sd
, struct inode
*inode
)
259 struct sysfs_inode_attrs
*attrs
= sd
->s_iattr
;
261 inode
->i_mode
= sd
->s_mode
;
263 /* sysfs_dirent has non-default attributes
264 * get them from persistent copy in sysfs_dirent
266 set_inode_attr(inode
, &attrs
->ia_iattr
);
267 security_inode_notifysecctx(inode
, attrs
->ia_secdata
,
268 attrs
->ia_secdata_len
);
271 if (sysfs_type(sd
) == SYSFS_DIR
)
272 set_nlink(inode
, sd
->s_dir
.subdirs
+ 2);
275 int sysfs_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
278 struct sysfs_dirent
*sd
= dentry
->d_fsdata
;
279 struct inode
*inode
= dentry
->d_inode
;
281 mutex_lock(&sysfs_mutex
);
282 sysfs_refresh_inode(sd
, inode
);
283 mutex_unlock(&sysfs_mutex
);
285 generic_fillattr(inode
, stat
);
289 static void sysfs_init_inode(struct sysfs_dirent
*sd
, struct inode
*inode
)
292 inode
->i_private
= sd
;
293 inode
->i_mapping
->a_ops
= &sysfs_aops
;
294 inode
->i_mapping
->backing_dev_info
= &sysfs_backing_dev_info
;
295 inode
->i_op
= &sysfs_inode_operations
;
297 set_default_inode_attr(inode
, sd
->s_mode
);
298 sysfs_refresh_inode(sd
, inode
);
300 /* initialize inode according to type */
301 switch (sysfs_type(sd
)) {
303 inode
->i_op
= &sysfs_dir_inode_operations
;
304 inode
->i_fop
= &sysfs_dir_operations
;
306 case SYSFS_KOBJ_ATTR
:
307 inode
->i_size
= sd
->s_attr
.size
;
308 inode
->i_fop
= &kernfs_file_operations
;
310 case SYSFS_KOBJ_LINK
:
311 inode
->i_op
= &sysfs_symlink_inode_operations
;
317 unlock_new_inode(inode
);
321 * sysfs_get_inode - get inode for sysfs_dirent
323 * @sd: sysfs_dirent to allocate inode for
325 * Get inode for @sd. If such inode doesn't exist, a new inode
326 * is allocated and basics are initialized. New inode is
330 * Kernel thread context (may sleep).
333 * Pointer to allocated inode on success, NULL on failure.
335 struct inode
*sysfs_get_inode(struct super_block
*sb
, struct sysfs_dirent
*sd
)
339 inode
= iget_locked(sb
, sd
->s_ino
);
340 if (inode
&& (inode
->i_state
& I_NEW
))
341 sysfs_init_inode(sd
, inode
);
347 * The sysfs_dirent serves as both an inode and a directory entry for sysfs.
348 * To prevent the sysfs inode numbers from being freed prematurely we take a
349 * reference to sysfs_dirent from the sysfs inode. A
350 * super_operations.evict_inode() implementation is needed to drop that
351 * reference upon inode destruction.
353 void sysfs_evict_inode(struct inode
*inode
)
355 struct sysfs_dirent
*sd
= inode
->i_private
;
357 truncate_inode_pages(&inode
->i_data
, 0);
362 int sysfs_permission(struct inode
*inode
, int mask
)
364 struct sysfs_dirent
*sd
;
366 if (mask
& MAY_NOT_BLOCK
)
369 sd
= inode
->i_private
;
371 mutex_lock(&sysfs_mutex
);
372 sysfs_refresh_inode(sd
, inode
);
373 mutex_unlock(&sysfs_mutex
);
375 return generic_permission(inode
, mask
);