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