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 user_namespace
*mnt_userns
, struct dentry
*dentry
,
118 struct inode
*inode
= d_inode(dentry
);
119 struct kernfs_node
*kn
= inode
->i_private
;
125 mutex_lock(&kernfs_mutex
);
126 error
= setattr_prepare(&init_user_ns
, dentry
, iattr
);
130 error
= __kernfs_setattr(kn
, iattr
);
134 /* this ignores size changes */
135 setattr_copy(&init_user_ns
, inode
, iattr
);
138 mutex_unlock(&kernfs_mutex
);
142 ssize_t
kernfs_iop_listxattr(struct dentry
*dentry
, char *buf
, size_t size
)
144 struct kernfs_node
*kn
= kernfs_dentry_node(dentry
);
145 struct kernfs_iattrs
*attrs
;
147 attrs
= kernfs_iattrs(kn
);
151 return simple_xattr_list(d_inode(dentry
), &attrs
->xattrs
, buf
, size
);
154 static inline void set_default_inode_attr(struct inode
*inode
, umode_t mode
)
156 inode
->i_mode
= mode
;
157 inode
->i_atime
= inode
->i_mtime
=
158 inode
->i_ctime
= current_time(inode
);
161 static inline void set_inode_attr(struct inode
*inode
,
162 struct kernfs_iattrs
*attrs
)
164 inode
->i_uid
= attrs
->ia_uid
;
165 inode
->i_gid
= attrs
->ia_gid
;
166 inode
->i_atime
= attrs
->ia_atime
;
167 inode
->i_mtime
= attrs
->ia_mtime
;
168 inode
->i_ctime
= attrs
->ia_ctime
;
171 static void kernfs_refresh_inode(struct kernfs_node
*kn
, struct inode
*inode
)
173 struct kernfs_iattrs
*attrs
= kn
->iattr
;
175 inode
->i_mode
= kn
->mode
;
178 * kernfs_node has non-default attributes get them from
179 * persistent copy in kernfs_node.
181 set_inode_attr(inode
, attrs
);
183 if (kernfs_type(kn
) == KERNFS_DIR
)
184 set_nlink(inode
, kn
->dir
.subdirs
+ 2);
187 int kernfs_iop_getattr(struct user_namespace
*mnt_userns
,
188 const struct path
*path
, struct kstat
*stat
,
189 u32 request_mask
, unsigned int query_flags
)
191 struct inode
*inode
= d_inode(path
->dentry
);
192 struct kernfs_node
*kn
= inode
->i_private
;
194 mutex_lock(&kernfs_mutex
);
195 kernfs_refresh_inode(kn
, inode
);
196 mutex_unlock(&kernfs_mutex
);
198 generic_fillattr(&init_user_ns
, inode
, stat
);
202 static void kernfs_init_inode(struct kernfs_node
*kn
, struct inode
*inode
)
205 inode
->i_private
= kn
;
206 inode
->i_mapping
->a_ops
= &kernfs_aops
;
207 inode
->i_op
= &kernfs_iops
;
208 inode
->i_generation
= kernfs_gen(kn
);
210 set_default_inode_attr(inode
, kn
->mode
);
211 kernfs_refresh_inode(kn
, inode
);
213 /* initialize inode according to type */
214 switch (kernfs_type(kn
)) {
216 inode
->i_op
= &kernfs_dir_iops
;
217 inode
->i_fop
= &kernfs_dir_fops
;
218 if (kn
->flags
& KERNFS_EMPTY_DIR
)
219 make_empty_dir_inode(inode
);
222 inode
->i_size
= kn
->attr
.size
;
223 inode
->i_fop
= &kernfs_file_fops
;
226 inode
->i_op
= &kernfs_symlink_iops
;
232 unlock_new_inode(inode
);
236 * kernfs_get_inode - get inode for kernfs_node
238 * @kn: kernfs_node to allocate inode for
240 * Get inode for @kn. If such inode doesn't exist, a new inode is
241 * allocated and basics are initialized. New inode is returned
245 * Kernel thread context (may sleep).
248 * Pointer to allocated inode on success, NULL on failure.
250 struct inode
*kernfs_get_inode(struct super_block
*sb
, struct kernfs_node
*kn
)
254 inode
= iget_locked(sb
, kernfs_ino(kn
));
255 if (inode
&& (inode
->i_state
& I_NEW
))
256 kernfs_init_inode(kn
, inode
);
262 * The kernfs_node serves as both an inode and a directory entry for
263 * kernfs. To prevent the kernfs inode numbers from being freed
264 * prematurely we take a reference to kernfs_node from the kernfs inode. A
265 * super_operations.evict_inode() implementation is needed to drop that
266 * reference upon inode destruction.
268 void kernfs_evict_inode(struct inode
*inode
)
270 struct kernfs_node
*kn
= inode
->i_private
;
272 truncate_inode_pages_final(&inode
->i_data
);
277 int kernfs_iop_permission(struct user_namespace
*mnt_userns
,
278 struct inode
*inode
, int mask
)
280 struct kernfs_node
*kn
;
282 if (mask
& MAY_NOT_BLOCK
)
285 kn
= inode
->i_private
;
287 mutex_lock(&kernfs_mutex
);
288 kernfs_refresh_inode(kn
, inode
);
289 mutex_unlock(&kernfs_mutex
);
291 return generic_permission(&init_user_ns
, inode
, mask
);
294 int kernfs_xattr_get(struct kernfs_node
*kn
, const char *name
,
295 void *value
, size_t size
)
297 struct kernfs_iattrs
*attrs
= kernfs_iattrs_noalloc(kn
);
301 return simple_xattr_get(&attrs
->xattrs
, name
, value
, size
);
304 int kernfs_xattr_set(struct kernfs_node
*kn
, const char *name
,
305 const void *value
, size_t size
, int flags
)
307 struct kernfs_iattrs
*attrs
= kernfs_iattrs(kn
);
311 return simple_xattr_set(&attrs
->xattrs
, name
, value
, size
, flags
, NULL
);
314 static int kernfs_vfs_xattr_get(const struct xattr_handler
*handler
,
315 struct dentry
*unused
, struct inode
*inode
,
316 const char *suffix
, void *value
, size_t size
)
318 const char *name
= xattr_full_name(handler
, suffix
);
319 struct kernfs_node
*kn
= inode
->i_private
;
321 return kernfs_xattr_get(kn
, name
, value
, size
);
324 static int kernfs_vfs_xattr_set(const struct xattr_handler
*handler
,
325 struct user_namespace
*mnt_userns
,
326 struct dentry
*unused
, struct inode
*inode
,
327 const char *suffix
, const void *value
,
328 size_t size
, int flags
)
330 const char *name
= xattr_full_name(handler
, suffix
);
331 struct kernfs_node
*kn
= inode
->i_private
;
333 return kernfs_xattr_set(kn
, name
, value
, size
, flags
);
336 static int kernfs_vfs_user_xattr_add(struct kernfs_node
*kn
,
337 const char *full_name
,
338 struct simple_xattrs
*xattrs
,
339 const void *value
, size_t size
, int flags
)
341 atomic_t
*sz
= &kn
->iattr
->user_xattr_size
;
342 atomic_t
*nr
= &kn
->iattr
->nr_user_xattrs
;
343 ssize_t removed_size
;
346 if (atomic_inc_return(nr
) > KERNFS_MAX_USER_XATTRS
) {
351 if (atomic_add_return(size
, sz
) > KERNFS_USER_XATTR_SIZE_LIMIT
) {
356 ret
= simple_xattr_set(xattrs
, full_name
, value
, size
, flags
,
359 if (!ret
&& removed_size
>= 0)
364 atomic_sub(size
, sz
);
370 static int kernfs_vfs_user_xattr_rm(struct kernfs_node
*kn
,
371 const char *full_name
,
372 struct simple_xattrs
*xattrs
,
373 const void *value
, size_t size
, int flags
)
375 atomic_t
*sz
= &kn
->iattr
->user_xattr_size
;
376 atomic_t
*nr
= &kn
->iattr
->nr_user_xattrs
;
377 ssize_t removed_size
;
380 ret
= simple_xattr_set(xattrs
, full_name
, value
, size
, flags
,
383 if (removed_size
>= 0) {
384 atomic_sub(removed_size
, sz
);
391 static int kernfs_vfs_user_xattr_set(const struct xattr_handler
*handler
,
392 struct user_namespace
*mnt_userns
,
393 struct dentry
*unused
, struct inode
*inode
,
394 const char *suffix
, const void *value
,
395 size_t size
, int flags
)
397 const char *full_name
= xattr_full_name(handler
, suffix
);
398 struct kernfs_node
*kn
= inode
->i_private
;
399 struct kernfs_iattrs
*attrs
;
401 if (!(kernfs_root(kn
)->flags
& KERNFS_ROOT_SUPPORT_USER_XATTR
))
404 attrs
= kernfs_iattrs(kn
);
409 return kernfs_vfs_user_xattr_add(kn
, full_name
, &attrs
->xattrs
,
412 return kernfs_vfs_user_xattr_rm(kn
, full_name
, &attrs
->xattrs
,
417 static const struct xattr_handler kernfs_trusted_xattr_handler
= {
418 .prefix
= XATTR_TRUSTED_PREFIX
,
419 .get
= kernfs_vfs_xattr_get
,
420 .set
= kernfs_vfs_xattr_set
,
423 static const struct xattr_handler kernfs_security_xattr_handler
= {
424 .prefix
= XATTR_SECURITY_PREFIX
,
425 .get
= kernfs_vfs_xattr_get
,
426 .set
= kernfs_vfs_xattr_set
,
429 static const struct xattr_handler kernfs_user_xattr_handler
= {
430 .prefix
= XATTR_USER_PREFIX
,
431 .get
= kernfs_vfs_xattr_get
,
432 .set
= kernfs_vfs_user_xattr_set
,
435 const struct xattr_handler
*kernfs_xattr_handlers
[] = {
436 &kernfs_trusted_xattr_handler
,
437 &kernfs_security_xattr_handler
,
438 &kernfs_user_xattr_handler
,