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 kernfs_aops
= {
22 .readpage
= simple_readpage
,
23 .write_begin
= simple_write_begin
,
24 .write_end
= simple_write_end
,
27 static const struct inode_operations kernfs_iops
= {
28 .permission
= kernfs_iop_permission
,
29 .setattr
= kernfs_iop_setattr
,
30 .getattr
= kernfs_iop_getattr
,
31 .listxattr
= kernfs_iop_listxattr
,
34 static struct kernfs_iattrs
*__kernfs_iattrs(struct kernfs_node
*kn
, int alloc
)
36 static DEFINE_MUTEX(iattr_mutex
);
37 struct kernfs_iattrs
*ret
;
39 mutex_lock(&iattr_mutex
);
41 if (kn
->iattr
|| !alloc
)
44 kn
->iattr
= kmem_cache_zalloc(kernfs_iattrs_cache
, GFP_KERNEL
);
48 /* assign default attributes */
49 kn
->iattr
->ia_uid
= GLOBAL_ROOT_UID
;
50 kn
->iattr
->ia_gid
= GLOBAL_ROOT_GID
;
52 ktime_get_real_ts64(&kn
->iattr
->ia_atime
);
53 kn
->iattr
->ia_mtime
= kn
->iattr
->ia_atime
;
54 kn
->iattr
->ia_ctime
= kn
->iattr
->ia_atime
;
56 simple_xattrs_init(&kn
->iattr
->xattrs
);
59 mutex_unlock(&iattr_mutex
);
63 static struct kernfs_iattrs
*kernfs_iattrs(struct kernfs_node
*kn
)
65 return __kernfs_iattrs(kn
, 1);
68 static struct kernfs_iattrs
*kernfs_iattrs_noalloc(struct kernfs_node
*kn
)
70 return __kernfs_iattrs(kn
, 0);
73 int __kernfs_setattr(struct kernfs_node
*kn
, const struct iattr
*iattr
)
75 struct kernfs_iattrs
*attrs
;
76 unsigned int ia_valid
= iattr
->ia_valid
;
78 attrs
= kernfs_iattrs(kn
);
82 if (ia_valid
& ATTR_UID
)
83 attrs
->ia_uid
= iattr
->ia_uid
;
84 if (ia_valid
& ATTR_GID
)
85 attrs
->ia_gid
= iattr
->ia_gid
;
86 if (ia_valid
& ATTR_ATIME
)
87 attrs
->ia_atime
= iattr
->ia_atime
;
88 if (ia_valid
& ATTR_MTIME
)
89 attrs
->ia_mtime
= iattr
->ia_mtime
;
90 if (ia_valid
& ATTR_CTIME
)
91 attrs
->ia_ctime
= iattr
->ia_ctime
;
92 if (ia_valid
& ATTR_MODE
)
93 kn
->mode
= iattr
->ia_mode
;
98 * kernfs_setattr - set iattr on a node
100 * @iattr: iattr to set
102 * Returns 0 on success, -errno on failure.
104 int kernfs_setattr(struct kernfs_node
*kn
, const struct iattr
*iattr
)
108 mutex_lock(&kernfs_mutex
);
109 ret
= __kernfs_setattr(kn
, iattr
);
110 mutex_unlock(&kernfs_mutex
);
114 int kernfs_iop_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
116 struct inode
*inode
= d_inode(dentry
);
117 struct kernfs_node
*kn
= inode
->i_private
;
123 mutex_lock(&kernfs_mutex
);
124 error
= setattr_prepare(dentry
, iattr
);
128 error
= __kernfs_setattr(kn
, iattr
);
132 /* this ignores size changes */
133 setattr_copy(inode
, iattr
);
136 mutex_unlock(&kernfs_mutex
);
140 ssize_t
kernfs_iop_listxattr(struct dentry
*dentry
, char *buf
, size_t size
)
142 struct kernfs_node
*kn
= kernfs_dentry_node(dentry
);
143 struct kernfs_iattrs
*attrs
;
145 attrs
= kernfs_iattrs(kn
);
149 return simple_xattr_list(d_inode(dentry
), &attrs
->xattrs
, buf
, size
);
152 static inline void set_default_inode_attr(struct inode
*inode
, umode_t mode
)
154 inode
->i_mode
= mode
;
155 inode
->i_atime
= inode
->i_mtime
=
156 inode
->i_ctime
= current_time(inode
);
159 static inline void set_inode_attr(struct inode
*inode
,
160 struct kernfs_iattrs
*attrs
)
162 struct super_block
*sb
= inode
->i_sb
;
163 inode
->i_uid
= attrs
->ia_uid
;
164 inode
->i_gid
= attrs
->ia_gid
;
165 inode
->i_atime
= timespec64_trunc(attrs
->ia_atime
, sb
->s_time_gran
);
166 inode
->i_mtime
= timespec64_trunc(attrs
->ia_mtime
, sb
->s_time_gran
);
167 inode
->i_ctime
= timespec64_trunc(attrs
->ia_ctime
, sb
->s_time_gran
);
170 static void kernfs_refresh_inode(struct kernfs_node
*kn
, struct inode
*inode
)
172 struct kernfs_iattrs
*attrs
= kn
->iattr
;
174 inode
->i_mode
= kn
->mode
;
177 * kernfs_node has non-default attributes get them from
178 * persistent copy in kernfs_node.
180 set_inode_attr(inode
, attrs
);
182 if (kernfs_type(kn
) == KERNFS_DIR
)
183 set_nlink(inode
, kn
->dir
.subdirs
+ 2);
186 int kernfs_iop_getattr(const struct path
*path
, struct kstat
*stat
,
187 u32 request_mask
, unsigned int query_flags
)
189 struct inode
*inode
= d_inode(path
->dentry
);
190 struct kernfs_node
*kn
= inode
->i_private
;
192 mutex_lock(&kernfs_mutex
);
193 kernfs_refresh_inode(kn
, inode
);
194 mutex_unlock(&kernfs_mutex
);
196 generic_fillattr(inode
, stat
);
200 static void kernfs_init_inode(struct kernfs_node
*kn
, struct inode
*inode
)
203 inode
->i_private
= kn
;
204 inode
->i_mapping
->a_ops
= &kernfs_aops
;
205 inode
->i_op
= &kernfs_iops
;
206 inode
->i_generation
= kn
->id
.generation
;
208 set_default_inode_attr(inode
, kn
->mode
);
209 kernfs_refresh_inode(kn
, inode
);
211 /* initialize inode according to type */
212 switch (kernfs_type(kn
)) {
214 inode
->i_op
= &kernfs_dir_iops
;
215 inode
->i_fop
= &kernfs_dir_fops
;
216 if (kn
->flags
& KERNFS_EMPTY_DIR
)
217 make_empty_dir_inode(inode
);
220 inode
->i_size
= kn
->attr
.size
;
221 inode
->i_fop
= &kernfs_file_fops
;
224 inode
->i_op
= &kernfs_symlink_iops
;
230 unlock_new_inode(inode
);
234 * kernfs_get_inode - get inode for kernfs_node
236 * @kn: kernfs_node to allocate inode for
238 * Get inode for @kn. If such inode doesn't exist, a new inode is
239 * allocated and basics are initialized. New inode is returned
243 * Kernel thread context (may sleep).
246 * Pointer to allocated inode on success, NULL on failure.
248 struct inode
*kernfs_get_inode(struct super_block
*sb
, struct kernfs_node
*kn
)
252 inode
= iget_locked(sb
, kn
->id
.ino
);
253 if (inode
&& (inode
->i_state
& I_NEW
))
254 kernfs_init_inode(kn
, inode
);
260 * The kernfs_node serves as both an inode and a directory entry for
261 * kernfs. To prevent the kernfs inode numbers from being freed
262 * prematurely we take a reference to kernfs_node from the kernfs inode. A
263 * super_operations.evict_inode() implementation is needed to drop that
264 * reference upon inode destruction.
266 void kernfs_evict_inode(struct inode
*inode
)
268 struct kernfs_node
*kn
= inode
->i_private
;
270 truncate_inode_pages_final(&inode
->i_data
);
275 int kernfs_iop_permission(struct inode
*inode
, int mask
)
277 struct kernfs_node
*kn
;
279 if (mask
& MAY_NOT_BLOCK
)
282 kn
= inode
->i_private
;
284 mutex_lock(&kernfs_mutex
);
285 kernfs_refresh_inode(kn
, inode
);
286 mutex_unlock(&kernfs_mutex
);
288 return generic_permission(inode
, mask
);
291 static int kernfs_node_xattr_get(const struct xattr_handler
*handler
,
292 struct kernfs_node
*kn
, const char *suffix
,
293 void *value
, size_t size
)
295 const char *name
= xattr_full_name(handler
, suffix
);
296 struct kernfs_iattrs
*attrs
;
298 attrs
= kernfs_iattrs_noalloc(kn
);
302 return simple_xattr_get(&attrs
->xattrs
, name
, value
, size
);
305 static int kernfs_node_xattr_set(const struct xattr_handler
*handler
,
306 struct kernfs_node
*kn
, const char *suffix
,
307 const void *value
, size_t size
, int flags
)
309 const char *name
= xattr_full_name(handler
, suffix
);
310 struct kernfs_iattrs
*attrs
;
312 attrs
= kernfs_iattrs(kn
);
316 return simple_xattr_set(&attrs
->xattrs
, name
, value
, size
, flags
);
319 static int kernfs_xattr_get(const struct xattr_handler
*handler
,
320 struct dentry
*unused
, struct inode
*inode
,
321 const char *suffix
, void *value
, size_t size
)
323 struct kernfs_node
*kn
= inode
->i_private
;
325 return kernfs_node_xattr_get(handler
, kn
, suffix
, value
, size
);
328 static int kernfs_xattr_set(const struct xattr_handler
*handler
,
329 struct dentry
*unused
, struct inode
*inode
,
330 const char *suffix
, const void *value
,
331 size_t size
, int flags
)
333 struct kernfs_node
*kn
= inode
->i_private
;
335 return kernfs_node_xattr_set(handler
, kn
, suffix
, value
, size
, flags
);
338 static const struct xattr_handler kernfs_trusted_xattr_handler
= {
339 .prefix
= XATTR_TRUSTED_PREFIX
,
340 .get
= kernfs_xattr_get
,
341 .set
= kernfs_xattr_set
,
344 static const struct xattr_handler kernfs_security_xattr_handler
= {
345 .prefix
= XATTR_SECURITY_PREFIX
,
346 .get
= kernfs_xattr_get
,
347 .set
= kernfs_xattr_set
,
350 const struct xattr_handler
*kernfs_xattr_handlers
[] = {
351 &kernfs_trusted_xattr_handler
,
352 &kernfs_security_xattr_handler
,
356 int kernfs_security_xattr_get(struct kernfs_node
*kn
, const char *suffix
,
357 void *value
, size_t size
)
359 return kernfs_node_xattr_get(&kernfs_security_xattr_handler
,
360 kn
, suffix
, value
, size
);
363 int kernfs_security_xattr_set(struct kernfs_node
*kn
, const char *suffix
,
364 void *value
, size_t size
, int flags
)
366 return kernfs_node_xattr_set(&kernfs_security_xattr_handler
,
367 kn
, suffix
, value
, size
, flags
);