4 Extended attribute handling.
6 Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
7 Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
8 Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
11 #include <linux/slab.h>
12 #include <linux/file.h>
13 #include <linux/xattr.h>
14 #include <linux/mount.h>
15 #include <linux/namei.h>
16 #include <linux/security.h>
17 #include <linux/evm.h>
18 #include <linux/syscalls.h>
19 #include <linux/export.h>
20 #include <linux/fsnotify.h>
21 #include <linux/audit.h>
22 #include <linux/vmalloc.h>
23 #include <linux/posix_acl_xattr.h>
25 #include <linux/uaccess.h>
28 strcmp_prefix(const char *a
, const char *a_prefix
)
30 while (*a_prefix
&& *a
== *a_prefix
) {
34 return *a_prefix
? NULL
: a
;
38 * In order to implement different sets of xattr operations for each xattr
39 * prefix, a filesystem should create a null-terminated array of struct
40 * xattr_handler (one for each prefix) and hang a pointer to it off of the
41 * s_xattr field of the superblock.
43 #define for_each_xattr_handler(handlers, handler) \
45 for ((handler) = *(handlers)++; \
47 (handler) = *(handlers)++)
50 * Find the xattr_handler with the matching prefix.
52 static const struct xattr_handler
*
53 xattr_resolve_name(struct inode
*inode
, const char **name
)
55 const struct xattr_handler
**handlers
= inode
->i_sb
->s_xattr
;
56 const struct xattr_handler
*handler
;
58 if (!(inode
->i_opflags
& IOP_XATTR
)) {
59 if (unlikely(is_bad_inode(inode
)))
61 return ERR_PTR(-EOPNOTSUPP
);
63 for_each_xattr_handler(handlers
, handler
) {
66 n
= strcmp_prefix(*name
, xattr_prefix(handler
));
68 if (!handler
->prefix
^ !*n
) {
71 return ERR_PTR(-EINVAL
);
77 return ERR_PTR(-EOPNOTSUPP
);
81 * Check permissions for extended attribute access. This is a bit complicated
82 * because different namespaces have very different rules.
85 xattr_permission(struct inode
*inode
, const char *name
, int mask
)
88 * We can never set or remove an extended attribute on a read-only
89 * filesystem or on an immutable / append-only inode.
91 if (mask
& MAY_WRITE
) {
92 if (IS_IMMUTABLE(inode
) || IS_APPEND(inode
))
95 * Updating an xattr will likely cause i_uid and i_gid
96 * to be writen back improperly if their true value is
99 if (HAS_UNMAPPED_ID(inode
))
104 * No restriction for security.* and system.* from the VFS. Decision
105 * on these is left to the underlying filesystem / security module.
107 if (!strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
) ||
108 !strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
112 * The trusted.* namespace can only be accessed by privileged users.
114 if (!strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
)) {
115 if (!capable(CAP_SYS_ADMIN
))
116 return (mask
& MAY_WRITE
) ? -EPERM
: -ENODATA
;
121 * In the user.* namespace, only regular files and directories can have
122 * extended attributes. For sticky directories, only the owner and
123 * privileged users can write attributes.
125 if (!strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
)) {
126 if (!S_ISREG(inode
->i_mode
) && !S_ISDIR(inode
->i_mode
))
127 return (mask
& MAY_WRITE
) ? -EPERM
: -ENODATA
;
128 if (S_ISDIR(inode
->i_mode
) && (inode
->i_mode
& S_ISVTX
) &&
129 (mask
& MAY_WRITE
) && !inode_owner_or_capable(inode
))
133 return inode_permission(inode
, mask
);
137 __vfs_setxattr(struct dentry
*dentry
, struct inode
*inode
, const char *name
,
138 const void *value
, size_t size
, int flags
)
140 const struct xattr_handler
*handler
;
142 handler
= xattr_resolve_name(inode
, &name
);
144 return PTR_ERR(handler
);
148 value
= ""; /* empty EA, do not remove */
149 return handler
->set(handler
, dentry
, inode
, name
, value
, size
, flags
);
151 EXPORT_SYMBOL(__vfs_setxattr
);
154 * __vfs_setxattr_noperm - perform setxattr operation without performing
157 * @dentry - object to perform setxattr on
158 * @name - xattr name to set
159 * @value - value to set @name to
160 * @size - size of @value
161 * @flags - flags to pass into filesystem operations
163 * returns the result of the internal setxattr or setsecurity operations.
165 * This function requires the caller to lock the inode's i_mutex before it
166 * is executed. It also assumes that the caller will make the appropriate
169 int __vfs_setxattr_noperm(struct dentry
*dentry
, const char *name
,
170 const void *value
, size_t size
, int flags
)
172 struct inode
*inode
= dentry
->d_inode
;
174 int issec
= !strncmp(name
, XATTR_SECURITY_PREFIX
,
175 XATTR_SECURITY_PREFIX_LEN
);
178 inode
->i_flags
&= ~S_NOSEC
;
179 if (inode
->i_opflags
& IOP_XATTR
) {
180 error
= __vfs_setxattr(dentry
, inode
, name
, value
, size
, flags
);
182 fsnotify_xattr(dentry
);
183 security_inode_post_setxattr(dentry
, name
, value
,
187 if (unlikely(is_bad_inode(inode
)))
190 if (error
== -EAGAIN
) {
194 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
196 error
= security_inode_setsecurity(inode
, suffix
, value
,
199 fsnotify_xattr(dentry
);
208 vfs_setxattr(struct dentry
*dentry
, const char *name
, const void *value
,
209 size_t size
, int flags
)
211 struct inode
*inode
= dentry
->d_inode
;
214 error
= xattr_permission(inode
, name
, MAY_WRITE
);
219 error
= security_inode_setxattr(dentry
, name
, value
, size
, flags
);
223 error
= __vfs_setxattr_noperm(dentry
, name
, value
, size
, flags
);
229 EXPORT_SYMBOL_GPL(vfs_setxattr
);
232 xattr_getsecurity(struct inode
*inode
, const char *name
, void *value
,
238 if (!value
|| !size
) {
239 len
= security_inode_getsecurity(inode
, name
, &buffer
, false);
243 len
= security_inode_getsecurity(inode
, name
, &buffer
, true);
250 memcpy(value
, buffer
, len
);
252 security_release_secctx(buffer
, len
);
256 EXPORT_SYMBOL_GPL(xattr_getsecurity
);
259 * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
261 * Allocate memory, if not already allocated, or re-allocate correct size,
262 * before retrieving the extended attribute.
264 * Returns the result of alloc, if failed, or the getxattr operation.
267 vfs_getxattr_alloc(struct dentry
*dentry
, const char *name
, char **xattr_value
,
268 size_t xattr_size
, gfp_t flags
)
270 const struct xattr_handler
*handler
;
271 struct inode
*inode
= dentry
->d_inode
;
272 char *value
= *xattr_value
;
275 error
= xattr_permission(inode
, name
, MAY_READ
);
279 handler
= xattr_resolve_name(inode
, &name
);
281 return PTR_ERR(handler
);
284 error
= handler
->get(handler
, dentry
, inode
, name
, NULL
, 0);
288 if (!value
|| (error
> xattr_size
)) {
289 value
= krealloc(*xattr_value
, error
+ 1, flags
);
292 memset(value
, 0, error
+ 1);
295 error
= handler
->get(handler
, dentry
, inode
, name
, value
, error
);
296 *xattr_value
= value
;
299 EXPORT_SYMBOL_GPL(vfs_getxattr_alloc
);
302 __vfs_getxattr(struct dentry
*dentry
, struct inode
*inode
, const char *name
,
303 void *value
, size_t size
)
305 const struct xattr_handler
*handler
;
307 handler
= xattr_resolve_name(inode
, &name
);
309 return PTR_ERR(handler
);
312 return handler
->get(handler
, dentry
, inode
, name
, value
, size
);
314 EXPORT_SYMBOL(__vfs_getxattr
);
317 vfs_getxattr(struct dentry
*dentry
, const char *name
, void *value
, size_t size
)
319 struct inode
*inode
= dentry
->d_inode
;
322 error
= xattr_permission(inode
, name
, MAY_READ
);
326 error
= security_inode_getxattr(dentry
, name
);
330 if (!strncmp(name
, XATTR_SECURITY_PREFIX
,
331 XATTR_SECURITY_PREFIX_LEN
)) {
332 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
333 int ret
= xattr_getsecurity(inode
, suffix
, value
, size
);
335 * Only overwrite the return value if a security module
336 * is actually active.
338 if (ret
== -EOPNOTSUPP
)
343 return __vfs_getxattr(dentry
, inode
, name
, value
, size
);
345 EXPORT_SYMBOL_GPL(vfs_getxattr
);
348 vfs_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
350 struct inode
*inode
= d_inode(dentry
);
353 error
= security_inode_listxattr(dentry
);
356 if (inode
->i_op
->listxattr
&& (inode
->i_opflags
& IOP_XATTR
)) {
358 error
= inode
->i_op
->listxattr(dentry
, list
, size
);
360 error
= security_inode_listsecurity(inode
, list
, size
);
361 if (size
&& error
> size
)
366 EXPORT_SYMBOL_GPL(vfs_listxattr
);
369 __vfs_removexattr(struct dentry
*dentry
, const char *name
)
371 struct inode
*inode
= d_inode(dentry
);
372 const struct xattr_handler
*handler
;
374 handler
= xattr_resolve_name(inode
, &name
);
376 return PTR_ERR(handler
);
379 return handler
->set(handler
, dentry
, inode
, name
, NULL
, 0, XATTR_REPLACE
);
381 EXPORT_SYMBOL(__vfs_removexattr
);
384 vfs_removexattr(struct dentry
*dentry
, const char *name
)
386 struct inode
*inode
= dentry
->d_inode
;
389 error
= xattr_permission(inode
, name
, MAY_WRITE
);
394 error
= security_inode_removexattr(dentry
, name
);
398 error
= __vfs_removexattr(dentry
, name
);
401 fsnotify_xattr(dentry
);
402 evm_inode_post_removexattr(dentry
, name
);
409 EXPORT_SYMBOL_GPL(vfs_removexattr
);
413 * Extended attribute SET operations
416 setxattr(struct dentry
*d
, const char __user
*name
, const void __user
*value
,
417 size_t size
, int flags
)
421 char kname
[XATTR_NAME_MAX
+ 1];
423 if (flags
& ~(XATTR_CREATE
|XATTR_REPLACE
))
426 error
= strncpy_from_user(kname
, name
, sizeof(kname
));
427 if (error
== 0 || error
== sizeof(kname
))
433 if (size
> XATTR_SIZE_MAX
)
435 kvalue
= kmalloc(size
, GFP_KERNEL
| __GFP_NOWARN
);
437 kvalue
= vmalloc(size
);
441 if (copy_from_user(kvalue
, value
, size
)) {
445 if ((strcmp(kname
, XATTR_NAME_POSIX_ACL_ACCESS
) == 0) ||
446 (strcmp(kname
, XATTR_NAME_POSIX_ACL_DEFAULT
) == 0))
447 posix_acl_fix_xattr_from_user(kvalue
, size
);
450 error
= vfs_setxattr(d
, kname
, kvalue
, size
, flags
);
457 static int path_setxattr(const char __user
*pathname
,
458 const char __user
*name
, const void __user
*value
,
459 size_t size
, int flags
, unsigned int lookup_flags
)
464 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
467 error
= mnt_want_write(path
.mnt
);
469 error
= setxattr(path
.dentry
, name
, value
, size
, flags
);
470 mnt_drop_write(path
.mnt
);
473 if (retry_estale(error
, lookup_flags
)) {
474 lookup_flags
|= LOOKUP_REVAL
;
480 SYSCALL_DEFINE5(setxattr
, const char __user
*, pathname
,
481 const char __user
*, name
, const void __user
*, value
,
482 size_t, size
, int, flags
)
484 return path_setxattr(pathname
, name
, value
, size
, flags
, LOOKUP_FOLLOW
);
487 SYSCALL_DEFINE5(lsetxattr
, const char __user
*, pathname
,
488 const char __user
*, name
, const void __user
*, value
,
489 size_t, size
, int, flags
)
491 return path_setxattr(pathname
, name
, value
, size
, flags
, 0);
494 SYSCALL_DEFINE5(fsetxattr
, int, fd
, const char __user
*, name
,
495 const void __user
*,value
, size_t, size
, int, flags
)
497 struct fd f
= fdget(fd
);
503 error
= mnt_want_write_file(f
.file
);
505 error
= setxattr(f
.file
->f_path
.dentry
, name
, value
, size
, flags
);
506 mnt_drop_write_file(f
.file
);
513 * Extended attribute GET operations
516 getxattr(struct dentry
*d
, const char __user
*name
, void __user
*value
,
521 char kname
[XATTR_NAME_MAX
+ 1];
523 error
= strncpy_from_user(kname
, name
, sizeof(kname
));
524 if (error
== 0 || error
== sizeof(kname
))
530 if (size
> XATTR_SIZE_MAX
)
531 size
= XATTR_SIZE_MAX
;
532 kvalue
= kzalloc(size
, GFP_KERNEL
| __GFP_NOWARN
);
534 kvalue
= vmalloc(size
);
540 error
= vfs_getxattr(d
, kname
, kvalue
, size
);
542 if ((strcmp(kname
, XATTR_NAME_POSIX_ACL_ACCESS
) == 0) ||
543 (strcmp(kname
, XATTR_NAME_POSIX_ACL_DEFAULT
) == 0))
544 posix_acl_fix_xattr_to_user(kvalue
, size
);
545 if (size
&& copy_to_user(value
, kvalue
, error
))
547 } else if (error
== -ERANGE
&& size
>= XATTR_SIZE_MAX
) {
548 /* The file system tried to returned a value bigger
549 than XATTR_SIZE_MAX bytes. Not possible. */
558 static ssize_t
path_getxattr(const char __user
*pathname
,
559 const char __user
*name
, void __user
*value
,
560 size_t size
, unsigned int lookup_flags
)
565 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
568 error
= getxattr(path
.dentry
, name
, value
, size
);
570 if (retry_estale(error
, lookup_flags
)) {
571 lookup_flags
|= LOOKUP_REVAL
;
577 SYSCALL_DEFINE4(getxattr
, const char __user
*, pathname
,
578 const char __user
*, name
, void __user
*, value
, size_t, size
)
580 return path_getxattr(pathname
, name
, value
, size
, LOOKUP_FOLLOW
);
583 SYSCALL_DEFINE4(lgetxattr
, const char __user
*, pathname
,
584 const char __user
*, name
, void __user
*, value
, size_t, size
)
586 return path_getxattr(pathname
, name
, value
, size
, 0);
589 SYSCALL_DEFINE4(fgetxattr
, int, fd
, const char __user
*, name
,
590 void __user
*, value
, size_t, size
)
592 struct fd f
= fdget(fd
);
593 ssize_t error
= -EBADF
;
598 error
= getxattr(f
.file
->f_path
.dentry
, name
, value
, size
);
604 * Extended attribute LIST operations
607 listxattr(struct dentry
*d
, char __user
*list
, size_t size
)
613 if (size
> XATTR_LIST_MAX
)
614 size
= XATTR_LIST_MAX
;
615 klist
= kmalloc(size
, __GFP_NOWARN
| GFP_KERNEL
);
617 klist
= vmalloc(size
);
623 error
= vfs_listxattr(d
, klist
, size
);
625 if (size
&& copy_to_user(list
, klist
, error
))
627 } else if (error
== -ERANGE
&& size
>= XATTR_LIST_MAX
) {
628 /* The file system tried to returned a list bigger
629 than XATTR_LIST_MAX bytes. Not possible. */
638 static ssize_t
path_listxattr(const char __user
*pathname
, char __user
*list
,
639 size_t size
, unsigned int lookup_flags
)
644 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
647 error
= listxattr(path
.dentry
, list
, size
);
649 if (retry_estale(error
, lookup_flags
)) {
650 lookup_flags
|= LOOKUP_REVAL
;
656 SYSCALL_DEFINE3(listxattr
, const char __user
*, pathname
, char __user
*, list
,
659 return path_listxattr(pathname
, list
, size
, LOOKUP_FOLLOW
);
662 SYSCALL_DEFINE3(llistxattr
, const char __user
*, pathname
, char __user
*, list
,
665 return path_listxattr(pathname
, list
, size
, 0);
668 SYSCALL_DEFINE3(flistxattr
, int, fd
, char __user
*, list
, size_t, size
)
670 struct fd f
= fdget(fd
);
671 ssize_t error
= -EBADF
;
676 error
= listxattr(f
.file
->f_path
.dentry
, list
, size
);
682 * Extended attribute REMOVE operations
685 removexattr(struct dentry
*d
, const char __user
*name
)
688 char kname
[XATTR_NAME_MAX
+ 1];
690 error
= strncpy_from_user(kname
, name
, sizeof(kname
));
691 if (error
== 0 || error
== sizeof(kname
))
696 return vfs_removexattr(d
, kname
);
699 static int path_removexattr(const char __user
*pathname
,
700 const char __user
*name
, unsigned int lookup_flags
)
705 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
708 error
= mnt_want_write(path
.mnt
);
710 error
= removexattr(path
.dentry
, name
);
711 mnt_drop_write(path
.mnt
);
714 if (retry_estale(error
, lookup_flags
)) {
715 lookup_flags
|= LOOKUP_REVAL
;
721 SYSCALL_DEFINE2(removexattr
, const char __user
*, pathname
,
722 const char __user
*, name
)
724 return path_removexattr(pathname
, name
, LOOKUP_FOLLOW
);
727 SYSCALL_DEFINE2(lremovexattr
, const char __user
*, pathname
,
728 const char __user
*, name
)
730 return path_removexattr(pathname
, name
, 0);
733 SYSCALL_DEFINE2(fremovexattr
, int, fd
, const char __user
*, name
)
735 struct fd f
= fdget(fd
);
741 error
= mnt_want_write_file(f
.file
);
743 error
= removexattr(f
.file
->f_path
.dentry
, name
);
744 mnt_drop_write_file(f
.file
);
751 * Combine the results of the list() operation from every xattr_handler in the
755 generic_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
757 const struct xattr_handler
*handler
, **handlers
= dentry
->d_sb
->s_xattr
;
758 unsigned int size
= 0;
761 for_each_xattr_handler(handlers
, handler
) {
762 if (!handler
->name
||
763 (handler
->list
&& !handler
->list(dentry
)))
765 size
+= strlen(handler
->name
) + 1;
771 for_each_xattr_handler(handlers
, handler
) {
772 if (!handler
->name
||
773 (handler
->list
&& !handler
->list(dentry
)))
775 len
= strlen(handler
->name
);
776 if (len
+ 1 > buffer_size
)
778 memcpy(buf
, handler
->name
, len
+ 1);
780 buffer_size
-= len
+ 1;
786 EXPORT_SYMBOL(generic_listxattr
);
789 * xattr_full_name - Compute full attribute name from suffix
791 * @handler: handler of the xattr_handler operation
792 * @name: name passed to the xattr_handler operation
794 * The get and set xattr handler operations are called with the remainder of
795 * the attribute name after skipping the handler's prefix: for example, "foo"
796 * is passed to the get operation of a handler with prefix "user." to get
797 * attribute "user.foo". The full name is still "there" in the name though.
799 * Note: the list xattr handler operation when called from the vfs is passed a
800 * NULL name; some file systems use this operation internally, with varying
803 const char *xattr_full_name(const struct xattr_handler
*handler
,
806 size_t prefix_len
= strlen(xattr_prefix(handler
));
808 return name
- prefix_len
;
810 EXPORT_SYMBOL(xattr_full_name
);
813 * Allocate new xattr and copy in the value; but leave the name to callers.
815 struct simple_xattr
*simple_xattr_alloc(const void *value
, size_t size
)
817 struct simple_xattr
*new_xattr
;
821 len
= sizeof(*new_xattr
) + size
;
822 if (len
< sizeof(*new_xattr
))
825 new_xattr
= kmalloc(len
, GFP_KERNEL
);
829 new_xattr
->size
= size
;
830 memcpy(new_xattr
->value
, value
, size
);
835 * xattr GET operation for in-memory/pseudo filesystems
837 int simple_xattr_get(struct simple_xattrs
*xattrs
, const char *name
,
838 void *buffer
, size_t size
)
840 struct simple_xattr
*xattr
;
843 spin_lock(&xattrs
->lock
);
844 list_for_each_entry(xattr
, &xattrs
->head
, list
) {
845 if (strcmp(name
, xattr
->name
))
850 if (size
< xattr
->size
)
853 memcpy(buffer
, xattr
->value
, xattr
->size
);
857 spin_unlock(&xattrs
->lock
);
862 * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
863 * @xattrs: target simple_xattr list
864 * @name: name of the extended attribute
865 * @value: value of the xattr. If %NULL, will remove the attribute.
866 * @size: size of the new xattr
867 * @flags: %XATTR_{CREATE|REPLACE}
869 * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
870 * with -EEXIST. If %XATTR_REPLACE is set, the xattr should exist;
871 * otherwise, fails with -ENODATA.
873 * Returns 0 on success, -errno on failure.
875 int simple_xattr_set(struct simple_xattrs
*xattrs
, const char *name
,
876 const void *value
, size_t size
, int flags
)
878 struct simple_xattr
*xattr
;
879 struct simple_xattr
*new_xattr
= NULL
;
882 /* value == NULL means remove */
884 new_xattr
= simple_xattr_alloc(value
, size
);
888 new_xattr
->name
= kstrdup(name
, GFP_KERNEL
);
889 if (!new_xattr
->name
) {
895 spin_lock(&xattrs
->lock
);
896 list_for_each_entry(xattr
, &xattrs
->head
, list
) {
897 if (!strcmp(name
, xattr
->name
)) {
898 if (flags
& XATTR_CREATE
) {
901 } else if (new_xattr
) {
902 list_replace(&xattr
->list
, &new_xattr
->list
);
904 list_del(&xattr
->list
);
909 if (flags
& XATTR_REPLACE
) {
913 list_add(&new_xattr
->list
, &xattrs
->head
);
917 spin_unlock(&xattrs
->lock
);
926 static bool xattr_is_trusted(const char *name
)
928 return !strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
);
931 static int xattr_list_one(char **buffer
, ssize_t
*remaining_size
,
934 size_t len
= strlen(name
) + 1;
936 if (*remaining_size
< len
)
938 memcpy(*buffer
, name
, len
);
941 *remaining_size
-= len
;
946 * xattr LIST operation for in-memory/pseudo filesystems
948 ssize_t
simple_xattr_list(struct inode
*inode
, struct simple_xattrs
*xattrs
,
949 char *buffer
, size_t size
)
951 bool trusted
= capable(CAP_SYS_ADMIN
);
952 struct simple_xattr
*xattr
;
953 ssize_t remaining_size
= size
;
956 #ifdef CONFIG_FS_POSIX_ACL
958 err
= xattr_list_one(&buffer
, &remaining_size
,
959 XATTR_NAME_POSIX_ACL_ACCESS
);
963 if (inode
->i_default_acl
) {
964 err
= xattr_list_one(&buffer
, &remaining_size
,
965 XATTR_NAME_POSIX_ACL_DEFAULT
);
971 spin_lock(&xattrs
->lock
);
972 list_for_each_entry(xattr
, &xattrs
->head
, list
) {
973 /* skip "trusted." attributes for unprivileged callers */
974 if (!trusted
&& xattr_is_trusted(xattr
->name
))
977 err
= xattr_list_one(&buffer
, &remaining_size
, xattr
->name
);
981 spin_unlock(&xattrs
->lock
);
983 return err
? err
: size
- remaining_size
;
987 * Adds an extended attribute to the list
989 void simple_xattr_list_add(struct simple_xattrs
*xattrs
,
990 struct simple_xattr
*new_xattr
)
992 spin_lock(&xattrs
->lock
);
993 list_add(&new_xattr
->list
, &xattrs
->head
);
994 spin_unlock(&xattrs
->lock
);