Branch data Line data Source code
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 address_space_operations kernfs_aops = {
21 : : .readpage = simple_readpage,
22 : : .write_begin = simple_write_begin,
23 : : .write_end = simple_write_end,
24 : : };
25 : :
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,
31 : : };
32 : :
33 : : static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, int alloc)
34 : : {
35 : : static DEFINE_MUTEX(iattr_mutex);
36 : : struct kernfs_iattrs *ret;
37 : :
38 : : mutex_lock(&iattr_mutex);
39 : :
40 : : if (kn->iattr || !alloc)
41 : : goto out_unlock;
42 : :
43 : : kn->iattr = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL);
44 : : if (!kn->iattr)
45 : : goto out_unlock;
46 : :
47 : : /* assign default attributes */
48 : : kn->iattr->ia_uid = GLOBAL_ROOT_UID;
49 : : kn->iattr->ia_gid = GLOBAL_ROOT_GID;
50 : :
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;
54 : :
55 : : simple_xattrs_init(&kn->iattr->xattrs);
56 : : out_unlock:
57 : : ret = kn->iattr;
58 : : mutex_unlock(&iattr_mutex);
59 : : return ret;
60 : : }
61 : :
62 : 390 : static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn)
63 : : {
64 : 390 : return __kernfs_iattrs(kn, 1);
65 : : }
66 : :
67 : 226018 : static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn)
68 : : {
69 : 226018 : return __kernfs_iattrs(kn, 0);
70 : : }
71 : :
72 : 26 : int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
73 : : {
74 : 26 : struct kernfs_iattrs *attrs;
75 : 26 : unsigned int ia_valid = iattr->ia_valid;
76 : :
77 : 26 : attrs = kernfs_iattrs(kn);
78 [ + - ]: 26 : if (!attrs)
79 : : return -ENOMEM;
80 : :
81 [ - + ]: 26 : if (ia_valid & ATTR_UID)
82 : 0 : attrs->ia_uid = iattr->ia_uid;
83 [ - + ]: 26 : if (ia_valid & ATTR_GID)
84 : 0 : attrs->ia_gid = iattr->ia_gid;
85 [ - + ]: 26 : if (ia_valid & ATTR_ATIME)
86 : 0 : attrs->ia_atime = iattr->ia_atime;
87 [ + - ]: 26 : if (ia_valid & ATTR_MTIME)
88 : 26 : attrs->ia_mtime = iattr->ia_mtime;
89 [ + - ]: 26 : if (ia_valid & ATTR_CTIME)
90 : 26 : attrs->ia_ctime = iattr->ia_ctime;
91 [ - + ]: 26 : if (ia_valid & ATTR_MODE)
92 : 0 : kn->mode = iattr->ia_mode;
93 : : return 0;
94 : : }
95 : :
96 : : /**
97 : : * kernfs_setattr - set iattr on a node
98 : : * @kn: target node
99 : : * @iattr: iattr to set
100 : : *
101 : : * Returns 0 on success, -errno on failure.
102 : : */
103 : 0 : int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
104 : : {
105 : 0 : int ret;
106 : :
107 : 0 : mutex_lock(&kernfs_mutex);
108 : 0 : ret = __kernfs_setattr(kn, iattr);
109 : 0 : mutex_unlock(&kernfs_mutex);
110 : 0 : return ret;
111 : : }
112 : :
113 : 26 : int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr)
114 : : {
115 [ + - ]: 26 : struct inode *inode = d_inode(dentry);
116 : 26 : struct kernfs_node *kn = inode->i_private;
117 : 26 : int error;
118 : :
119 [ + - ]: 26 : if (!kn)
120 : : return -EINVAL;
121 : :
122 : 26 : mutex_lock(&kernfs_mutex);
123 : 26 : error = setattr_prepare(dentry, iattr);
124 [ - + ]: 26 : if (error)
125 : 0 : goto out;
126 : :
127 : 26 : error = __kernfs_setattr(kn, iattr);
128 [ - + ]: 26 : if (error)
129 : 0 : goto out;
130 : :
131 : : /* this ignores size changes */
132 : 26 : setattr_copy(inode, iattr);
133 : :
134 : 26 : out:
135 : 26 : mutex_unlock(&kernfs_mutex);
136 : 26 : return error;
137 : : }
138 : :
139 : 0 : ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)
140 : : {
141 [ # # ]: 0 : struct kernfs_node *kn = kernfs_dentry_node(dentry);
142 : 0 : struct kernfs_iattrs *attrs;
143 : :
144 : 0 : attrs = kernfs_iattrs(kn);
145 [ # # ]: 0 : if (!attrs)
146 : : return -ENOMEM;
147 : :
148 : 0 : return simple_xattr_list(d_inode(dentry), &attrs->xattrs, buf, size);
149 : : }
150 : :
151 : 32709 : static inline void set_default_inode_attr(struct inode *inode, umode_t mode)
152 : : {
153 : 32709 : inode->i_mode = mode;
154 : 65418 : inode->i_atime = inode->i_mtime =
155 : 32709 : inode->i_ctime = current_time(inode);
156 : : }
157 : :
158 : 3689 : static inline void set_inode_attr(struct inode *inode,
159 : : struct kernfs_iattrs *attrs)
160 : : {
161 : 3689 : inode->i_uid = attrs->ia_uid;
162 : 3689 : inode->i_gid = attrs->ia_gid;
163 : 3689 : inode->i_atime = attrs->ia_atime;
164 : 3689 : inode->i_mtime = attrs->ia_mtime;
165 : 3689 : inode->i_ctime = attrs->ia_ctime;
166 : 3689 : }
167 : :
168 : 759058 : static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
169 : : {
170 : 759058 : struct kernfs_iattrs *attrs = kn->iattr;
171 : :
172 : 759058 : inode->i_mode = kn->mode;
173 [ + + ]: 759058 : if (attrs)
174 : : /*
175 : : * kernfs_node has non-default attributes get them from
176 : : * persistent copy in kernfs_node.
177 : : */
178 : 3689 : set_inode_attr(inode, attrs);
179 : :
180 [ + + ]: 759058 : if (kernfs_type(kn) == KERNFS_DIR)
181 : 662949 : set_nlink(inode, kn->dir.subdirs + 2);
182 : 759058 : }
183 : :
184 : 148032 : int kernfs_iop_getattr(const struct path *path, struct kstat *stat,
185 : : u32 request_mask, unsigned int query_flags)
186 : : {
187 : 148032 : struct inode *inode = d_inode(path->dentry);
188 : 148032 : struct kernfs_node *kn = inode->i_private;
189 : :
190 : 148032 : mutex_lock(&kernfs_mutex);
191 : 148032 : kernfs_refresh_inode(kn, inode);
192 : 148032 : mutex_unlock(&kernfs_mutex);
193 : :
194 : 148032 : generic_fillattr(inode, stat);
195 : 148032 : return 0;
196 : : }
197 : :
198 : 32709 : static void kernfs_init_inode(struct kernfs_node *kn, struct inode *inode)
199 : : {
200 : 32709 : kernfs_get(kn);
201 : 32709 : inode->i_private = kn;
202 : 32709 : inode->i_mapping->a_ops = &kernfs_aops;
203 : 32709 : inode->i_op = &kernfs_iops;
204 : 32709 : inode->i_generation = kernfs_gen(kn);
205 : :
206 : 32709 : set_default_inode_attr(inode, kn->mode);
207 : 32709 : kernfs_refresh_inode(kn, inode);
208 : :
209 : : /* initialize inode according to type */
210 [ + + + - ]: 32709 : switch (kernfs_type(kn)) {
211 : 10901 : case KERNFS_DIR:
212 : 10901 : inode->i_op = &kernfs_dir_iops;
213 : 10901 : inode->i_fop = &kernfs_dir_fops;
214 [ + + ]: 10901 : if (kn->flags & KERNFS_EMPTY_DIR)
215 : 78 : make_empty_dir_inode(inode);
216 : : break;
217 : 14157 : case KERNFS_FILE:
218 : 14157 : inode->i_size = kn->attr.size;
219 : 14157 : inode->i_fop = &kernfs_file_fops;
220 : 14157 : break;
221 : 7651 : case KERNFS_LINK:
222 : 7651 : inode->i_op = &kernfs_symlink_iops;
223 : 7651 : break;
224 : 0 : default:
225 : 0 : BUG();
226 : : }
227 : :
228 : 32709 : unlock_new_inode(inode);
229 : 32709 : }
230 : :
231 : : /**
232 : : * kernfs_get_inode - get inode for kernfs_node
233 : : * @sb: super block
234 : : * @kn: kernfs_node to allocate inode for
235 : : *
236 : : * Get inode for @kn. If such inode doesn't exist, a new inode is
237 : : * allocated and basics are initialized. New inode is returned
238 : : * locked.
239 : : *
240 : : * LOCKING:
241 : : * Kernel thread context (may sleep).
242 : : *
243 : : * RETURNS:
244 : : * Pointer to allocated inode on success, NULL on failure.
245 : : */
246 : 33437 : struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
247 : : {
248 : 33437 : struct inode *inode;
249 : :
250 : 33437 : inode = iget_locked(sb, kernfs_ino(kn));
251 [ + - + + ]: 33437 : if (inode && (inode->i_state & I_NEW))
252 : 32709 : kernfs_init_inode(kn, inode);
253 : :
254 : 33437 : return inode;
255 : : }
256 : :
257 : : /*
258 : : * The kernfs_node serves as both an inode and a directory entry for
259 : : * kernfs. To prevent the kernfs inode numbers from being freed
260 : : * prematurely we take a reference to kernfs_node from the kernfs inode. A
261 : : * super_operations.evict_inode() implementation is needed to drop that
262 : : * reference upon inode destruction.
263 : : */
264 : 3107 : void kernfs_evict_inode(struct inode *inode)
265 : : {
266 : 3107 : struct kernfs_node *kn = inode->i_private;
267 : :
268 : 3107 : truncate_inode_pages_final(&inode->i_data);
269 : 3107 : clear_inode(inode);
270 : 3107 : kernfs_put(kn);
271 : 3107 : }
272 : :
273 : 797289 : int kernfs_iop_permission(struct inode *inode, int mask)
274 : : {
275 : 797289 : struct kernfs_node *kn;
276 : :
277 [ + + ]: 797289 : if (mask & MAY_NOT_BLOCK)
278 : : return -ECHILD;
279 : :
280 : 578317 : kn = inode->i_private;
281 : :
282 : 578317 : mutex_lock(&kernfs_mutex);
283 : 578317 : kernfs_refresh_inode(kn, inode);
284 : 578317 : mutex_unlock(&kernfs_mutex);
285 : :
286 : 578317 : return generic_permission(inode, mask);
287 : : }
288 : :
289 : 226018 : int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
290 : : void *value, size_t size)
291 : : {
292 : 226018 : struct kernfs_iattrs *attrs = kernfs_iattrs_noalloc(kn);
293 [ - + ]: 226018 : if (!attrs)
294 : : return -ENODATA;
295 : :
296 : 0 : return simple_xattr_get(&attrs->xattrs, name, value, size);
297 : : }
298 : :
299 : 364 : int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
300 : : const void *value, size_t size, int flags)
301 : : {
302 : 364 : struct kernfs_iattrs *attrs = kernfs_iattrs(kn);
303 [ + - ]: 364 : if (!attrs)
304 : : return -ENOMEM;
305 : :
306 : 364 : return simple_xattr_set(&attrs->xattrs, name, value, size, flags);
307 : : }
308 : :
309 : 26 : static int kernfs_vfs_xattr_get(const struct xattr_handler *handler,
310 : : struct dentry *unused, struct inode *inode,
311 : : const char *suffix, void *value, size_t size)
312 : : {
313 : 26 : const char *name = xattr_full_name(handler, suffix);
314 : 26 : struct kernfs_node *kn = inode->i_private;
315 : :
316 : 26 : return kernfs_xattr_get(kn, name, value, size);
317 : : }
318 : :
319 : 364 : static int kernfs_vfs_xattr_set(const struct xattr_handler *handler,
320 : : struct dentry *unused, struct inode *inode,
321 : : const char *suffix, const void *value,
322 : : size_t size, int flags)
323 : : {
324 : 364 : const char *name = xattr_full_name(handler, suffix);
325 : 364 : struct kernfs_node *kn = inode->i_private;
326 : :
327 : 364 : return kernfs_xattr_set(kn, name, value, size, flags);
328 : : }
329 : :
330 : : static const struct xattr_handler kernfs_trusted_xattr_handler = {
331 : : .prefix = XATTR_TRUSTED_PREFIX,
332 : : .get = kernfs_vfs_xattr_get,
333 : : .set = kernfs_vfs_xattr_set,
334 : : };
335 : :
336 : : static const struct xattr_handler kernfs_security_xattr_handler = {
337 : : .prefix = XATTR_SECURITY_PREFIX,
338 : : .get = kernfs_vfs_xattr_get,
339 : : .set = kernfs_vfs_xattr_set,
340 : : };
341 : :
342 : : const struct xattr_handler *kernfs_xattr_handlers[] = {
343 : : &kernfs_trusted_xattr_handler,
344 : : &kernfs_security_xattr_handler,
345 : : NULL
346 : : };
|
