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