inode.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * fs/kernfs/inode.c - kernfs inode implementation
  4 *
  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>
  8 */
  9
 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>
 17
 18#include "kernfs-internal.h"
 19
 20static const struct inode_operations kernfs_iops = {
 21	.permission	= kernfs_iop_permission,
 22	.setattr	= kernfs_iop_setattr,
 23	.getattr	= kernfs_iop_getattr,
 24	.listxattr	= kernfs_iop_listxattr,
 25};
 26
 27static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, bool alloc)
 28{
 29	struct kernfs_iattrs *ret __free(kfree) = NULL;
 30	struct kernfs_iattrs *attr;
 31
 32	attr = READ_ONCE(kn->iattr);
 33	if (attr || !alloc)
 34		return attr;
 35
 36	ret = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL);
 37	if (!ret)
 38		return NULL;
 39
 40	/* assign default attributes */
 41	ret->ia_uid = GLOBAL_ROOT_UID;
 42	ret->ia_gid = GLOBAL_ROOT_GID;
 43
 44	ktime_get_real_ts64(&ret->ia_atime);
 45	ret->ia_mtime = ret->ia_atime;
 46	ret->ia_ctime = ret->ia_atime;
 47
 48	simple_xattrs_init(&ret->xattrs);
 49	atomic_set(&ret->nr_user_xattrs, 0);
 50	atomic_set(&ret->user_xattr_size, 0);
 51
 52	/* If someone raced us, recognize it. */
 53	if (!try_cmpxchg(&kn->iattr, &attr, ret))
 54		return READ_ONCE(kn->iattr);
 55
 56	return no_free_ptr(ret);
 57}
 58
 59static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn)
 60{
 61	return __kernfs_iattrs(kn, true);
 62}
 63
 64static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn)
 65{
 66	return __kernfs_iattrs(kn, false);
 67}
 68
 69int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
 70{
 71	struct kernfs_iattrs *attrs;
 72	unsigned int ia_valid = iattr->ia_valid;
 73
 74	attrs = kernfs_iattrs(kn);
 75	if (!attrs)
 76		return -ENOMEM;
 77
 78	if (ia_valid & ATTR_UID)
 79		attrs->ia_uid = iattr->ia_uid;
 80	if (ia_valid & ATTR_GID)
 81		attrs->ia_gid = iattr->ia_gid;
 82	if (ia_valid & ATTR_ATIME)
 83		attrs->ia_atime = iattr->ia_atime;
 84	if (ia_valid & ATTR_MTIME)
 85		attrs->ia_mtime = iattr->ia_mtime;
 86	if (ia_valid & ATTR_CTIME)
 87		attrs->ia_ctime = iattr->ia_ctime;
 88	if (ia_valid & ATTR_MODE)
 89		kn->mode = iattr->ia_mode;
 90	return 0;
 91}
 92
 93/**
 94 * kernfs_setattr - set iattr on a node
 95 * @kn: target node
 96 * @iattr: iattr to set
 97 *
 98 * Return: %0 on success, -errno on failure.
 99 */
100int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
101{
102	int ret;
103	struct kernfs_root *root = kernfs_root(kn);
104
105	down_write(&root->kernfs_iattr_rwsem);
106	ret = __kernfs_setattr(kn, iattr);
107	up_write(&root->kernfs_iattr_rwsem);
108	return ret;
109}
110
111int kernfs_iop_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
112		       struct iattr *iattr)
113{
114	struct inode *inode = d_inode(dentry);
115	struct kernfs_node *kn = inode->i_private;
116	struct kernfs_root *root;
117	int error;
118
119	if (!kn)
120		return -EINVAL;
121
122	root = kernfs_root(kn);
123	down_write(&root->kernfs_iattr_rwsem);
124	error = setattr_prepare(&nop_mnt_idmap, dentry, iattr);
125	if (error)
126		goto out;
127
128	error = __kernfs_setattr(kn, iattr);
129	if (error)
130		goto out;
131
132	/* this ignores size changes */
133	setattr_copy(&nop_mnt_idmap, inode, iattr);
134
135out:
136	up_write(&root->kernfs_iattr_rwsem);
137	return error;
138}
139
140ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)
141{
142	struct kernfs_node *kn = kernfs_dentry_node(dentry);
143	struct kernfs_iattrs *attrs;
144
145	attrs = kernfs_iattrs(kn);
146	if (!attrs)
147		return -ENOMEM;
148
149	return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size);
150}
151
152static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
153{
154	inode->i_mode = mode;
155	simple_inode_init_ts(inode);
156}
157
158static inline void set_inode_attr(struct inode *inode,
159				  struct kernfs_iattrs *attrs)
160{
161	inode->i_uid = attrs->ia_uid;
162	inode->i_gid = attrs->ia_gid;
163	inode_set_atime_to_ts(inode, attrs->ia_atime);
164	inode_set_mtime_to_ts(inode, attrs->ia_mtime);
165	inode_set_ctime_to_ts(inode, attrs->ia_ctime);
166}
167
168static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
169{
170	struct kernfs_iattrs *attrs;
171
172	inode->i_mode = kn->mode;
173	attrs = kernfs_iattrs_noalloc(kn);
174	if (attrs)
175		/*
176		 * kernfs_node has non-default attributes get them from
177		 * persistent copy in kernfs_node.
178		 */
179		set_inode_attr(inode, attrs);
180
181	if (kernfs_type(kn) == KERNFS_DIR)
182		set_nlink(inode, kn->dir.subdirs + 2);
183}
184
185int kernfs_iop_getattr(struct mnt_idmap *idmap,
186		       const struct path *path, struct kstat *stat,
187		       u32 request_mask, unsigned int query_flags)
188{
189	struct inode *inode = d_inode(path->dentry);
190	struct kernfs_node *kn = inode->i_private;
191	struct kernfs_root *root = kernfs_root(kn);
192
193	down_read(&root->kernfs_iattr_rwsem);
194	kernfs_refresh_inode(kn, inode);
195	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
196	up_read(&root->kernfs_iattr_rwsem);
197
198	return 0;
199}
200
201static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode)
202{
203	kernfs_get(kn);
204	inode->i_private = kn;
205	inode->i_mapping->a_ops = &ram_aops;
206	inode->i_op = &kernfs_iops;
207	inode->i_generation = kernfs_gen(kn);
208
209	set_default_inode_attr(inode, kn->mode);
210	kernfs_refresh_inode(kn, inode);
211
212	/* initialize inode according to type */
213	switch (kernfs_type(kn)) {
214	case KERNFS_DIR:
215		inode->i_op = &kernfs_dir_iops;
216		inode->i_fop = &kernfs_dir_fops;
217		if (kn->flags & KERNFS_EMPTY_DIR)
218			make_empty_dir_inode(inode);
219		break;
220	case KERNFS_FILE:
221		inode->i_size = kn->attr.size;
222		inode->i_fop = &kernfs_file_fops;
223		break;
224	case KERNFS_LINK:
225		inode->i_op = &kernfs_symlink_iops;
226		break;
227	default:
228		BUG();
229	}
230
231	unlock_new_inode(inode);
232}
233
234/**
235 *	kernfs_get_inode - get inode for kernfs_node
236 *	@sb: super block
237 *	@kn: kernfs_node to allocate inode for
238 *
239 *	Get inode for @kn.  If such inode doesn't exist, a new inode is
240 *	allocated and basics are initialized.  New inode is returned
241 *	locked.
242 *
243 *	Locking:
244 *	Kernel thread context (may sleep).
245 *
246 *	Return:
247 *	Pointer to allocated inode on success, %NULL on failure.
248 */
249struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
250{
251	struct inode *inode;
252
253	inode = iget_locked(sb, kernfs_ino(kn));
254	if (inode && (inode_state_read_once(inode) & I_NEW))
255		kernfs_init_inode(kn, inode);
256
257	return inode;
258}
259
260/*
261 * The kernfs_node serves as both an inode and a directory entry for
262 * kernfs.  To prevent the kernfs inode numbers from being freed
263 * prematurely we take a reference to kernfs_node from the kernfs inode.  A
264 * super_operations.evict_inode() implementation is needed to drop that
265 * reference upon inode destruction.
266 */
267void kernfs_evict_inode(struct inode *inode)
268{
269	struct kernfs_node *kn = inode->i_private;
270
271	truncate_inode_pages_final(&inode->i_data);
272	clear_inode(inode);
273	kernfs_put(kn);
274}
275
276int kernfs_iop_permission(struct mnt_idmap *idmap,
277			  struct inode *inode, int mask)
278{
279	struct kernfs_node *kn;
280	struct kernfs_root *root;
281	int ret;
282
283	if (mask & MAY_NOT_BLOCK)
284		return -ECHILD;
285
286	kn = inode->i_private;
287	root = kernfs_root(kn);
288
289	down_read(&root->kernfs_iattr_rwsem);
290	kernfs_refresh_inode(kn, inode);
291	ret = generic_permission(&nop_mnt_idmap, inode, mask);
292	up_read(&root->kernfs_iattr_rwsem);
293
294	return ret;
295}
296
297int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
298		     void *value, size_t size)
299{
300	struct kernfs_iattrs *attrs = kernfs_iattrs_noalloc(kn);
301	if (!attrs)
302		return -ENODATA;
303
304	return simple_xattr_get(&attrs->xattrs, name, value, size);
305}
306
307int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
308		     const void *value, size_t size, int flags)
309{
310	struct simple_xattr *old_xattr;
311	struct kernfs_iattrs *attrs;
312
313	attrs = kernfs_iattrs(kn);
314	if (!attrs)
315		return -ENOMEM;
316
317	old_xattr = simple_xattr_set(&attrs->xattrs, name, value, size, flags);
318	if (IS_ERR(old_xattr))
319		return PTR_ERR(old_xattr);
320
321	simple_xattr_free(old_xattr);
322	return 0;
323}
324
325static int kernfs_vfs_xattr_get(const struct xattr_handler *handler,
326				struct dentry *unused, struct inode *inode,
327				const char *suffix, void *value, size_t size)
328{
329	const char *name = xattr_full_name(handler, suffix);
330	struct kernfs_node *kn = inode->i_private;
331
332	return kernfs_xattr_get(kn, name, value, size);
333}
334
335static int kernfs_vfs_xattr_set(const struct xattr_handler *handler,
336				struct mnt_idmap *idmap,
337				struct dentry *unused, struct inode *inode,
338				const char *suffix, const void *value,
339				size_t size, int flags)
340{
341	const char *name = xattr_full_name(handler, suffix);
342	struct kernfs_node *kn = inode->i_private;
343
344	return kernfs_xattr_set(kn, name, value, size, flags);
345}
346
347static int kernfs_vfs_user_xattr_add(struct kernfs_node *kn,
348				     const char *full_name,
349				     struct simple_xattrs *xattrs,
350				     const void *value, size_t size, int flags)
351{
352	struct kernfs_iattrs *attr = kernfs_iattrs_noalloc(kn);
353	atomic_t *sz = &attr->user_xattr_size;
354	atomic_t *nr = &attr->nr_user_xattrs;
355	struct simple_xattr *old_xattr;
356	int ret;
357
358	if (atomic_inc_return(nr) > KERNFS_MAX_USER_XATTRS) {
359		ret = -ENOSPC;
360		goto dec_count_out;
361	}
362
363	if (atomic_add_return(size, sz) > KERNFS_USER_XATTR_SIZE_LIMIT) {
364		ret = -ENOSPC;
365		goto dec_size_out;
366	}
367
368	old_xattr = simple_xattr_set(xattrs, full_name, value, size, flags);
369	if (!old_xattr)
370		return 0;
371
372	if (IS_ERR(old_xattr)) {
373		ret = PTR_ERR(old_xattr);
374		goto dec_size_out;
375	}
376
377	ret = 0;
378	size = old_xattr->size;
379	simple_xattr_free(old_xattr);
380dec_size_out:
381	atomic_sub(size, sz);
382dec_count_out:
383	atomic_dec(nr);
384	return ret;
385}
386
387static int kernfs_vfs_user_xattr_rm(struct kernfs_node *kn,
388				    const char *full_name,
389				    struct simple_xattrs *xattrs,
390				    const void *value, size_t size, int flags)
391{
392	struct kernfs_iattrs *attr = kernfs_iattrs_noalloc(kn);
393	atomic_t *sz = &attr->user_xattr_size;
394	atomic_t *nr = &attr->nr_user_xattrs;
395	struct simple_xattr *old_xattr;
396
397	old_xattr = simple_xattr_set(xattrs, full_name, value, size, flags);
398	if (!old_xattr)
399		return 0;
400
401	if (IS_ERR(old_xattr))
402		return PTR_ERR(old_xattr);
403
404	atomic_sub(old_xattr->size, sz);
405	atomic_dec(nr);
406	simple_xattr_free(old_xattr);
407	return 0;
408}
409
410static int kernfs_vfs_user_xattr_set(const struct xattr_handler *handler,
411				     struct mnt_idmap *idmap,
412				     struct dentry *unused, struct inode *inode,
413				     const char *suffix, const void *value,
414				     size_t size, int flags)
415{
416	const char *full_name = xattr_full_name(handler, suffix);
417	struct kernfs_node *kn = inode->i_private;
418	struct kernfs_iattrs *attrs;
419
420	if (!(kernfs_root(kn)->flags & KERNFS_ROOT_SUPPORT_USER_XATTR))
421		return -EOPNOTSUPP;
422
423	attrs = kernfs_iattrs(kn);
424	if (!attrs)
425		return -ENOMEM;
426
427	if (value)
428		return kernfs_vfs_user_xattr_add(kn, full_name, &attrs->xattrs,
429						 value, size, flags);
430	else
431		return kernfs_vfs_user_xattr_rm(kn, full_name, &attrs->xattrs,
432						value, size, flags);
433
434}
435
436static const struct xattr_handler kernfs_trusted_xattr_handler = {
437	.prefix = XATTR_TRUSTED_PREFIX,
438	.get = kernfs_vfs_xattr_get,
439	.set = kernfs_vfs_xattr_set,
440};
441
442static const struct xattr_handler kernfs_security_xattr_handler = {
443	.prefix = XATTR_SECURITY_PREFIX,
444	.get = kernfs_vfs_xattr_get,
445	.set = kernfs_vfs_xattr_set,
446};
447
448static const struct xattr_handler kernfs_user_xattr_handler = {
449	.prefix = XATTR_USER_PREFIX,
450	.get = kernfs_vfs_xattr_get,
451	.set = kernfs_vfs_user_xattr_set,
452};
453
454const struct xattr_handler * const kernfs_xattr_handlers[] = {
455	&kernfs_trusted_xattr_handler,
456	&kernfs_security_xattr_handler,
457	&kernfs_user_xattr_handler,
458	NULL
459};