1 // SPDX-License-Identifier: GPL-2.0-only
3 * fs/kernfs/inode.c - kernfs inode implementation
5 * Copyright (c) 2001-3 Patrick Mochel
6 * Copyright (c) 2007 SUSE Linux Products GmbH
7 * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
10 #include <linux/pagemap.h>
11 #include <linux/backing-dev.h>
12 #include <linux/capability.h>
13 #include <linux/errno.h>
14 #include <linux/slab.h>
15 #include <linux/xattr.h>
16 #include <linux/security.h>
18 #include "kernfs-internal.h"
20 static const struct address_space_operations kernfs_aops
= {
21 .readpage
= simple_readpage
,
22 .write_begin
= simple_write_begin
,
23 .write_end
= simple_write_end
,
26 static const struct inode_operations kernfs_iops
= {
27 .permission
= kernfs_iop_permission
,
28 .setattr
= kernfs_iop_setattr
,
29 .getattr
= kernfs_iop_getattr
,
30 .listxattr
= kernfs_iop_listxattr
,
33 static struct kernfs_iattrs
*__kernfs_iattrs(struct kernfs_node
*kn
, int alloc
)
35 static DEFINE_MUTEX(iattr_mutex
);
36 struct kernfs_iattrs
*ret
;
38 mutex_lock(&iattr_mutex
);
40 if (kn
->iattr
|| !alloc
)
43 kn
->iattr
= kmem_cache_zalloc(kernfs_iattrs_cache
, GFP_KERNEL
);
47 /* assign default attributes */
48 kn
->iattr
->ia_uid
= GLOBAL_ROOT_UID
;
49 kn
->iattr
->ia_gid
= GLOBAL_ROOT_GID
;
51 ktime_get_real_ts64(&kn
->iattr
->ia_atime
);
52 kn
->iattr
->ia_mtime
= kn
->iattr
->ia_atime
;
53 kn
->iattr
->ia_ctime
= kn
->iattr
->ia_atime
;
55 simple_xattrs_init(&kn
->iattr
->xattrs
);
56 atomic_set(&kn
->iattr
->nr_user_xattrs
, 0);
57 atomic_set(&kn
->iattr
->user_xattr_size
, 0);
60 mutex_unlock(&iattr_mutex
);
64 static struct kernfs_iattrs
*kernfs_iattrs(struct kernfs_node
*kn
)
66 return __kernfs_iattrs(kn
, 1);
69 static struct kernfs_iattrs
*kernfs_iattrs_noalloc(struct kernfs_node
*kn
)
71 return __kernfs_iattrs(kn
, 0);
74 int __kernfs_setattr(struct kernfs_node
*kn
, const struct iattr
*iattr
)
76 struct kernfs_iattrs
*attrs
;
77 unsigned int ia_valid
= iattr
->ia_valid
;
79 attrs
= kernfs_iattrs(kn
);
83 if (ia_valid
& ATTR_UID
)
84 attrs
->ia_uid
= iattr
->ia_uid
;
85 if (ia_valid
& ATTR_GID
)
86 attrs
->ia_gid
= iattr
->ia_gid
;
87 if (ia_valid
& ATTR_ATIME
)
88 attrs
->ia_atime
= iattr
->ia_atime
;
89 if (ia_valid
& ATTR_MTIME
)
90 attrs
->ia_mtime
= iattr
->ia_mtime
;
91 if (ia_valid
& ATTR_CTIME
)
92 attrs
->ia_ctime
= iattr
->ia_ctime
;
93 if (ia_valid
& ATTR_MODE
)
94 kn
->mode
= iattr
->ia_mode
;
99 * kernfs_setattr - set iattr on a node
101 * @iattr: iattr to set
103 * Returns 0 on success, -errno on failure.
105 int kernfs_setattr(struct kernfs_node
*kn
, const struct iattr
*iattr
)
109 mutex_lock(&kernfs_mutex
);
110 ret
= __kernfs_setattr(kn
, iattr
);
111 mutex_unlock(&kernfs_mutex
);
115 int kernfs_iop_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
117 struct inode
*inode
= d_inode(dentry
);
118 struct kernfs_node
*kn
= inode
->i_private
;
124 mutex_lock(&kernfs_mutex
);
125 error
= setattr_prepare(dentry
, iattr
);
129 error
= __kernfs_setattr(kn
, iattr
);
133 /* this ignores size changes */
134 setattr_copy(inode
, iattr
);
137 mutex_unlock(&kernfs_mutex
);
141 ssize_t
kernfs_iop_listxattr(struct dentry
*dentry
, char *buf
, size_t size
)
143 struct kernfs_node
*kn
= kernfs_dentry_node(dentry
);
144 struct kernfs_iattrs
*attrs
;
146 attrs
= kernfs_iattrs(kn
);
150 return simple_xattr_list(d_inode(dentry
), &attrs
->xattrs
, buf
, size
);
153 static inline void set_default_inode_attr(struct inode
*inode
, umode_t mode
)
155 inode
->i_mode
= mode
;
156 inode
->i_atime
= inode
->i_mtime
=
157 inode
->i_ctime
= current_time(inode
);
160 static inline void set_inode_attr(struct inode
*inode
,
161 struct kernfs_iattrs
*attrs
)
163 inode
->i_uid
= attrs
->ia_uid
;
164 inode
->i_gid
= attrs
->ia_gid
;
165 inode
->i_atime
= attrs
->ia_atime
;
166 inode
->i_mtime
= attrs
->ia_mtime
;
167 inode
->i_ctime
= attrs
->ia_ctime
;
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
= kernfs_gen(kn
);
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
, kernfs_ino(kn
));
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 int kernfs_xattr_get(struct kernfs_node
*kn
, const char *name
,
292 void *value
, size_t size
)
294 struct kernfs_iattrs
*attrs
= kernfs_iattrs_noalloc(kn
);
298 return simple_xattr_get(&attrs
->xattrs
, name
, value
, size
);
301 int kernfs_xattr_set(struct kernfs_node
*kn
, const char *name
,
302 const void *value
, size_t size
, int flags
)
304 struct kernfs_iattrs
*attrs
= kernfs_iattrs(kn
);
308 return simple_xattr_set(&attrs
->xattrs
, name
, value
, size
, flags
, NULL
);
311 static int kernfs_vfs_xattr_get(const struct xattr_handler
*handler
,
312 struct dentry
*unused
, struct inode
*inode
,
313 const char *suffix
, void *value
, size_t size
)
315 const char *name
= xattr_full_name(handler
, suffix
);
316 struct kernfs_node
*kn
= inode
->i_private
;
318 return kernfs_xattr_get(kn
, name
, value
, size
);
321 static int kernfs_vfs_xattr_set(const struct xattr_handler
*handler
,
322 struct dentry
*unused
, struct inode
*inode
,
323 const char *suffix
, const void *value
,
324 size_t size
, int flags
)
326 const char *name
= xattr_full_name(handler
, suffix
);
327 struct kernfs_node
*kn
= inode
->i_private
;
329 return kernfs_xattr_set(kn
, name
, value
, size
, flags
);
332 static int kernfs_vfs_user_xattr_add(struct kernfs_node
*kn
,
333 const char *full_name
,
334 struct simple_xattrs
*xattrs
,
335 const void *value
, size_t size
, int flags
)
337 atomic_t
*sz
= &kn
->iattr
->user_xattr_size
;
338 atomic_t
*nr
= &kn
->iattr
->nr_user_xattrs
;
339 ssize_t removed_size
;
342 if (atomic_inc_return(nr
) > KERNFS_MAX_USER_XATTRS
) {
347 if (atomic_add_return(size
, sz
) > KERNFS_USER_XATTR_SIZE_LIMIT
) {
352 ret
= simple_xattr_set(xattrs
, full_name
, value
, size
, flags
,
355 if (!ret
&& removed_size
>= 0)
360 atomic_sub(size
, sz
);
366 static int kernfs_vfs_user_xattr_rm(struct kernfs_node
*kn
,
367 const char *full_name
,
368 struct simple_xattrs
*xattrs
,
369 const void *value
, size_t size
, int flags
)
371 atomic_t
*sz
= &kn
->iattr
->user_xattr_size
;
372 atomic_t
*nr
= &kn
->iattr
->nr_user_xattrs
;
373 ssize_t removed_size
;
376 ret
= simple_xattr_set(xattrs
, full_name
, value
, size
, flags
,
379 if (removed_size
>= 0) {
380 atomic_sub(removed_size
, sz
);
387 static int kernfs_vfs_user_xattr_set(const struct xattr_handler
*handler
,
388 struct dentry
*unused
, struct inode
*inode
,
389 const char *suffix
, const void *value
,
390 size_t size
, int flags
)
392 const char *full_name
= xattr_full_name(handler
, suffix
);
393 struct kernfs_node
*kn
= inode
->i_private
;
394 struct kernfs_iattrs
*attrs
;
396 if (!(kernfs_root(kn
)->flags
& KERNFS_ROOT_SUPPORT_USER_XATTR
))
399 attrs
= kernfs_iattrs(kn
);
404 return kernfs_vfs_user_xattr_add(kn
, full_name
, &attrs
->xattrs
,
407 return kernfs_vfs_user_xattr_rm(kn
, full_name
, &attrs
->xattrs
,
412 static const struct xattr_handler kernfs_trusted_xattr_handler
= {
413 .prefix
= XATTR_TRUSTED_PREFIX
,
414 .get
= kernfs_vfs_xattr_get
,
415 .set
= kernfs_vfs_xattr_set
,
418 static const struct xattr_handler kernfs_security_xattr_handler
= {
419 .prefix
= XATTR_SECURITY_PREFIX
,
420 .get
= kernfs_vfs_xattr_get
,
421 .set
= kernfs_vfs_xattr_set
,
424 static const struct xattr_handler kernfs_user_xattr_handler
= {
425 .prefix
= XATTR_USER_PREFIX
,
426 .get
= kernfs_vfs_xattr_get
,
427 .set
= kernfs_vfs_user_xattr_set
,
430 const struct xattr_handler
*kernfs_xattr_handlers
[] = {
431 &kernfs_trusted_xattr_handler
,
432 &kernfs_security_xattr_handler
,
433 &kernfs_user_xattr_handler
,