Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : File: fs/xattr.c
4 :
5 : Extended attribute handling.
6 :
7 : Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
8 : Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
9 : Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
10 : */
11 : #include <linux/fs.h>
12 : #include <linux/filelock.h>
13 : #include <linux/slab.h>
14 : #include <linux/file.h>
15 : #include <linux/xattr.h>
16 : #include <linux/mount.h>
17 : #include <linux/namei.h>
18 : #include <linux/security.h>
19 : #include <linux/evm.h>
20 : #include <linux/syscalls.h>
21 : #include <linux/export.h>
22 : #include <linux/fsnotify.h>
23 : #include <linux/audit.h>
24 : #include <linux/vmalloc.h>
25 : #include <linux/posix_acl_xattr.h>
26 :
27 : #include <linux/uaccess.h>
28 :
29 : #include "internal.h"
30 :
31 : static const char *
32 : strcmp_prefix(const char *a, const char *a_prefix)
33 : {
34 1032399081 : while (*a_prefix && *a == *a_prefix) {
35 662774494 : a++;
36 662774494 : a_prefix++;
37 : }
38 369624587 : return *a_prefix ? NULL : a;
39 : }
40 :
41 : /*
42 : * In order to implement different sets of xattr operations for each xattr
43 : * prefix, a filesystem should create a null-terminated array of struct
44 : * xattr_handler (one for each prefix) and hang a pointer to it off of the
45 : * s_xattr field of the superblock.
46 : */
47 : #define for_each_xattr_handler(handlers, handler) \
48 : if (handlers) \
49 : for ((handler) = *(handlers)++; \
50 : (handler) != NULL; \
51 : (handler) = *(handlers)++)
52 :
53 : /*
54 : * Find the xattr_handler with the matching prefix.
55 : */
56 : static const struct xattr_handler *
57 197786230 : xattr_resolve_name(struct inode *inode, const char **name)
58 : {
59 197786230 : const struct xattr_handler **handlers = inode->i_sb->s_xattr;
60 197786230 : const struct xattr_handler *handler;
61 :
62 197786230 : if (!(inode->i_opflags & IOP_XATTR)) {
63 7860 : if (unlikely(is_bad_inode(inode)))
64 : return ERR_PTR(-EIO);
65 7860 : return ERR_PTR(-EOPNOTSUPP);
66 : }
67 446084538 : for_each_xattr_handler(handlers, handler) {
68 369624587 : const char *n;
69 :
70 369624587 : n = strcmp_prefix(*name, xattr_prefix(handler));
71 121318419 : if (n) {
72 121318419 : if (!handler->prefix ^ !*n) {
73 0 : if (*n)
74 0 : continue;
75 : return ERR_PTR(-EINVAL);
76 : }
77 121381680 : *name = n;
78 121381680 : return handler;
79 : }
80 : }
81 : return ERR_PTR(-EOPNOTSUPP);
82 : }
83 :
84 : /**
85 : * may_write_xattr - check whether inode allows writing xattr
86 : * @idmap: idmap of the mount the inode was found from
87 : * @inode: the inode on which to set an xattr
88 : *
89 : * Check whether the inode allows writing xattrs. Specifically, we can never
90 : * set or remove an extended attribute on a read-only filesystem or on an
91 : * immutable / append-only inode.
92 : *
93 : * We also need to ensure that the inode has a mapping in the mount to
94 : * not risk writing back invalid i_{g,u}id values.
95 : *
96 : * Return: On success zero is returned. On error a negative errno is returned.
97 : */
98 170620065 : int may_write_xattr(struct mnt_idmap *idmap, struct inode *inode)
99 : {
100 170620065 : if (IS_IMMUTABLE(inode))
101 : return -EPERM;
102 170620021 : if (IS_APPEND(inode))
103 : return -EPERM;
104 170619977 : if (HAS_UNMAPPED_ID(idmap, inode))
105 0 : return -EPERM;
106 : return 0;
107 : }
108 :
109 : /*
110 : * Check permissions for extended attribute access. This is a bit complicated
111 : * because different namespaces have very different rules.
112 : */
113 : static int
114 181969157 : xattr_permission(struct mnt_idmap *idmap, struct inode *inode,
115 : const char *name, int mask)
116 : {
117 181969157 : if (mask & MAY_WRITE) {
118 168803732 : int ret;
119 :
120 168803732 : ret = may_write_xattr(idmap, inode);
121 168792855 : if (ret)
122 : return ret;
123 : }
124 :
125 : /*
126 : * No restriction for security.* and system.* from the VFS. Decision
127 : * on these is left to the underlying filesystem / security module.
128 : */
129 181958208 : if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
130 181938696 : !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
131 : return 0;
132 :
133 : /*
134 : * The trusted.* namespace can only be accessed by privileged users.
135 : */
136 181938690 : if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
137 190615 : if (!capable(CAP_SYS_ADMIN))
138 0 : return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
139 : return 0;
140 : }
141 :
142 : /*
143 : * In the user.* namespace, only regular files and directories can have
144 : * extended attributes. For sticky directories, only the owner and
145 : * privileged users can write attributes.
146 : */
147 181748075 : if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
148 113332083 : if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
149 96 : return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
150 113331987 : if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
151 0 : (mask & MAY_WRITE) &&
152 0 : !inode_owner_or_capable(idmap, inode))
153 : return -EPERM;
154 : }
155 :
156 181747979 : return inode_permission(idmap, inode, mask);
157 : }
158 :
159 : /*
160 : * Look for any handler that deals with the specified namespace.
161 : */
162 : int
163 0 : xattr_supports_user_prefix(struct inode *inode)
164 : {
165 0 : const struct xattr_handler **handlers = inode->i_sb->s_xattr;
166 0 : const struct xattr_handler *handler;
167 :
168 0 : if (!(inode->i_opflags & IOP_XATTR)) {
169 0 : if (unlikely(is_bad_inode(inode)))
170 : return -EIO;
171 0 : return -EOPNOTSUPP;
172 : }
173 :
174 0 : for_each_xattr_handler(handlers, handler) {
175 0 : if (!strncmp(xattr_prefix(handler), XATTR_USER_PREFIX,
176 : XATTR_USER_PREFIX_LEN))
177 : return 0;
178 : }
179 :
180 : return -EOPNOTSUPP;
181 : }
182 : EXPORT_SYMBOL(xattr_supports_user_prefix);
183 :
184 : int
185 137928081 : __vfs_setxattr(struct mnt_idmap *idmap, struct dentry *dentry,
186 : struct inode *inode, const char *name, const void *value,
187 : size_t size, int flags)
188 : {
189 137928081 : const struct xattr_handler *handler;
190 :
191 137928081 : if (is_posix_acl_xattr(name))
192 : return -EOPNOTSUPP;
193 :
194 137928081 : handler = xattr_resolve_name(inode, &name);
195 137960246 : if (IS_ERR(handler))
196 68429976 : return PTR_ERR(handler);
197 69530270 : if (!handler->set)
198 : return -EOPNOTSUPP;
199 69530270 : if (size == 0)
200 696545 : value = ""; /* empty EA, do not remove */
201 69530270 : return handler->set(handler, idmap, dentry, inode, name, value,
202 : size, flags);
203 : }
204 : EXPORT_SYMBOL(__vfs_setxattr);
205 :
206 : /**
207 : * __vfs_setxattr_noperm - perform setxattr operation without performing
208 : * permission checks.
209 : *
210 : * @idmap: idmap of the mount the inode was found from
211 : * @dentry: object to perform setxattr on
212 : * @name: xattr name to set
213 : * @value: value to set @name to
214 : * @size: size of @value
215 : * @flags: flags to pass into filesystem operations
216 : *
217 : * returns the result of the internal setxattr or setsecurity operations.
218 : *
219 : * This function requires the caller to lock the inode's i_mutex before it
220 : * is executed. It also assumes that the caller will make the appropriate
221 : * permission checks.
222 : */
223 137948423 : int __vfs_setxattr_noperm(struct mnt_idmap *idmap,
224 : struct dentry *dentry, const char *name,
225 : const void *value, size_t size, int flags)
226 : {
227 137948423 : struct inode *inode = dentry->d_inode;
228 137948423 : int error = -EAGAIN;
229 137948423 : int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
230 : XATTR_SECURITY_PREFIX_LEN);
231 :
232 137948423 : if (issec)
233 46 : inode->i_flags &= ~S_NOSEC;
234 137948423 : if (inode->i_opflags & IOP_XATTR) {
235 137948423 : error = __vfs_setxattr(idmap, dentry, inode, name, value,
236 : size, flags);
237 137889234 : if (!error) {
238 60116896 : fsnotify_xattr(dentry);
239 : security_inode_post_setxattr(dentry, name, value,
240 : size, flags);
241 : }
242 : } else {
243 0 : if (unlikely(is_bad_inode(inode)))
244 : return -EIO;
245 : }
246 137890237 : if (error == -EAGAIN) {
247 0 : error = -EOPNOTSUPP;
248 :
249 0 : if (issec) {
250 : const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
251 :
252 : error = security_inode_setsecurity(inode, suffix, value,
253 : size, flags);
254 : if (!error)
255 : fsnotify_xattr(dentry);
256 : }
257 : }
258 :
259 : return error;
260 : }
261 :
262 : /**
263 : * __vfs_setxattr_locked - set an extended attribute while holding the inode
264 : * lock
265 : *
266 : * @idmap: idmap of the mount of the target inode
267 : * @dentry: object to perform setxattr on
268 : * @name: xattr name to set
269 : * @value: value to set @name to
270 : * @size: size of @value
271 : * @flags: flags to pass into filesystem operations
272 : * @delegated_inode: on return, will contain an inode pointer that
273 : * a delegation was broken on, NULL if none.
274 : */
275 : int
276 137935083 : __vfs_setxattr_locked(struct mnt_idmap *idmap, struct dentry *dentry,
277 : const char *name, const void *value, size_t size,
278 : int flags, struct inode **delegated_inode)
279 : {
280 137935083 : struct inode *inode = dentry->d_inode;
281 137935083 : int error;
282 :
283 137935083 : error = xattr_permission(idmap, inode, name, MAY_WRITE);
284 137942137 : if (error)
285 : return error;
286 :
287 137946593 : error = security_inode_setxattr(idmap, dentry, name, value, size,
288 : flags);
289 137919046 : if (error)
290 0 : goto out;
291 :
292 137919046 : error = try_break_deleg(inode, delegated_inode);
293 137948223 : if (error)
294 0 : goto out;
295 :
296 137948223 : error = __vfs_setxattr_noperm(idmap, dentry, name, value,
297 : size, flags);
298 :
299 : out:
300 : return error;
301 : }
302 : EXPORT_SYMBOL_GPL(__vfs_setxattr_locked);
303 :
304 : int
305 137914681 : vfs_setxattr(struct mnt_idmap *idmap, struct dentry *dentry,
306 : const char *name, const void *value, size_t size, int flags)
307 : {
308 137914681 : struct inode *inode = dentry->d_inode;
309 137914681 : struct inode *delegated_inode = NULL;
310 137914681 : const void *orig_value = value;
311 137914681 : int error;
312 :
313 137914681 : if (size && strcmp(name, XATTR_NAME_CAPS) == 0) {
314 46 : error = cap_convert_nscap(idmap, dentry, &value, size);
315 46 : if (error < 0)
316 : return error;
317 44 : size = error;
318 : }
319 :
320 137914679 : retry_deleg:
321 137914679 : inode_lock(inode);
322 137937040 : error = __vfs_setxattr_locked(idmap, dentry, name, value, size,
323 : flags, &delegated_inode);
324 137873421 : inode_unlock(inode);
325 :
326 137841897 : if (delegated_inode) {
327 0 : error = break_deleg_wait(&delegated_inode);
328 0 : if (!error)
329 0 : goto retry_deleg;
330 : }
331 137841897 : if (value != orig_value)
332 24 : kfree(value);
333 :
334 : return error;
335 : }
336 : EXPORT_SYMBOL_GPL(vfs_setxattr);
337 :
338 : static ssize_t
339 19034 : xattr_getsecurity(struct mnt_idmap *idmap, struct inode *inode,
340 : const char *name, void *value, size_t size)
341 : {
342 19034 : void *buffer = NULL;
343 19034 : ssize_t len;
344 :
345 19034 : if (!value || !size) {
346 328 : len = security_inode_getsecurity(idmap, inode, name,
347 : &buffer, false);
348 328 : goto out_noalloc;
349 : }
350 :
351 18706 : len = security_inode_getsecurity(idmap, inode, name, &buffer,
352 : true);
353 18706 : if (len < 0)
354 : return len;
355 54 : if (size < len) {
356 0 : len = -ERANGE;
357 0 : goto out;
358 : }
359 108 : memcpy(value, buffer, len);
360 54 : out:
361 54 : kfree(buffer);
362 : out_noalloc:
363 : return len;
364 : }
365 :
366 : /*
367 : * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
368 : *
369 : * Allocate memory, if not already allocated, or re-allocate correct size,
370 : * before retrieving the extended attribute. The xattr value buffer should
371 : * always be freed by the caller, even on error.
372 : *
373 : * Returns the result of alloc, if failed, or the getxattr operation.
374 : */
375 : int
376 416 : vfs_getxattr_alloc(struct mnt_idmap *idmap, struct dentry *dentry,
377 : const char *name, char **xattr_value, size_t xattr_size,
378 : gfp_t flags)
379 : {
380 416 : const struct xattr_handler *handler;
381 416 : struct inode *inode = dentry->d_inode;
382 416 : char *value = *xattr_value;
383 416 : int error;
384 :
385 416 : error = xattr_permission(idmap, inode, name, MAY_READ);
386 416 : if (error)
387 : return error;
388 :
389 416 : handler = xattr_resolve_name(inode, &name);
390 416 : if (IS_ERR(handler))
391 0 : return PTR_ERR(handler);
392 416 : if (!handler->get)
393 : return -EOPNOTSUPP;
394 416 : error = handler->get(handler, dentry, inode, name, NULL, 0);
395 416 : if (error < 0)
396 : return error;
397 :
398 62 : if (!value || (error > xattr_size)) {
399 62 : value = krealloc(*xattr_value, error + 1, flags);
400 62 : if (!value)
401 : return -ENOMEM;
402 124 : memset(value, 0, error + 1);
403 : }
404 :
405 62 : error = handler->get(handler, dentry, inode, name, value, error);
406 62 : *xattr_value = value;
407 62 : return error;
408 : }
409 :
410 : ssize_t
411 28996168 : __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name,
412 : void *value, size_t size)
413 : {
414 28996168 : const struct xattr_handler *handler;
415 :
416 28996168 : if (is_posix_acl_xattr(name))
417 : return -EOPNOTSUPP;
418 :
419 28996168 : handler = xattr_resolve_name(inode, &name);
420 29000292 : if (IS_ERR(handler))
421 8037088 : return PTR_ERR(handler);
422 20963204 : if (!handler->get)
423 : return -EOPNOTSUPP;
424 20963204 : return handler->get(handler, dentry, inode, name, value, size);
425 : }
426 : EXPORT_SYMBOL(__vfs_getxattr);
427 :
428 : ssize_t
429 13152749 : vfs_getxattr(struct mnt_idmap *idmap, struct dentry *dentry,
430 : const char *name, void *value, size_t size)
431 : {
432 13152749 : struct inode *inode = dentry->d_inode;
433 13152749 : int error;
434 :
435 13152749 : error = xattr_permission(idmap, inode, name, MAY_READ);
436 13152926 : if (error)
437 24 : return error;
438 :
439 13152902 : error = security_inode_getxattr(dentry, name);
440 13152902 : if (error)
441 : return error;
442 :
443 13152902 : if (!strncmp(name, XATTR_SECURITY_PREFIX,
444 : XATTR_SECURITY_PREFIX_LEN)) {
445 19034 : const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
446 19034 : int ret = xattr_getsecurity(idmap, inode, suffix, value,
447 : size);
448 : /*
449 : * Only overwrite the return value if a security module
450 : * is actually active.
451 : */
452 19034 : if (ret == -EOPNOTSUPP)
453 18618 : goto nolsm;
454 416 : return ret;
455 : }
456 13133868 : nolsm:
457 13152486 : return __vfs_getxattr(dentry, inode, name, value, size);
458 : }
459 : EXPORT_SYMBOL_GPL(vfs_getxattr);
460 :
461 : /**
462 : * vfs_listxattr - retrieve \0 separated list of xattr names
463 : * @dentry: the dentry from whose inode the xattr names are retrieved
464 : * @list: buffer to store xattr names into
465 : * @size: size of the buffer
466 : *
467 : * This function returns the names of all xattrs associated with the
468 : * inode of @dentry.
469 : *
470 : * Note, for legacy reasons the vfs_listxattr() function lists POSIX
471 : * ACLs as well. Since POSIX ACLs are decoupled from IOP_XATTR the
472 : * vfs_listxattr() function doesn't check for this flag since a
473 : * filesystem could implement POSIX ACLs without implementing any other
474 : * xattrs.
475 : *
476 : * However, since all codepaths that remove IOP_XATTR also assign of
477 : * inode operations that either don't implement or implement a stub
478 : * ->listxattr() operation.
479 : *
480 : * Return: On success, the size of the buffer that was used. On error a
481 : * negative error code.
482 : */
483 : ssize_t
484 38163375 : vfs_listxattr(struct dentry *dentry, char *list, size_t size)
485 : {
486 38163375 : struct inode *inode = d_inode(dentry);
487 38163375 : ssize_t error;
488 :
489 38163375 : error = security_inode_listxattr(dentry);
490 38163375 : if (error)
491 : return error;
492 :
493 38163375 : if (inode->i_op->listxattr) {
494 38163375 : error = inode->i_op->listxattr(dentry, list, size);
495 : } else {
496 : error = security_inode_listsecurity(inode, list, size);
497 : if (size && error > size)
498 : error = -ERANGE;
499 : }
500 38164564 : return error;
501 : }
502 : EXPORT_SYMBOL_GPL(vfs_listxattr);
503 :
504 : int
505 30898468 : __vfs_removexattr(struct mnt_idmap *idmap, struct dentry *dentry,
506 : const char *name)
507 : {
508 30898468 : struct inode *inode = d_inode(dentry);
509 30898468 : const struct xattr_handler *handler;
510 :
511 30898468 : if (is_posix_acl_xattr(name))
512 : return -EOPNOTSUPP;
513 :
514 30898468 : handler = xattr_resolve_name(inode, &name);
515 30898872 : if (IS_ERR(handler))
516 0 : return PTR_ERR(handler);
517 30898872 : if (!handler->set)
518 : return -EOPNOTSUPP;
519 30898872 : return handler->set(handler, idmap, dentry, inode, name, NULL, 0,
520 : XATTR_REPLACE);
521 : }
522 : EXPORT_SYMBOL(__vfs_removexattr);
523 :
524 : /**
525 : * __vfs_removexattr_locked - set an extended attribute while holding the inode
526 : * lock
527 : *
528 : * @idmap: idmap of the mount of the target inode
529 : * @dentry: object to perform setxattr on
530 : * @name: name of xattr to remove
531 : * @delegated_inode: on return, will contain an inode pointer that
532 : * a delegation was broken on, NULL if none.
533 : */
534 : int
535 30898523 : __vfs_removexattr_locked(struct mnt_idmap *idmap,
536 : struct dentry *dentry, const char *name,
537 : struct inode **delegated_inode)
538 : {
539 30898523 : struct inode *inode = dentry->d_inode;
540 30898523 : int error;
541 :
542 30898523 : error = xattr_permission(idmap, inode, name, MAY_WRITE);
543 30898350 : if (error)
544 : return error;
545 :
546 30898759 : error = security_inode_removexattr(idmap, dentry, name);
547 30895555 : if (error)
548 0 : goto out;
549 :
550 30895555 : error = try_break_deleg(inode, delegated_inode);
551 30898769 : if (error)
552 0 : goto out;
553 :
554 30898769 : error = __vfs_removexattr(idmap, dentry, name);
555 :
556 30897662 : if (!error) {
557 20561637 : fsnotify_xattr(dentry);
558 : evm_inode_post_removexattr(dentry, name);
559 : }
560 :
561 10336025 : out:
562 : return error;
563 : }
564 : EXPORT_SYMBOL_GPL(__vfs_removexattr_locked);
565 :
566 : int
567 30896884 : vfs_removexattr(struct mnt_idmap *idmap, struct dentry *dentry,
568 : const char *name)
569 : {
570 30896884 : struct inode *inode = dentry->d_inode;
571 30896884 : struct inode *delegated_inode = NULL;
572 30896884 : int error;
573 :
574 30896884 : retry_deleg:
575 30896884 : inode_lock(inode);
576 30898801 : error = __vfs_removexattr_locked(idmap, dentry,
577 : name, &delegated_inode);
578 30897016 : inode_unlock(inode);
579 :
580 30897644 : if (delegated_inode) {
581 0 : error = break_deleg_wait(&delegated_inode);
582 0 : if (!error)
583 0 : goto retry_deleg;
584 : }
585 :
586 30897644 : return error;
587 : }
588 : EXPORT_SYMBOL_GPL(vfs_removexattr);
589 :
590 : /*
591 : * Extended attribute SET operations
592 : */
593 :
594 139715644 : int setxattr_copy(const char __user *name, struct xattr_ctx *ctx)
595 : {
596 139715644 : int error;
597 :
598 139715644 : if (ctx->flags & ~(XATTR_CREATE|XATTR_REPLACE))
599 : return -EINVAL;
600 :
601 139715644 : error = strncpy_from_user(ctx->kname->name, name,
602 : sizeof(ctx->kname->name));
603 139722351 : if (error == 0 || error == sizeof(ctx->kname->name))
604 : return -ERANGE;
605 139722351 : if (error < 0)
606 : return error;
607 :
608 139722351 : error = 0;
609 139722351 : if (ctx->size) {
610 139057337 : if (ctx->size > XATTR_SIZE_MAX)
611 : return -E2BIG;
612 :
613 139057337 : ctx->kvalue = vmemdup_user(ctx->cvalue, ctx->size);
614 139043560 : if (IS_ERR(ctx->kvalue)) {
615 0 : error = PTR_ERR(ctx->kvalue);
616 0 : ctx->kvalue = NULL;
617 : }
618 : }
619 :
620 : return error;
621 : }
622 :
623 139737343 : int do_setxattr(struct mnt_idmap *idmap, struct dentry *dentry,
624 : struct xattr_ctx *ctx)
625 : {
626 139737343 : if (is_posix_acl_xattr(ctx->kname->name))
627 1856023 : return do_set_acl(idmap, dentry, ctx->kname->name,
628 1856023 : ctx->kvalue, ctx->size);
629 :
630 137881320 : return vfs_setxattr(idmap, dentry, ctx->kname->name,
631 137881320 : ctx->kvalue, ctx->size, ctx->flags);
632 : }
633 :
634 : static long
635 139756127 : setxattr(struct mnt_idmap *idmap, struct dentry *d,
636 : const char __user *name, const void __user *value, size_t size,
637 : int flags)
638 : {
639 139756127 : struct xattr_name kname;
640 139756127 : struct xattr_ctx ctx = {
641 : .cvalue = value,
642 : .kvalue = NULL,
643 : .size = size,
644 : .kname = &kname,
645 : .flags = flags,
646 : };
647 139756127 : int error;
648 :
649 139756127 : error = setxattr_copy(name, &ctx);
650 139726301 : if (error)
651 0 : return error;
652 :
653 139726301 : error = do_setxattr(idmap, d, &ctx);
654 :
655 139677020 : kvfree(ctx.kvalue);
656 139729236 : return error;
657 : }
658 :
659 137708785 : static int path_setxattr(const char __user *pathname,
660 : const char __user *name, const void __user *value,
661 : size_t size, int flags, unsigned int lookup_flags)
662 : {
663 137704619 : struct path path;
664 137704619 : int error;
665 :
666 137704619 : retry:
667 137704619 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
668 137772713 : if (error)
669 0 : return error;
670 137772713 : error = mnt_want_write(path.mnt);
671 137772427 : if (!error) {
672 137774082 : error = setxattr(mnt_idmap(path.mnt), path.dentry, name,
673 : value, size, flags);
674 137724488 : mnt_drop_write(path.mnt);
675 : }
676 137743072 : path_put(&path);
677 275508390 : if (retry_estale(error, lookup_flags)) {
678 0 : lookup_flags |= LOOKUP_REVAL;
679 0 : goto retry;
680 : }
681 : return error;
682 : }
683 :
684 138674360 : SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
685 : const char __user *, name, const void __user *, value,
686 : size_t, size, int, flags)
687 : {
688 69329977 : return path_setxattr(pathname, name, value, size, flags, LOOKUP_FOLLOW);
689 : }
690 :
691 136852818 : SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
692 : const char __user *, name, const void __user *, value,
693 : size_t, size, int, flags)
694 : {
695 68418302 : return path_setxattr(pathname, name, value, size, flags, 0);
696 : }
697 :
698 3963602 : SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
699 : const void __user *,value, size_t, size, int, flags)
700 : {
701 1981802 : struct fd f = fdget(fd);
702 1981804 : int error = -EBADF;
703 :
704 1981804 : if (!f.file)
705 : return error;
706 1981804 : audit_file(f.file);
707 1981804 : error = mnt_want_write_file(f.file);
708 1981801 : if (!error) {
709 1981807 : error = setxattr(file_mnt_idmap(f.file),
710 : f.file->f_path.dentry, name,
711 : value, size, flags);
712 1981811 : mnt_drop_write_file(f.file);
713 : }
714 1981802 : fdput(f);
715 1981802 : return error;
716 : }
717 :
718 : /*
719 : * Extended attribute GET operations
720 : */
721 : ssize_t
722 14973849 : do_getxattr(struct mnt_idmap *idmap, struct dentry *d,
723 : struct xattr_ctx *ctx)
724 : {
725 14973849 : ssize_t error;
726 14973849 : char *kname = ctx->kname->name;
727 :
728 14973849 : if (ctx->size) {
729 5701658 : if (ctx->size > XATTR_SIZE_MAX)
730 0 : ctx->size = XATTR_SIZE_MAX;
731 5701658 : ctx->kvalue = kvzalloc(ctx->size, GFP_KERNEL);
732 5701685 : if (!ctx->kvalue)
733 : return -ENOMEM;
734 : }
735 :
736 14973876 : if (is_posix_acl_xattr(ctx->kname->name))
737 1893117 : error = do_get_acl(idmap, d, kname, ctx->kvalue, ctx->size);
738 : else
739 13080759 : error = vfs_getxattr(idmap, d, kname, ctx->kvalue, ctx->size);
740 14974007 : if (error > 0) {
741 11280201 : if (ctx->size && copy_to_user(ctx->value, ctx->kvalue, error))
742 0 : error = -EFAULT;
743 7453937 : } else if (error == -ERANGE && ctx->size >= XATTR_SIZE_MAX) {
744 : /* The file system tried to returned a value bigger
745 : than XATTR_SIZE_MAX bytes. Not possible. */
746 0 : error = -E2BIG;
747 : }
748 :
749 : return error;
750 : }
751 :
752 : static ssize_t
753 14973731 : getxattr(struct mnt_idmap *idmap, struct dentry *d,
754 : const char __user *name, void __user *value, size_t size)
755 : {
756 14973731 : ssize_t error;
757 14973731 : struct xattr_name kname;
758 14973731 : struct xattr_ctx ctx = {
759 : .value = value,
760 : .kvalue = NULL,
761 : .size = size,
762 : .kname = &kname,
763 : .flags = 0,
764 : };
765 :
766 14973731 : error = strncpy_from_user(kname.name, name, sizeof(kname.name));
767 14973865 : if (error == 0 || error == sizeof(kname.name))
768 : error = -ERANGE;
769 14973865 : if (error < 0)
770 0 : return error;
771 :
772 14973865 : error = do_getxattr(idmap, d, &ctx);
773 :
774 14973961 : kvfree(ctx.kvalue);
775 14973961 : return error;
776 : }
777 :
778 13135997 : static ssize_t path_getxattr(const char __user *pathname,
779 : const char __user *name, void __user *value,
780 : size_t size, unsigned int lookup_flags)
781 : {
782 13135984 : struct path path;
783 13135984 : ssize_t error;
784 13135984 : retry:
785 13135984 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
786 13136615 : if (error)
787 0 : return error;
788 13136615 : error = getxattr(mnt_idmap(path.mnt), path.dentry, name, value, size);
789 13136478 : path_put(&path);
790 26273372 : if (retry_estale(error, lookup_flags)) {
791 0 : lookup_flags |= LOOKUP_REVAL;
792 0 : goto retry;
793 : }
794 : return error;
795 : }
796 :
797 26232082 : SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
798 : const char __user *, name, void __user *, value, size_t, size)
799 : {
800 13115715 : return path_getxattr(pathname, name, value, size, LOOKUP_FOLLOW);
801 : }
802 :
803 40548 : SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
804 : const char __user *, name, void __user *, value, size_t, size)
805 : {
806 20274 : return path_getxattr(pathname, name, value, size, 0);
807 : }
808 :
809 3674802 : SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
810 : void __user *, value, size_t, size)
811 : {
812 1837400 : struct fd f = fdget(fd);
813 1837401 : ssize_t error = -EBADF;
814 :
815 1837401 : if (!f.file)
816 : return error;
817 1837401 : audit_file(f.file);
818 1837401 : error = getxattr(file_mnt_idmap(f.file), f.file->f_path.dentry,
819 : name, value, size);
820 1837411 : fdput(f);
821 1837411 : return error;
822 : }
823 :
824 : /*
825 : * Extended attribute LIST operations
826 : */
827 : static ssize_t
828 38148538 : listxattr(struct dentry *d, char __user *list, size_t size)
829 : {
830 38148538 : ssize_t error;
831 38148538 : char *klist = NULL;
832 :
833 38148538 : if (size) {
834 25243388 : if (size > XATTR_LIST_MAX)
835 : size = XATTR_LIST_MAX;
836 25243388 : klist = kvmalloc(size, GFP_KERNEL);
837 25242858 : if (!klist)
838 : return -ENOMEM;
839 : }
840 :
841 38148008 : error = vfs_listxattr(d, klist, size);
842 38150482 : if (error > 0) {
843 57629129 : if (size && copy_to_user(list, klist, error))
844 0 : error = -EFAULT;
845 5150146 : } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
846 : /* The file system tried to returned a list bigger
847 : than XATTR_LIST_MAX bytes. Not possible. */
848 0 : error = -E2BIG;
849 : }
850 :
851 38150879 : kvfree(klist);
852 :
853 38150879 : return error;
854 : }
855 :
856 34524926 : static ssize_t path_listxattr(const char __user *pathname, char __user *list,
857 : size_t size, unsigned int lookup_flags)
858 : {
859 34524858 : struct path path;
860 34524858 : ssize_t error;
861 34524858 : retry:
862 34524858 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
863 34530023 : if (error)
864 2 : return error;
865 34530021 : error = listxattr(path.dentry, list, size);
866 34527309 : path_put(&path);
867 69058732 : if (retry_estale(error, lookup_flags)) {
868 0 : lookup_flags |= LOOKUP_REVAL;
869 0 : goto retry;
870 : }
871 : return error;
872 : }
873 :
874 35237136 : SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
875 : size_t, size)
876 : {
877 17618463 : return path_listxattr(pathname, list, size, LOOKUP_FOLLOW);
878 : }
879 :
880 33820664 : SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
881 : size_t, size)
882 : {
883 16909812 : return path_listxattr(pathname, list, size, 0);
884 : }
885 :
886 7243964 : SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
887 : {
888 3621982 : struct fd f = fdget(fd);
889 3621971 : ssize_t error = -EBADF;
890 :
891 3621971 : if (!f.file)
892 : return error;
893 3621971 : audit_file(f.file);
894 3621971 : error = listxattr(f.file->f_path.dentry, list, size);
895 3622042 : fdput(f);
896 3622042 : return error;
897 : }
898 :
899 : /*
900 : * Extended attribute REMOVE operations
901 : */
902 : static long
903 30907509 : removexattr(struct mnt_idmap *idmap, struct dentry *d,
904 : const char __user *name)
905 : {
906 30907509 : int error;
907 30907509 : char kname[XATTR_NAME_MAX + 1];
908 :
909 30907509 : error = strncpy_from_user(kname, name, sizeof(kname));
910 30908248 : if (error == 0 || error == sizeof(kname))
911 : error = -ERANGE;
912 30908248 : if (error < 0)
913 0 : return error;
914 :
915 30908248 : if (is_posix_acl_xattr(kname))
916 17440 : return vfs_remove_acl(idmap, d, kname);
917 :
918 30890808 : return vfs_removexattr(idmap, d, kname);
919 : }
920 :
921 30906560 : static int path_removexattr(const char __user *pathname,
922 : const char __user *name, unsigned int lookup_flags)
923 : {
924 30905874 : struct path path;
925 30905874 : int error;
926 30905874 : retry:
927 30905874 : error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
928 30906270 : if (error)
929 0 : return error;
930 30906270 : error = mnt_want_write(path.mnt);
931 30908068 : if (!error) {
932 30908079 : error = removexattr(mnt_idmap(path.mnt), path.dentry, name);
933 30906971 : mnt_drop_write(path.mnt);
934 : }
935 30907959 : path_put(&path);
936 61814560 : if (retry_estale(error, lookup_flags)) {
937 0 : lookup_flags |= LOOKUP_REVAL;
938 0 : goto retry;
939 : }
940 : return error;
941 : }
942 :
943 35500466 : SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
944 : const char __user *, name)
945 : {
946 17749886 : return path_removexattr(pathname, name, LOOKUP_FOLLOW);
947 : }
948 :
949 26314125 : SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
950 : const char __user *, name)
951 : {
952 13156839 : return path_removexattr(pathname, name, 0);
953 : }
954 :
955 32 : SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
956 : {
957 16 : struct fd f = fdget(fd);
958 16 : int error = -EBADF;
959 :
960 16 : if (!f.file)
961 : return error;
962 16 : audit_file(f.file);
963 16 : error = mnt_want_write_file(f.file);
964 16 : if (!error) {
965 16 : error = removexattr(file_mnt_idmap(f.file),
966 : f.file->f_path.dentry, name);
967 16 : mnt_drop_write_file(f.file);
968 : }
969 16 : fdput(f);
970 16 : return error;
971 : }
972 :
973 4 : int xattr_list_one(char **buffer, ssize_t *remaining_size, const char *name)
974 : {
975 4 : size_t len;
976 :
977 4 : len = strlen(name) + 1;
978 4 : if (*buffer) {
979 2 : if (*remaining_size < len)
980 : return -ERANGE;
981 4 : memcpy(*buffer, name, len);
982 2 : *buffer += len;
983 : }
984 4 : *remaining_size -= len;
985 4 : return 0;
986 : }
987 :
988 : /**
989 : * generic_listxattr - run through a dentry's xattr list() operations
990 : * @dentry: dentry to list the xattrs
991 : * @buffer: result buffer
992 : * @buffer_size: size of @buffer
993 : *
994 : * Combine the results of the list() operation from every xattr_handler in the
995 : * xattr_handler stack.
996 : *
997 : * Note that this will not include the entries for POSIX ACLs.
998 : */
999 : ssize_t
1000 4 : generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
1001 : {
1002 4 : const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
1003 4 : ssize_t remaining_size = buffer_size;
1004 4 : int err = 0;
1005 :
1006 20 : for_each_xattr_handler(handlers, handler) {
1007 16 : if (!handler->name || (handler->list && !handler->list(dentry)))
1008 12 : continue;
1009 4 : err = xattr_list_one(&buffer, &remaining_size, handler->name);
1010 4 : if (err)
1011 0 : return err;
1012 : }
1013 :
1014 4 : return err ? err : buffer_size - remaining_size;
1015 : }
1016 : EXPORT_SYMBOL(generic_listxattr);
1017 :
1018 : /**
1019 : * xattr_full_name - Compute full attribute name from suffix
1020 : *
1021 : * @handler: handler of the xattr_handler operation
1022 : * @name: name passed to the xattr_handler operation
1023 : *
1024 : * The get and set xattr handler operations are called with the remainder of
1025 : * the attribute name after skipping the handler's prefix: for example, "foo"
1026 : * is passed to the get operation of a handler with prefix "user." to get
1027 : * attribute "user.foo". The full name is still "there" in the name though.
1028 : *
1029 : * Note: the list xattr handler operation when called from the vfs is passed a
1030 : * NULL name; some file systems use this operation internally, with varying
1031 : * semantics.
1032 : */
1033 2678942 : const char *xattr_full_name(const struct xattr_handler *handler,
1034 : const char *name)
1035 : {
1036 2678942 : size_t prefix_len = strlen(xattr_prefix(handler));
1037 :
1038 2678942 : return name - prefix_len;
1039 : }
1040 : EXPORT_SYMBOL(xattr_full_name);
1041 :
1042 : /**
1043 : * free_simple_xattr - free an xattr object
1044 : * @xattr: the xattr object
1045 : *
1046 : * Free the xattr object. Can handle @xattr being NULL.
1047 : */
1048 73330 : static inline void free_simple_xattr(struct simple_xattr *xattr)
1049 : {
1050 73330 : if (xattr)
1051 14117 : kfree(xattr->name);
1052 73330 : kvfree(xattr);
1053 73330 : }
1054 :
1055 : /**
1056 : * simple_xattr_alloc - allocate new xattr object
1057 : * @value: value of the xattr object
1058 : * @size: size of @value
1059 : *
1060 : * Allocate a new xattr object and initialize respective members. The caller is
1061 : * responsible for handling the name of the xattr.
1062 : *
1063 : * Return: On success a new xattr object is returned. On failure NULL is
1064 : * returned.
1065 : */
1066 16287 : struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
1067 : {
1068 16287 : struct simple_xattr *new_xattr;
1069 16287 : size_t len;
1070 :
1071 : /* wrap around? */
1072 16287 : len = sizeof(*new_xattr) + size;
1073 16287 : if (len < sizeof(*new_xattr))
1074 : return NULL;
1075 :
1076 16287 : new_xattr = kvmalloc(len, GFP_KERNEL);
1077 16287 : if (!new_xattr)
1078 : return NULL;
1079 :
1080 16287 : new_xattr->size = size;
1081 32574 : memcpy(new_xattr->value, value, size);
1082 16287 : return new_xattr;
1083 : }
1084 :
1085 : /**
1086 : * rbtree_simple_xattr_cmp - compare xattr name with current rbtree xattr entry
1087 : * @key: xattr name
1088 : * @node: current node
1089 : *
1090 : * Compare the xattr name with the xattr name attached to @node in the rbtree.
1091 : *
1092 : * Return: Negative value if continuing left, positive if continuing right, 0
1093 : * if the xattr attached to @node matches @key.
1094 : */
1095 : static int rbtree_simple_xattr_cmp(const void *key, const struct rb_node *node)
1096 : {
1097 110402 : const char *xattr_name = key;
1098 110402 : const struct simple_xattr *xattr;
1099 :
1100 110402 : xattr = rb_entry(node, struct simple_xattr, rb_node);
1101 56483 : return strcmp(xattr->name, xattr_name);
1102 : }
1103 :
1104 : /**
1105 : * rbtree_simple_xattr_node_cmp - compare two xattr rbtree nodes
1106 : * @new_node: new node
1107 : * @node: current node
1108 : *
1109 : * Compare the xattr attached to @new_node with the xattr attached to @node.
1110 : *
1111 : * Return: Negative value if continuing left, positive if continuing right, 0
1112 : * if the xattr attached to @new_node matches the xattr attached to @node.
1113 : */
1114 : static int rbtree_simple_xattr_node_cmp(struct rb_node *new_node,
1115 : const struct rb_node *node)
1116 : {
1117 0 : struct simple_xattr *xattr;
1118 0 : xattr = rb_entry(new_node, struct simple_xattr, rb_node);
1119 0 : return rbtree_simple_xattr_cmp(xattr->name, node);
1120 : }
1121 :
1122 : /**
1123 : * simple_xattr_get - get an xattr object
1124 : * @xattrs: the header of the xattr object
1125 : * @name: the name of the xattr to retrieve
1126 : * @buffer: the buffer to store the value into
1127 : * @size: the size of @buffer
1128 : *
1129 : * Try to find and retrieve the xattr object associated with @name.
1130 : * If @buffer is provided store the value of @xattr in @buffer
1131 : * otherwise just return the length. The size of @buffer is limited
1132 : * to XATTR_SIZE_MAX which currently is 65536.
1133 : *
1134 : * Return: On success the length of the xattr value is returned. On error a
1135 : * negative error code is returned.
1136 : */
1137 2589232 : int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
1138 : void *buffer, size_t size)
1139 : {
1140 2589232 : struct simple_xattr *xattr = NULL;
1141 2589232 : struct rb_node *rbp;
1142 2589232 : int ret = -ENODATA;
1143 :
1144 2589232 : read_lock(&xattrs->lock);
1145 2589574 : rbp = rb_find(name, &xattrs->rb_root, rbtree_simple_xattr_cmp);
1146 2589574 : if (rbp) {
1147 2575 : xattr = rb_entry(rbp, struct simple_xattr, rb_node);
1148 2575 : ret = xattr->size;
1149 2575 : if (buffer) {
1150 1343 : if (size < xattr->size)
1151 : ret = -ERANGE;
1152 : else
1153 2686 : memcpy(buffer, xattr->value, xattr->size);
1154 : }
1155 : }
1156 2589574 : read_unlock(&xattrs->lock);
1157 2589573 : return ret;
1158 : }
1159 :
1160 : /**
1161 : * simple_xattr_set - set an xattr object
1162 : * @xattrs: the header of the xattr object
1163 : * @name: the name of the xattr to retrieve
1164 : * @value: the value to store along the xattr
1165 : * @size: the size of @value
1166 : * @flags: the flags determining how to set the xattr
1167 : * @removed_size: the size of the removed xattr
1168 : *
1169 : * Set a new xattr object.
1170 : * If @value is passed a new xattr object will be allocated. If XATTR_REPLACE
1171 : * is specified in @flags a matching xattr object for @name must already exist.
1172 : * If it does it will be replaced with the new xattr object. If it doesn't we
1173 : * fail. If XATTR_CREATE is specified and a matching xattr does already exist
1174 : * we fail. If it doesn't we create a new xattr. If @flags is zero we simply
1175 : * insert the new xattr replacing any existing one.
1176 : *
1177 : * If @value is empty and a matching xattr object is found we delete it if
1178 : * XATTR_REPLACE is specified in @flags or @flags is zero.
1179 : *
1180 : * If @value is empty and no matching xattr object for @name is found we do
1181 : * nothing if XATTR_CREATE is specified in @flags or @flags is zero. For
1182 : * XATTR_REPLACE we fail as mentioned above.
1183 : *
1184 : * Return: On success zero and on error a negative error code is returned.
1185 : */
1186 64850 : int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
1187 : const void *value, size_t size, int flags,
1188 : ssize_t *removed_size)
1189 : {
1190 64850 : struct simple_xattr *xattr = NULL, *new_xattr = NULL;
1191 64850 : struct rb_node *parent = NULL, **rbp;
1192 64850 : int err = 0, ret;
1193 :
1194 64850 : if (removed_size)
1195 32468 : *removed_size = -1;
1196 :
1197 : /* value == NULL means remove */
1198 64850 : if (value) {
1199 16287 : new_xattr = simple_xattr_alloc(value, size);
1200 16287 : if (!new_xattr)
1201 : return -ENOMEM;
1202 :
1203 16287 : new_xattr->name = kstrdup(name, GFP_KERNEL);
1204 16287 : if (!new_xattr->name) {
1205 0 : free_simple_xattr(new_xattr);
1206 0 : return -ENOMEM;
1207 : }
1208 : }
1209 :
1210 64850 : write_lock(&xattrs->lock);
1211 64850 : rbp = &xattrs->rb_root.rb_node;
1212 113132 : while (*rbp) {
1213 53919 : parent = *rbp;
1214 53919 : ret = rbtree_simple_xattr_cmp(name, *rbp);
1215 53919 : if (ret < 0)
1216 32188 : rbp = &(*rbp)->rb_left;
1217 21731 : else if (ret > 0)
1218 16094 : rbp = &(*rbp)->rb_right;
1219 : else
1220 : xattr = rb_entry(*rbp, struct simple_xattr, rb_node);
1221 53919 : if (xattr)
1222 : break;
1223 : }
1224 :
1225 64850 : if (xattr) {
1226 : /* Fail if XATTR_CREATE is requested and the xattr exists. */
1227 5637 : if (flags & XATTR_CREATE) {
1228 0 : err = -EEXIST;
1229 0 : goto out_unlock;
1230 : }
1231 :
1232 5637 : if (new_xattr)
1233 5637 : rb_replace_node(&xattr->rb_node, &new_xattr->rb_node,
1234 : &xattrs->rb_root);
1235 : else
1236 0 : rb_erase(&xattr->rb_node, &xattrs->rb_root);
1237 5637 : if (!err && removed_size)
1238 0 : *removed_size = xattr->size;
1239 : } else {
1240 : /* Fail if XATTR_REPLACE is requested but no xattr is found. */
1241 59213 : if (flags & XATTR_REPLACE) {
1242 48563 : err = -ENODATA;
1243 48563 : goto out_unlock;
1244 : }
1245 :
1246 : /*
1247 : * If XATTR_CREATE or no flags are specified together with a
1248 : * new value simply insert it.
1249 : */
1250 10650 : if (new_xattr) {
1251 10650 : rb_link_node(&new_xattr->rb_node, parent, rbp);
1252 10650 : rb_insert_color(&new_xattr->rb_node, &xattrs->rb_root);
1253 : }
1254 :
1255 : /*
1256 : * If XATTR_CREATE or no flags are specified and neither an
1257 : * old or new xattr exist then we don't need to do anything.
1258 : */
1259 : }
1260 :
1261 0 : out_unlock:
1262 64850 : write_unlock(&xattrs->lock);
1263 64850 : if (err)
1264 48563 : free_simple_xattr(new_xattr);
1265 : else
1266 16287 : free_simple_xattr(xattr);
1267 : return err;
1268 :
1269 : }
1270 :
1271 : static bool xattr_is_trusted(const char *name)
1272 : {
1273 0 : return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
1274 : }
1275 :
1276 : /**
1277 : * simple_xattr_list - list all xattr objects
1278 : * @inode: inode from which to get the xattrs
1279 : * @xattrs: the header of the xattr object
1280 : * @buffer: the buffer to store all xattrs into
1281 : * @size: the size of @buffer
1282 : *
1283 : * List all xattrs associated with @inode. If @buffer is NULL we returned
1284 : * the required size of the buffer. If @buffer is provided we store the
1285 : * xattrs value into it provided it is big enough.
1286 : *
1287 : * Note, the number of xattr names that can be listed with listxattr(2) is
1288 : * limited to XATTR_LIST_MAX aka 65536 bytes. If a larger buffer is passed
1289 : * then vfs_listxattr() caps it to XATTR_LIST_MAX and if more xattr names
1290 : * are found it will return -E2BIG.
1291 : *
1292 : * Return: On success the required size or the size of the copied xattrs is
1293 : * returned. On error a negative error code is returned.
1294 : */
1295 3655281 : ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
1296 : char *buffer, size_t size)
1297 : {
1298 3655281 : bool trusted = ns_capable_noaudit(&init_user_ns, CAP_SYS_ADMIN);
1299 3655337 : struct simple_xattr *xattr;
1300 3655337 : struct rb_node *rbp;
1301 3655337 : ssize_t remaining_size = size;
1302 3655337 : int err = 0;
1303 :
1304 3655337 : err = posix_acl_listxattr(inode, &buffer, &remaining_size);
1305 3655380 : if (err)
1306 0 : return err;
1307 :
1308 3655380 : read_lock(&xattrs->lock);
1309 3655327 : for (rbp = rb_first(&xattrs->rb_root); rbp; rbp = rb_next(rbp)) {
1310 0 : xattr = rb_entry(rbp, struct simple_xattr, rb_node);
1311 :
1312 : /* skip "trusted." attributes for unprivileged callers */
1313 0 : if (!trusted && xattr_is_trusted(xattr->name))
1314 0 : continue;
1315 :
1316 0 : err = xattr_list_one(&buffer, &remaining_size, xattr->name);
1317 0 : if (err)
1318 : break;
1319 : }
1320 3655315 : read_unlock(&xattrs->lock);
1321 :
1322 3655413 : return err ? err : size - remaining_size;
1323 : }
1324 :
1325 : /**
1326 : * rbtree_simple_xattr_less - compare two xattr rbtree nodes
1327 : * @new_node: new node
1328 : * @node: current node
1329 : *
1330 : * Compare the xattr attached to @new_node with the xattr attached to @node.
1331 : * Note that this function technically tolerates duplicate entries.
1332 : *
1333 : * Return: True if insertion point in the rbtree is found.
1334 : */
1335 : static bool rbtree_simple_xattr_less(struct rb_node *new_node,
1336 : const struct rb_node *node)
1337 : {
1338 0 : return rbtree_simple_xattr_node_cmp(new_node, node) < 0;
1339 : }
1340 :
1341 : /**
1342 : * simple_xattr_add - add xattr objects
1343 : * @xattrs: the header of the xattr object
1344 : * @new_xattr: the xattr object to add
1345 : *
1346 : * Add an xattr object to @xattrs. This assumes no replacement or removal
1347 : * of matching xattrs is wanted. Should only be called during inode
1348 : * initialization when a few distinct initial xattrs are supposed to be set.
1349 : */
1350 0 : void simple_xattr_add(struct simple_xattrs *xattrs,
1351 : struct simple_xattr *new_xattr)
1352 : {
1353 0 : write_lock(&xattrs->lock);
1354 0 : rb_add(&new_xattr->rb_node, &xattrs->rb_root, rbtree_simple_xattr_less);
1355 0 : write_unlock(&xattrs->lock);
1356 0 : }
1357 :
1358 : /**
1359 : * simple_xattrs_init - initialize new xattr header
1360 : * @xattrs: header to initialize
1361 : *
1362 : * Initialize relevant fields of a an xattr header.
1363 : */
1364 951514 : void simple_xattrs_init(struct simple_xattrs *xattrs)
1365 : {
1366 951514 : xattrs->rb_root = RB_ROOT;
1367 951514 : rwlock_init(&xattrs->lock);
1368 951513 : }
1369 :
1370 : /**
1371 : * simple_xattrs_free - free xattrs
1372 : * @xattrs: xattr header whose xattrs to destroy
1373 : *
1374 : * Destroy all xattrs in @xattr. When this is called no one can hold a
1375 : * reference to any of the xattrs anymore.
1376 : */
1377 945932 : void simple_xattrs_free(struct simple_xattrs *xattrs)
1378 : {
1379 945932 : struct rb_node *rbp;
1380 :
1381 945932 : rbp = rb_first(&xattrs->rb_root);
1382 954411 : while (rbp) {
1383 8480 : struct simple_xattr *xattr;
1384 8480 : struct rb_node *rbp_next;
1385 :
1386 8480 : rbp_next = rb_next(rbp);
1387 8480 : xattr = rb_entry(rbp, struct simple_xattr, rb_node);
1388 8480 : rb_erase(&xattr->rb_node, &xattrs->rb_root);
1389 8480 : free_simple_xattr(xattr);
1390 8480 : rbp = rbp_next;
1391 : }
1392 945931 : }
|
