1 // SPDX-License-Identifier: GPL-2.0-only
5 Extended attribute handling.
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>
12 #include <linux/slab.h>
13 #include <linux/file.h>
14 #include <linux/xattr.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/security.h>
18 #include <linux/evm.h>
19 #include <linux/syscalls.h>
20 #include <linux/export.h>
21 #include <linux/fsnotify.h>
22 #include <linux/audit.h>
23 #include <linux/vmalloc.h>
24 #include <linux/posix_acl_xattr.h>
26 #include <linux/uaccess.h>
31 strcmp_prefix(const char *a
, const char *a_prefix
)
33 while (*a_prefix
&& *a
== *a_prefix
) {
37 return *a_prefix
? NULL
: a
;
41 * In order to implement different sets of xattr operations for each xattr
42 * prefix, a filesystem should create a null-terminated array of struct
43 * xattr_handler (one for each prefix) and hang a pointer to it off of the
44 * s_xattr field of the superblock.
46 #define for_each_xattr_handler(handlers, handler) \
48 for ((handler) = *(handlers)++; \
50 (handler) = *(handlers)++)
53 * Find the xattr_handler with the matching prefix.
55 static const struct xattr_handler
*
56 xattr_resolve_name(struct inode
*inode
, const char **name
)
58 const struct xattr_handler
**handlers
= inode
->i_sb
->s_xattr
;
59 const struct xattr_handler
*handler
;
61 if (!(inode
->i_opflags
& IOP_XATTR
)) {
62 if (unlikely(is_bad_inode(inode
)))
64 return ERR_PTR(-EOPNOTSUPP
);
66 for_each_xattr_handler(handlers
, handler
) {
69 n
= strcmp_prefix(*name
, xattr_prefix(handler
));
71 if (!handler
->prefix
^ !*n
) {
74 return ERR_PTR(-EINVAL
);
80 return ERR_PTR(-EOPNOTSUPP
);
84 * may_write_xattr - check whether inode allows writing xattr
85 * @mnt_userns: User namespace of the mount the inode was found from
86 * @inode: the inode on which to set an xattr
88 * Check whether the inode allows writing xattrs. Specifically, we can never
89 * set or remove an extended attribute on a read-only filesystem or on an
90 * immutable / append-only inode.
92 * We also need to ensure that the inode has a mapping in the mount to
93 * not risk writing back invalid i_{g,u}id values.
95 * Return: On success zero is returned. On error a negative errno is returned.
97 int may_write_xattr(struct user_namespace
*mnt_userns
, struct inode
*inode
)
99 if (IS_IMMUTABLE(inode
))
101 if (IS_APPEND(inode
))
103 if (HAS_UNMAPPED_ID(mnt_userns
, inode
))
109 * Check permissions for extended attribute access. This is a bit complicated
110 * because different namespaces have very different rules.
113 xattr_permission(struct user_namespace
*mnt_userns
, struct inode
*inode
,
114 const char *name
, int mask
)
116 if (mask
& MAY_WRITE
) {
119 ret
= may_write_xattr(mnt_userns
, inode
);
125 * No restriction for security.* and system.* from the VFS. Decision
126 * on these is left to the underlying filesystem / security module.
128 if (!strncmp(name
, XATTR_SECURITY_PREFIX
, XATTR_SECURITY_PREFIX_LEN
) ||
129 !strncmp(name
, XATTR_SYSTEM_PREFIX
, XATTR_SYSTEM_PREFIX_LEN
))
133 * The trusted.* namespace can only be accessed by privileged users.
135 if (!strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
)) {
136 if (!capable(CAP_SYS_ADMIN
))
137 return (mask
& MAY_WRITE
) ? -EPERM
: -ENODATA
;
142 * In the user.* namespace, only regular files and directories can have
143 * extended attributes. For sticky directories, only the owner and
144 * privileged users can write attributes.
146 if (!strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
)) {
147 if (!S_ISREG(inode
->i_mode
) && !S_ISDIR(inode
->i_mode
))
148 return (mask
& MAY_WRITE
) ? -EPERM
: -ENODATA
;
149 if (S_ISDIR(inode
->i_mode
) && (inode
->i_mode
& S_ISVTX
) &&
150 (mask
& MAY_WRITE
) &&
151 !inode_owner_or_capable(mnt_userns
, inode
))
155 return inode_permission(mnt_userns
, inode
, mask
);
159 * Look for any handler that deals with the specified namespace.
162 xattr_supported_namespace(struct inode
*inode
, const char *prefix
)
164 const struct xattr_handler
**handlers
= inode
->i_sb
->s_xattr
;
165 const struct xattr_handler
*handler
;
168 if (!(inode
->i_opflags
& IOP_XATTR
)) {
169 if (unlikely(is_bad_inode(inode
)))
174 preflen
= strlen(prefix
);
176 for_each_xattr_handler(handlers
, handler
) {
177 if (!strncmp(xattr_prefix(handler
), prefix
, preflen
))
183 EXPORT_SYMBOL(xattr_supported_namespace
);
186 __vfs_setxattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
187 struct inode
*inode
, const char *name
, const void *value
,
188 size_t size
, int flags
)
190 const struct xattr_handler
*handler
;
192 if (is_posix_acl_xattr(name
))
195 handler
= xattr_resolve_name(inode
, &name
);
197 return PTR_ERR(handler
);
201 value
= ""; /* empty EA, do not remove */
202 return handler
->set(handler
, mnt_userns
, dentry
, inode
, name
, value
,
205 EXPORT_SYMBOL(__vfs_setxattr
);
208 * __vfs_setxattr_noperm - perform setxattr operation without performing
211 * @mnt_userns: user namespace of the mount the inode was found from
212 * @dentry: object to perform setxattr on
213 * @name: xattr name to set
214 * @value: value to set @name to
215 * @size: size of @value
216 * @flags: flags to pass into filesystem operations
218 * returns the result of the internal setxattr or setsecurity operations.
220 * This function requires the caller to lock the inode's i_mutex before it
221 * is executed. It also assumes that the caller will make the appropriate
224 int __vfs_setxattr_noperm(struct user_namespace
*mnt_userns
,
225 struct dentry
*dentry
, const char *name
,
226 const void *value
, size_t size
, int flags
)
228 struct inode
*inode
= dentry
->d_inode
;
230 int issec
= !strncmp(name
, XATTR_SECURITY_PREFIX
,
231 XATTR_SECURITY_PREFIX_LEN
);
234 inode
->i_flags
&= ~S_NOSEC
;
235 if (inode
->i_opflags
& IOP_XATTR
) {
236 error
= __vfs_setxattr(mnt_userns
, dentry
, inode
, name
, value
,
239 fsnotify_xattr(dentry
);
240 security_inode_post_setxattr(dentry
, name
, value
,
244 if (unlikely(is_bad_inode(inode
)))
247 if (error
== -EAGAIN
) {
251 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
253 error
= security_inode_setsecurity(inode
, suffix
, value
,
256 fsnotify_xattr(dentry
);
264 * __vfs_setxattr_locked - set an extended attribute while holding the inode
267 * @mnt_userns: user namespace of the mount of the target inode
268 * @dentry: object to perform setxattr on
269 * @name: xattr name to set
270 * @value: value to set @name to
271 * @size: size of @value
272 * @flags: flags to pass into filesystem operations
273 * @delegated_inode: on return, will contain an inode pointer that
274 * a delegation was broken on, NULL if none.
277 __vfs_setxattr_locked(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
278 const char *name
, const void *value
, size_t size
,
279 int flags
, struct inode
**delegated_inode
)
281 struct inode
*inode
= dentry
->d_inode
;
284 error
= xattr_permission(mnt_userns
, inode
, name
, MAY_WRITE
);
288 error
= security_inode_setxattr(mnt_userns
, dentry
, name
, value
, size
,
293 error
= try_break_deleg(inode
, delegated_inode
);
297 error
= __vfs_setxattr_noperm(mnt_userns
, dentry
, name
, value
,
303 EXPORT_SYMBOL_GPL(__vfs_setxattr_locked
);
306 vfs_setxattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
307 const char *name
, const void *value
, size_t size
, int flags
)
309 struct inode
*inode
= dentry
->d_inode
;
310 struct inode
*delegated_inode
= NULL
;
311 const void *orig_value
= value
;
314 if (size
&& strcmp(name
, XATTR_NAME_CAPS
) == 0) {
315 error
= cap_convert_nscap(mnt_userns
, dentry
, &value
, size
);
323 error
= __vfs_setxattr_locked(mnt_userns
, dentry
, name
, value
, size
,
324 flags
, &delegated_inode
);
327 if (delegated_inode
) {
328 error
= break_deleg_wait(&delegated_inode
);
332 if (value
!= orig_value
)
337 EXPORT_SYMBOL_GPL(vfs_setxattr
);
340 xattr_getsecurity(struct user_namespace
*mnt_userns
, struct inode
*inode
,
341 const char *name
, void *value
, size_t size
)
346 if (!value
|| !size
) {
347 len
= security_inode_getsecurity(mnt_userns
, inode
, name
,
352 len
= security_inode_getsecurity(mnt_userns
, inode
, name
, &buffer
,
360 memcpy(value
, buffer
, len
);
368 * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
370 * Allocate memory, if not already allocated, or re-allocate correct size,
371 * before retrieving the extended attribute. The xattr value buffer should
372 * always be freed by the caller, even on error.
374 * Returns the result of alloc, if failed, or the getxattr operation.
377 vfs_getxattr_alloc(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
378 const char *name
, char **xattr_value
, size_t xattr_size
,
381 const struct xattr_handler
*handler
;
382 struct inode
*inode
= dentry
->d_inode
;
383 char *value
= *xattr_value
;
386 error
= xattr_permission(mnt_userns
, inode
, name
, MAY_READ
);
390 handler
= xattr_resolve_name(inode
, &name
);
392 return PTR_ERR(handler
);
395 error
= handler
->get(handler
, dentry
, inode
, name
, NULL
, 0);
399 if (!value
|| (error
> xattr_size
)) {
400 value
= krealloc(*xattr_value
, error
+ 1, flags
);
403 memset(value
, 0, error
+ 1);
406 error
= handler
->get(handler
, dentry
, inode
, name
, value
, error
);
407 *xattr_value
= value
;
412 __vfs_getxattr(struct dentry
*dentry
, struct inode
*inode
, const char *name
,
413 void *value
, size_t size
)
415 const struct xattr_handler
*handler
;
417 if (is_posix_acl_xattr(name
))
420 handler
= xattr_resolve_name(inode
, &name
);
422 return PTR_ERR(handler
);
425 return handler
->get(handler
, dentry
, inode
, name
, value
, size
);
427 EXPORT_SYMBOL(__vfs_getxattr
);
430 vfs_getxattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
431 const char *name
, void *value
, size_t size
)
433 struct inode
*inode
= dentry
->d_inode
;
436 error
= xattr_permission(mnt_userns
, inode
, name
, MAY_READ
);
440 error
= security_inode_getxattr(dentry
, name
);
444 if (!strncmp(name
, XATTR_SECURITY_PREFIX
,
445 XATTR_SECURITY_PREFIX_LEN
)) {
446 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
447 int ret
= xattr_getsecurity(mnt_userns
, inode
, suffix
, value
,
450 * Only overwrite the return value if a security module
451 * is actually active.
453 if (ret
== -EOPNOTSUPP
)
458 return __vfs_getxattr(dentry
, inode
, name
, value
, size
);
460 EXPORT_SYMBOL_GPL(vfs_getxattr
);
463 vfs_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
465 struct inode
*inode
= d_inode(dentry
);
468 error
= security_inode_listxattr(dentry
);
471 if (inode
->i_op
->listxattr
&& (inode
->i_opflags
& IOP_XATTR
)) {
472 error
= inode
->i_op
->listxattr(dentry
, list
, size
);
474 error
= security_inode_listsecurity(inode
, list
, size
);
475 if (size
&& error
> size
)
480 EXPORT_SYMBOL_GPL(vfs_listxattr
);
483 __vfs_removexattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
486 struct inode
*inode
= d_inode(dentry
);
487 const struct xattr_handler
*handler
;
489 if (is_posix_acl_xattr(name
))
492 handler
= xattr_resolve_name(inode
, &name
);
494 return PTR_ERR(handler
);
497 return handler
->set(handler
, mnt_userns
, dentry
, inode
, name
, NULL
, 0,
500 EXPORT_SYMBOL(__vfs_removexattr
);
503 * __vfs_removexattr_locked - set an extended attribute while holding the inode
506 * @mnt_userns: user namespace of the mount of the target inode
507 * @dentry: object to perform setxattr on
508 * @name: name of xattr to remove
509 * @delegated_inode: on return, will contain an inode pointer that
510 * a delegation was broken on, NULL if none.
513 __vfs_removexattr_locked(struct user_namespace
*mnt_userns
,
514 struct dentry
*dentry
, const char *name
,
515 struct inode
**delegated_inode
)
517 struct inode
*inode
= dentry
->d_inode
;
520 error
= xattr_permission(mnt_userns
, inode
, name
, MAY_WRITE
);
524 error
= security_inode_removexattr(mnt_userns
, dentry
, name
);
528 error
= try_break_deleg(inode
, delegated_inode
);
532 error
= __vfs_removexattr(mnt_userns
, dentry
, name
);
535 fsnotify_xattr(dentry
);
536 evm_inode_post_removexattr(dentry
, name
);
542 EXPORT_SYMBOL_GPL(__vfs_removexattr_locked
);
545 vfs_removexattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
548 struct inode
*inode
= dentry
->d_inode
;
549 struct inode
*delegated_inode
= NULL
;
554 error
= __vfs_removexattr_locked(mnt_userns
, dentry
,
555 name
, &delegated_inode
);
558 if (delegated_inode
) {
559 error
= break_deleg_wait(&delegated_inode
);
566 EXPORT_SYMBOL_GPL(vfs_removexattr
);
569 * Extended attribute SET operations
572 int setxattr_copy(const char __user
*name
, struct xattr_ctx
*ctx
)
576 if (ctx
->flags
& ~(XATTR_CREATE
|XATTR_REPLACE
))
579 error
= strncpy_from_user(ctx
->kname
->name
, name
,
580 sizeof(ctx
->kname
->name
));
581 if (error
== 0 || error
== sizeof(ctx
->kname
->name
))
588 if (ctx
->size
> XATTR_SIZE_MAX
)
591 ctx
->kvalue
= vmemdup_user(ctx
->cvalue
, ctx
->size
);
592 if (IS_ERR(ctx
->kvalue
)) {
593 error
= PTR_ERR(ctx
->kvalue
);
601 int do_setxattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
602 struct xattr_ctx
*ctx
)
604 if (is_posix_acl_xattr(ctx
->kname
->name
))
605 return do_set_acl(idmap
, dentry
, ctx
->kname
->name
,
606 ctx
->kvalue
, ctx
->size
);
608 return vfs_setxattr(mnt_idmap_owner(idmap
), dentry
, ctx
->kname
->name
,
609 ctx
->kvalue
, ctx
->size
, ctx
->flags
);
613 setxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
614 const char __user
*name
, const void __user
*value
, size_t size
,
617 struct xattr_name kname
;
618 struct xattr_ctx ctx
= {
627 error
= setxattr_copy(name
, &ctx
);
631 error
= do_setxattr(idmap
, d
, &ctx
);
637 static int path_setxattr(const char __user
*pathname
,
638 const char __user
*name
, const void __user
*value
,
639 size_t size
, int flags
, unsigned int lookup_flags
)
645 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
648 error
= mnt_want_write(path
.mnt
);
650 error
= setxattr(mnt_idmap(path
.mnt
), path
.dentry
, name
,
652 mnt_drop_write(path
.mnt
);
655 if (retry_estale(error
, lookup_flags
)) {
656 lookup_flags
|= LOOKUP_REVAL
;
662 SYSCALL_DEFINE5(setxattr
, const char __user
*, pathname
,
663 const char __user
*, name
, const void __user
*, value
,
664 size_t, size
, int, flags
)
666 return path_setxattr(pathname
, name
, value
, size
, flags
, LOOKUP_FOLLOW
);
669 SYSCALL_DEFINE5(lsetxattr
, const char __user
*, pathname
,
670 const char __user
*, name
, const void __user
*, value
,
671 size_t, size
, int, flags
)
673 return path_setxattr(pathname
, name
, value
, size
, flags
, 0);
676 SYSCALL_DEFINE5(fsetxattr
, int, fd
, const char __user
*, name
,
677 const void __user
*,value
, size_t, size
, int, flags
)
679 struct fd f
= fdget(fd
);
685 error
= mnt_want_write_file(f
.file
);
687 error
= setxattr(file_mnt_idmap(f
.file
),
688 f
.file
->f_path
.dentry
, name
,
690 mnt_drop_write_file(f
.file
);
697 * Extended attribute GET operations
700 do_getxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
701 struct xattr_ctx
*ctx
)
704 char *kname
= ctx
->kname
->name
;
707 if (ctx
->size
> XATTR_SIZE_MAX
)
708 ctx
->size
= XATTR_SIZE_MAX
;
709 ctx
->kvalue
= kvzalloc(ctx
->size
, GFP_KERNEL
);
714 if (is_posix_acl_xattr(ctx
->kname
->name
))
715 error
= do_get_acl(idmap
, d
, kname
, ctx
->kvalue
, ctx
->size
);
717 error
= vfs_getxattr(mnt_idmap_owner(idmap
), d
, kname
,
718 ctx
->kvalue
, ctx
->size
);
720 if (ctx
->size
&& copy_to_user(ctx
->value
, ctx
->kvalue
, error
))
722 } else if (error
== -ERANGE
&& ctx
->size
>= XATTR_SIZE_MAX
) {
723 /* The file system tried to returned a value bigger
724 than XATTR_SIZE_MAX bytes. Not possible. */
732 getxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
733 const char __user
*name
, void __user
*value
, size_t size
)
736 struct xattr_name kname
;
737 struct xattr_ctx ctx
= {
745 error
= strncpy_from_user(kname
.name
, name
, sizeof(kname
.name
));
746 if (error
== 0 || error
== sizeof(kname
.name
))
751 error
= do_getxattr(idmap
, d
, &ctx
);
757 static ssize_t
path_getxattr(const char __user
*pathname
,
758 const char __user
*name
, void __user
*value
,
759 size_t size
, unsigned int lookup_flags
)
764 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
767 error
= getxattr(mnt_idmap(path
.mnt
), path
.dentry
, name
, value
, size
);
769 if (retry_estale(error
, lookup_flags
)) {
770 lookup_flags
|= LOOKUP_REVAL
;
776 SYSCALL_DEFINE4(getxattr
, const char __user
*, pathname
,
777 const char __user
*, name
, void __user
*, value
, size_t, size
)
779 return path_getxattr(pathname
, name
, value
, size
, LOOKUP_FOLLOW
);
782 SYSCALL_DEFINE4(lgetxattr
, const char __user
*, pathname
,
783 const char __user
*, name
, void __user
*, value
, size_t, size
)
785 return path_getxattr(pathname
, name
, value
, size
, 0);
788 SYSCALL_DEFINE4(fgetxattr
, int, fd
, const char __user
*, name
,
789 void __user
*, value
, size_t, size
)
791 struct fd f
= fdget(fd
);
792 ssize_t error
= -EBADF
;
797 error
= getxattr(file_mnt_idmap(f
.file
), f
.file
->f_path
.dentry
,
804 * Extended attribute LIST operations
807 listxattr(struct dentry
*d
, char __user
*list
, size_t size
)
813 if (size
> XATTR_LIST_MAX
)
814 size
= XATTR_LIST_MAX
;
815 klist
= kvmalloc(size
, GFP_KERNEL
);
820 error
= vfs_listxattr(d
, klist
, size
);
822 if (size
&& copy_to_user(list
, klist
, error
))
824 } else if (error
== -ERANGE
&& size
>= XATTR_LIST_MAX
) {
825 /* The file system tried to returned a list bigger
826 than XATTR_LIST_MAX bytes. Not possible. */
835 static ssize_t
path_listxattr(const char __user
*pathname
, char __user
*list
,
836 size_t size
, unsigned int lookup_flags
)
841 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
844 error
= listxattr(path
.dentry
, list
, size
);
846 if (retry_estale(error
, lookup_flags
)) {
847 lookup_flags
|= LOOKUP_REVAL
;
853 SYSCALL_DEFINE3(listxattr
, const char __user
*, pathname
, char __user
*, list
,
856 return path_listxattr(pathname
, list
, size
, LOOKUP_FOLLOW
);
859 SYSCALL_DEFINE3(llistxattr
, const char __user
*, pathname
, char __user
*, list
,
862 return path_listxattr(pathname
, list
, size
, 0);
865 SYSCALL_DEFINE3(flistxattr
, int, fd
, char __user
*, list
, size_t, size
)
867 struct fd f
= fdget(fd
);
868 ssize_t error
= -EBADF
;
873 error
= listxattr(f
.file
->f_path
.dentry
, list
, size
);
879 * Extended attribute REMOVE operations
882 removexattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
883 const char __user
*name
)
886 char kname
[XATTR_NAME_MAX
+ 1];
888 error
= strncpy_from_user(kname
, name
, sizeof(kname
));
889 if (error
== 0 || error
== sizeof(kname
))
894 if (is_posix_acl_xattr(kname
))
895 return vfs_remove_acl(mnt_idmap_owner(idmap
), d
, kname
);
897 return vfs_removexattr(mnt_idmap_owner(idmap
), d
, kname
);
900 static int path_removexattr(const char __user
*pathname
,
901 const char __user
*name
, unsigned int lookup_flags
)
906 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
909 error
= mnt_want_write(path
.mnt
);
911 error
= removexattr(mnt_idmap(path
.mnt
), path
.dentry
, name
);
912 mnt_drop_write(path
.mnt
);
915 if (retry_estale(error
, lookup_flags
)) {
916 lookup_flags
|= LOOKUP_REVAL
;
922 SYSCALL_DEFINE2(removexattr
, const char __user
*, pathname
,
923 const char __user
*, name
)
925 return path_removexattr(pathname
, name
, LOOKUP_FOLLOW
);
928 SYSCALL_DEFINE2(lremovexattr
, const char __user
*, pathname
,
929 const char __user
*, name
)
931 return path_removexattr(pathname
, name
, 0);
934 SYSCALL_DEFINE2(fremovexattr
, int, fd
, const char __user
*, name
)
936 struct fd f
= fdget(fd
);
942 error
= mnt_want_write_file(f
.file
);
944 error
= removexattr(file_mnt_idmap(f
.file
),
945 f
.file
->f_path
.dentry
, name
);
946 mnt_drop_write_file(f
.file
);
953 * Combine the results of the list() operation from every xattr_handler in the
957 generic_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
959 const struct xattr_handler
*handler
, **handlers
= dentry
->d_sb
->s_xattr
;
960 unsigned int size
= 0;
963 for_each_xattr_handler(handlers
, handler
) {
964 if (!handler
->name
||
965 (handler
->list
&& !handler
->list(dentry
)))
967 size
+= strlen(handler
->name
) + 1;
973 for_each_xattr_handler(handlers
, handler
) {
974 if (!handler
->name
||
975 (handler
->list
&& !handler
->list(dentry
)))
977 len
= strlen(handler
->name
);
978 if (len
+ 1 > buffer_size
)
980 memcpy(buf
, handler
->name
, len
+ 1);
982 buffer_size
-= len
+ 1;
988 EXPORT_SYMBOL(generic_listxattr
);
991 * xattr_full_name - Compute full attribute name from suffix
993 * @handler: handler of the xattr_handler operation
994 * @name: name passed to the xattr_handler operation
996 * The get and set xattr handler operations are called with the remainder of
997 * the attribute name after skipping the handler's prefix: for example, "foo"
998 * is passed to the get operation of a handler with prefix "user." to get
999 * attribute "user.foo". The full name is still "there" in the name though.
1001 * Note: the list xattr handler operation when called from the vfs is passed a
1002 * NULL name; some file systems use this operation internally, with varying
1005 const char *xattr_full_name(const struct xattr_handler
*handler
,
1008 size_t prefix_len
= strlen(xattr_prefix(handler
));
1010 return name
- prefix_len
;
1012 EXPORT_SYMBOL(xattr_full_name
);
1015 * free_simple_xattr - free an xattr object
1016 * @xattr: the xattr object
1018 * Free the xattr object. Can handle @xattr being NULL.
1020 static inline void free_simple_xattr(struct simple_xattr
*xattr
)
1028 * simple_xattr_alloc - allocate new xattr object
1029 * @value: value of the xattr object
1030 * @size: size of @value
1032 * Allocate a new xattr object and initialize respective members. The caller is
1033 * responsible for handling the name of the xattr.
1035 * Return: On success a new xattr object is returned. On failure NULL is
1038 struct simple_xattr
*simple_xattr_alloc(const void *value
, size_t size
)
1040 struct simple_xattr
*new_xattr
;
1044 len
= sizeof(*new_xattr
) + size
;
1045 if (len
< sizeof(*new_xattr
))
1048 new_xattr
= kvmalloc(len
, GFP_KERNEL
);
1052 new_xattr
->size
= size
;
1053 memcpy(new_xattr
->value
, value
, size
);
1058 * rbtree_simple_xattr_cmp - compare xattr name with current rbtree xattr entry
1060 * @node: current node
1062 * Compare the xattr name with the xattr name attached to @node in the rbtree.
1064 * Return: Negative value if continuing left, positive if continuing right, 0
1065 * if the xattr attached to @node matches @key.
1067 static int rbtree_simple_xattr_cmp(const void *key
, const struct rb_node
*node
)
1069 const char *xattr_name
= key
;
1070 const struct simple_xattr
*xattr
;
1072 xattr
= rb_entry(node
, struct simple_xattr
, rb_node
);
1073 return strcmp(xattr
->name
, xattr_name
);
1077 * rbtree_simple_xattr_node_cmp - compare two xattr rbtree nodes
1078 * @new_node: new node
1079 * @node: current node
1081 * Compare the xattr attached to @new_node with the xattr attached to @node.
1083 * Return: Negative value if continuing left, positive if continuing right, 0
1084 * if the xattr attached to @new_node matches the xattr attached to @node.
1086 static int rbtree_simple_xattr_node_cmp(struct rb_node
*new_node
,
1087 const struct rb_node
*node
)
1089 struct simple_xattr
*xattr
;
1090 xattr
= rb_entry(new_node
, struct simple_xattr
, rb_node
);
1091 return rbtree_simple_xattr_cmp(xattr
->name
, node
);
1095 * simple_xattr_get - get an xattr object
1096 * @xattrs: the header of the xattr object
1097 * @name: the name of the xattr to retrieve
1098 * @buffer: the buffer to store the value into
1099 * @size: the size of @buffer
1101 * Try to find and retrieve the xattr object associated with @name.
1102 * If @buffer is provided store the value of @xattr in @buffer
1103 * otherwise just return the length. The size of @buffer is limited
1104 * to XATTR_SIZE_MAX which currently is 65536.
1106 * Return: On success the length of the xattr value is returned. On error a
1107 * negative error code is returned.
1109 int simple_xattr_get(struct simple_xattrs
*xattrs
, const char *name
,
1110 void *buffer
, size_t size
)
1112 struct simple_xattr
*xattr
= NULL
;
1113 struct rb_node
*rbp
;
1116 read_lock(&xattrs
->lock
);
1117 rbp
= rb_find(name
, &xattrs
->rb_root
, rbtree_simple_xattr_cmp
);
1119 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1122 if (size
< xattr
->size
)
1125 memcpy(buffer
, xattr
->value
, xattr
->size
);
1128 read_unlock(&xattrs
->lock
);
1133 * simple_xattr_set - set an xattr object
1134 * @xattrs: the header of the xattr object
1135 * @name: the name of the xattr to retrieve
1136 * @value: the value to store along the xattr
1137 * @size: the size of @value
1138 * @flags: the flags determining how to set the xattr
1139 * @removed_size: the size of the removed xattr
1141 * Set a new xattr object.
1142 * If @value is passed a new xattr object will be allocated. If XATTR_REPLACE
1143 * is specified in @flags a matching xattr object for @name must already exist.
1144 * If it does it will be replaced with the new xattr object. If it doesn't we
1145 * fail. If XATTR_CREATE is specified and a matching xattr does already exist
1146 * we fail. If it doesn't we create a new xattr. If @flags is zero we simply
1147 * insert the new xattr replacing any existing one.
1149 * If @value is empty and a matching xattr object is found we delete it if
1150 * XATTR_REPLACE is specified in @flags or @flags is zero.
1152 * If @value is empty and no matching xattr object for @name is found we do
1153 * nothing if XATTR_CREATE is specified in @flags or @flags is zero. For
1154 * XATTR_REPLACE we fail as mentioned above.
1156 * Return: On success zero and on error a negative error code is returned.
1158 int simple_xattr_set(struct simple_xattrs
*xattrs
, const char *name
,
1159 const void *value
, size_t size
, int flags
,
1160 ssize_t
*removed_size
)
1162 struct simple_xattr
*xattr
= NULL
, *new_xattr
= NULL
;
1163 struct rb_node
*parent
= NULL
, **rbp
;
1169 /* value == NULL means remove */
1171 new_xattr
= simple_xattr_alloc(value
, size
);
1175 new_xattr
->name
= kstrdup(name
, GFP_KERNEL
);
1176 if (!new_xattr
->name
) {
1177 free_simple_xattr(new_xattr
);
1182 write_lock(&xattrs
->lock
);
1183 rbp
= &xattrs
->rb_root
.rb_node
;
1186 ret
= rbtree_simple_xattr_cmp(name
, *rbp
);
1188 rbp
= &(*rbp
)->rb_left
;
1190 rbp
= &(*rbp
)->rb_right
;
1192 xattr
= rb_entry(*rbp
, struct simple_xattr
, rb_node
);
1198 /* Fail if XATTR_CREATE is requested and the xattr exists. */
1199 if (flags
& XATTR_CREATE
) {
1205 rb_replace_node(&xattr
->rb_node
, &new_xattr
->rb_node
,
1208 rb_erase(&xattr
->rb_node
, &xattrs
->rb_root
);
1209 if (!err
&& removed_size
)
1210 *removed_size
= xattr
->size
;
1212 /* Fail if XATTR_REPLACE is requested but no xattr is found. */
1213 if (flags
& XATTR_REPLACE
) {
1219 * If XATTR_CREATE or no flags are specified together with a
1220 * new value simply insert it.
1223 rb_link_node(&new_xattr
->rb_node
, parent
, rbp
);
1224 rb_insert_color(&new_xattr
->rb_node
, &xattrs
->rb_root
);
1228 * If XATTR_CREATE or no flags are specified and neither an
1229 * old or new xattr exist then we don't need to do anything.
1234 write_unlock(&xattrs
->lock
);
1236 free_simple_xattr(new_xattr
);
1238 free_simple_xattr(xattr
);
1243 static bool xattr_is_trusted(const char *name
)
1245 return !strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
);
1248 static int xattr_list_one(char **buffer
, ssize_t
*remaining_size
,
1251 size_t len
= strlen(name
) + 1;
1253 if (*remaining_size
< len
)
1255 memcpy(*buffer
, name
, len
);
1258 *remaining_size
-= len
;
1263 * simple_xattr_list - list all xattr objects
1264 * @inode: inode from which to get the xattrs
1265 * @xattrs: the header of the xattr object
1266 * @buffer: the buffer to store all xattrs into
1267 * @size: the size of @buffer
1269 * List all xattrs associated with @inode. If @buffer is NULL we returned
1270 * the required size of the buffer. If @buffer is provided we store the
1271 * xattrs value into it provided it is big enough.
1273 * Note, the number of xattr names that can be listed with listxattr(2) is
1274 * limited to XATTR_LIST_MAX aka 65536 bytes. If a larger buffer is passed
1275 * then vfs_listxattr() caps it to XATTR_LIST_MAX and if more xattr names
1276 * are found it will return -E2BIG.
1278 * Return: On success the required size or the size of the copied xattrs is
1279 * returned. On error a negative error code is returned.
1281 ssize_t
simple_xattr_list(struct inode
*inode
, struct simple_xattrs
*xattrs
,
1282 char *buffer
, size_t size
)
1284 bool trusted
= ns_capable_noaudit(&init_user_ns
, CAP_SYS_ADMIN
);
1285 struct simple_xattr
*xattr
;
1286 struct rb_node
*rbp
;
1287 ssize_t remaining_size
= size
;
1290 #ifdef CONFIG_FS_POSIX_ACL
1291 if (IS_POSIXACL(inode
)) {
1293 err
= xattr_list_one(&buffer
, &remaining_size
,
1294 XATTR_NAME_POSIX_ACL_ACCESS
);
1298 if (inode
->i_default_acl
) {
1299 err
= xattr_list_one(&buffer
, &remaining_size
,
1300 XATTR_NAME_POSIX_ACL_DEFAULT
);
1307 read_lock(&xattrs
->lock
);
1308 for (rbp
= rb_first(&xattrs
->rb_root
); rbp
; rbp
= rb_next(rbp
)) {
1309 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1311 /* skip "trusted." attributes for unprivileged callers */
1312 if (!trusted
&& xattr_is_trusted(xattr
->name
))
1315 err
= xattr_list_one(&buffer
, &remaining_size
, xattr
->name
);
1319 read_unlock(&xattrs
->lock
);
1321 return err
? err
: size
- remaining_size
;
1325 * rbtree_simple_xattr_less - compare two xattr rbtree nodes
1326 * @new_node: new node
1327 * @node: current node
1329 * Compare the xattr attached to @new_node with the xattr attached to @node.
1330 * Note that this function technically tolerates duplicate entries.
1332 * Return: True if insertion point in the rbtree is found.
1334 static bool rbtree_simple_xattr_less(struct rb_node
*new_node
,
1335 const struct rb_node
*node
)
1337 return rbtree_simple_xattr_node_cmp(new_node
, node
) < 0;
1341 * simple_xattr_add - add xattr objects
1342 * @xattrs: the header of the xattr object
1343 * @new_xattr: the xattr object to add
1345 * Add an xattr object to @xattrs. This assumes no replacement or removal
1346 * of matching xattrs is wanted. Should only be called during inode
1347 * initialization when a few distinct initial xattrs are supposed to be set.
1349 void simple_xattr_add(struct simple_xattrs
*xattrs
,
1350 struct simple_xattr
*new_xattr
)
1352 write_lock(&xattrs
->lock
);
1353 rb_add(&new_xattr
->rb_node
, &xattrs
->rb_root
, rbtree_simple_xattr_less
);
1354 write_unlock(&xattrs
->lock
);
1358 * simple_xattrs_init - initialize new xattr header
1359 * @xattrs: header to initialize
1361 * Initialize relevant fields of a an xattr header.
1363 void simple_xattrs_init(struct simple_xattrs
*xattrs
)
1365 xattrs
->rb_root
= RB_ROOT
;
1366 rwlock_init(&xattrs
->lock
);
1370 * simple_xattrs_free - free xattrs
1371 * @xattrs: xattr header whose xattrs to destroy
1373 * Destroy all xattrs in @xattr. When this is called no one can hold a
1374 * reference to any of the xattrs anymore.
1376 void simple_xattrs_free(struct simple_xattrs
*xattrs
)
1378 struct rb_node
*rbp
;
1380 rbp
= rb_first(&xattrs
->rb_root
);
1382 struct simple_xattr
*xattr
;
1383 struct rb_node
*rbp_next
;
1385 rbp_next
= rb_next(rbp
);
1386 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1387 rb_erase(&xattr
->rb_node
, &xattrs
->rb_root
);
1388 free_simple_xattr(xattr
);