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/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/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
* const *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 * @idmap: idmap 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 mnt_idmap
*idmap
, struct inode
*inode
)
99 if (IS_IMMUTABLE(inode
))
101 if (IS_APPEND(inode
))
103 if (HAS_UNMAPPED_ID(idmap
, 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 mnt_idmap
*idmap
, struct inode
*inode
,
114 const char *name
, int mask
)
116 if (mask
& MAY_WRITE
) {
119 ret
= may_write_xattr(idmap
, 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(idmap
, inode
))
155 return inode_permission(idmap
, inode
, mask
);
159 * Look for any handler that deals with the specified namespace.
162 xattr_supports_user_prefix(struct inode
*inode
)
164 const struct xattr_handler
* const *handlers
= inode
->i_sb
->s_xattr
;
165 const struct xattr_handler
*handler
;
167 if (!(inode
->i_opflags
& IOP_XATTR
)) {
168 if (unlikely(is_bad_inode(inode
)))
173 for_each_xattr_handler(handlers
, handler
) {
174 if (!strncmp(xattr_prefix(handler
), XATTR_USER_PREFIX
,
175 XATTR_USER_PREFIX_LEN
))
181 EXPORT_SYMBOL(xattr_supports_user_prefix
);
184 __vfs_setxattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
185 struct inode
*inode
, const char *name
, const void *value
,
186 size_t size
, int flags
)
188 const struct xattr_handler
*handler
;
190 if (is_posix_acl_xattr(name
))
193 handler
= xattr_resolve_name(inode
, &name
);
195 return PTR_ERR(handler
);
199 value
= ""; /* empty EA, do not remove */
200 return handler
->set(handler
, idmap
, dentry
, inode
, name
, value
,
203 EXPORT_SYMBOL(__vfs_setxattr
);
206 * __vfs_setxattr_noperm - perform setxattr operation without performing
209 * @idmap: idmap of the mount the inode was found from
210 * @dentry: object to perform setxattr on
211 * @name: xattr name to set
212 * @value: value to set @name to
213 * @size: size of @value
214 * @flags: flags to pass into filesystem operations
216 * returns the result of the internal setxattr or setsecurity operations.
218 * This function requires the caller to lock the inode's i_mutex before it
219 * is executed. It also assumes that the caller will make the appropriate
222 int __vfs_setxattr_noperm(struct mnt_idmap
*idmap
,
223 struct dentry
*dentry
, const char *name
,
224 const void *value
, size_t size
, int flags
)
226 struct inode
*inode
= dentry
->d_inode
;
228 int issec
= !strncmp(name
, XATTR_SECURITY_PREFIX
,
229 XATTR_SECURITY_PREFIX_LEN
);
232 inode
->i_flags
&= ~S_NOSEC
;
233 if (inode
->i_opflags
& IOP_XATTR
) {
234 error
= __vfs_setxattr(idmap
, dentry
, inode
, name
, value
,
237 fsnotify_xattr(dentry
);
238 security_inode_post_setxattr(dentry
, name
, value
,
242 if (unlikely(is_bad_inode(inode
)))
245 if (error
== -EAGAIN
) {
249 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
251 error
= security_inode_setsecurity(inode
, suffix
, value
,
254 fsnotify_xattr(dentry
);
262 * __vfs_setxattr_locked - set an extended attribute while holding the inode
265 * @idmap: idmap of the mount of the target inode
266 * @dentry: object to perform setxattr on
267 * @name: xattr name to set
268 * @value: value to set @name to
269 * @size: size of @value
270 * @flags: flags to pass into filesystem operations
271 * @delegated_inode: on return, will contain an inode pointer that
272 * a delegation was broken on, NULL if none.
275 __vfs_setxattr_locked(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
276 const char *name
, const void *value
, size_t size
,
277 int flags
, struct inode
**delegated_inode
)
279 struct inode
*inode
= dentry
->d_inode
;
282 error
= xattr_permission(idmap
, inode
, name
, MAY_WRITE
);
286 error
= security_inode_setxattr(idmap
, dentry
, name
, value
, size
,
291 error
= try_break_deleg(inode
, delegated_inode
);
295 error
= __vfs_setxattr_noperm(idmap
, dentry
, name
, value
,
301 EXPORT_SYMBOL_GPL(__vfs_setxattr_locked
);
304 vfs_setxattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
305 const char *name
, const void *value
, size_t size
, int flags
)
307 struct inode
*inode
= dentry
->d_inode
;
308 struct inode
*delegated_inode
= NULL
;
309 const void *orig_value
= value
;
312 if (size
&& strcmp(name
, XATTR_NAME_CAPS
) == 0) {
313 error
= cap_convert_nscap(idmap
, dentry
, &value
, size
);
321 error
= __vfs_setxattr_locked(idmap
, dentry
, name
, value
, size
,
322 flags
, &delegated_inode
);
325 if (delegated_inode
) {
326 error
= break_deleg_wait(&delegated_inode
);
330 if (value
!= orig_value
)
335 EXPORT_SYMBOL_GPL(vfs_setxattr
);
338 xattr_getsecurity(struct mnt_idmap
*idmap
, struct inode
*inode
,
339 const char *name
, void *value
, size_t size
)
344 if (!value
|| !size
) {
345 len
= security_inode_getsecurity(idmap
, inode
, name
,
350 len
= security_inode_getsecurity(idmap
, inode
, name
, &buffer
,
358 memcpy(value
, buffer
, len
);
366 * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
368 * Allocate memory, if not already allocated, or re-allocate correct size,
369 * before retrieving the extended attribute. The xattr value buffer should
370 * always be freed by the caller, even on error.
372 * Returns the result of alloc, if failed, or the getxattr operation.
375 vfs_getxattr_alloc(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
376 const char *name
, char **xattr_value
, size_t xattr_size
,
379 const struct xattr_handler
*handler
;
380 struct inode
*inode
= dentry
->d_inode
;
381 char *value
= *xattr_value
;
384 error
= xattr_permission(idmap
, inode
, name
, MAY_READ
);
388 handler
= xattr_resolve_name(inode
, &name
);
390 return PTR_ERR(handler
);
393 error
= handler
->get(handler
, dentry
, inode
, name
, NULL
, 0);
397 if (!value
|| (error
> xattr_size
)) {
398 value
= krealloc(*xattr_value
, error
+ 1, flags
);
401 memset(value
, 0, error
+ 1);
404 error
= handler
->get(handler
, dentry
, inode
, name
, value
, error
);
405 *xattr_value
= value
;
410 __vfs_getxattr(struct dentry
*dentry
, struct inode
*inode
, const char *name
,
411 void *value
, size_t size
)
413 const struct xattr_handler
*handler
;
415 if (is_posix_acl_xattr(name
))
418 handler
= xattr_resolve_name(inode
, &name
);
420 return PTR_ERR(handler
);
423 return handler
->get(handler
, dentry
, inode
, name
, value
, size
);
425 EXPORT_SYMBOL(__vfs_getxattr
);
428 vfs_getxattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
429 const char *name
, void *value
, size_t size
)
431 struct inode
*inode
= dentry
->d_inode
;
434 error
= xattr_permission(idmap
, inode
, name
, MAY_READ
);
438 error
= security_inode_getxattr(dentry
, name
);
442 if (!strncmp(name
, XATTR_SECURITY_PREFIX
,
443 XATTR_SECURITY_PREFIX_LEN
)) {
444 const char *suffix
= name
+ XATTR_SECURITY_PREFIX_LEN
;
445 int ret
= xattr_getsecurity(idmap
, inode
, suffix
, value
,
448 * Only overwrite the return value if a security module
449 * is actually active.
451 if (ret
== -EOPNOTSUPP
)
456 return __vfs_getxattr(dentry
, inode
, name
, value
, size
);
458 EXPORT_SYMBOL_GPL(vfs_getxattr
);
461 * vfs_listxattr - retrieve \0 separated list of xattr names
462 * @dentry: the dentry from whose inode the xattr names are retrieved
463 * @list: buffer to store xattr names into
464 * @size: size of the buffer
466 * This function returns the names of all xattrs associated with the
469 * Note, for legacy reasons the vfs_listxattr() function lists POSIX
470 * ACLs as well. Since POSIX ACLs are decoupled from IOP_XATTR the
471 * vfs_listxattr() function doesn't check for this flag since a
472 * filesystem could implement POSIX ACLs without implementing any other
475 * However, since all codepaths that remove IOP_XATTR also assign of
476 * inode operations that either don't implement or implement a stub
477 * ->listxattr() operation.
479 * Return: On success, the size of the buffer that was used. On error a
480 * negative error code.
483 vfs_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
485 struct inode
*inode
= d_inode(dentry
);
488 error
= security_inode_listxattr(dentry
);
492 if (inode
->i_op
->listxattr
) {
493 error
= inode
->i_op
->listxattr(dentry
, list
, size
);
495 error
= security_inode_listsecurity(inode
, list
, size
);
496 if (size
&& error
> size
)
501 EXPORT_SYMBOL_GPL(vfs_listxattr
);
504 __vfs_removexattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
507 struct inode
*inode
= d_inode(dentry
);
508 const struct xattr_handler
*handler
;
510 if (is_posix_acl_xattr(name
))
513 handler
= xattr_resolve_name(inode
, &name
);
515 return PTR_ERR(handler
);
518 return handler
->set(handler
, idmap
, dentry
, inode
, name
, NULL
, 0,
521 EXPORT_SYMBOL(__vfs_removexattr
);
524 * __vfs_removexattr_locked - set an extended attribute while holding the inode
527 * @idmap: idmap of the mount of the target inode
528 * @dentry: object to perform setxattr on
529 * @name: name of xattr to remove
530 * @delegated_inode: on return, will contain an inode pointer that
531 * a delegation was broken on, NULL if none.
534 __vfs_removexattr_locked(struct mnt_idmap
*idmap
,
535 struct dentry
*dentry
, const char *name
,
536 struct inode
**delegated_inode
)
538 struct inode
*inode
= dentry
->d_inode
;
541 error
= xattr_permission(idmap
, inode
, name
, MAY_WRITE
);
545 error
= security_inode_removexattr(idmap
, dentry
, name
);
549 error
= try_break_deleg(inode
, delegated_inode
);
553 error
= __vfs_removexattr(idmap
, dentry
, name
);
557 fsnotify_xattr(dentry
);
558 security_inode_post_removexattr(dentry
, name
);
563 EXPORT_SYMBOL_GPL(__vfs_removexattr_locked
);
566 vfs_removexattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
569 struct inode
*inode
= dentry
->d_inode
;
570 struct inode
*delegated_inode
= NULL
;
575 error
= __vfs_removexattr_locked(idmap
, dentry
,
576 name
, &delegated_inode
);
579 if (delegated_inode
) {
580 error
= break_deleg_wait(&delegated_inode
);
587 EXPORT_SYMBOL_GPL(vfs_removexattr
);
590 * Extended attribute SET operations
593 int setxattr_copy(const char __user
*name
, struct xattr_ctx
*ctx
)
597 if (ctx
->flags
& ~(XATTR_CREATE
|XATTR_REPLACE
))
600 error
= strncpy_from_user(ctx
->kname
->name
, name
,
601 sizeof(ctx
->kname
->name
));
602 if (error
== 0 || error
== sizeof(ctx
->kname
->name
))
609 if (ctx
->size
> XATTR_SIZE_MAX
)
612 ctx
->kvalue
= vmemdup_user(ctx
->cvalue
, ctx
->size
);
613 if (IS_ERR(ctx
->kvalue
)) {
614 error
= PTR_ERR(ctx
->kvalue
);
622 int do_setxattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
623 struct xattr_ctx
*ctx
)
625 if (is_posix_acl_xattr(ctx
->kname
->name
))
626 return do_set_acl(idmap
, dentry
, ctx
->kname
->name
,
627 ctx
->kvalue
, ctx
->size
);
629 return vfs_setxattr(idmap
, dentry
, ctx
->kname
->name
,
630 ctx
->kvalue
, ctx
->size
, ctx
->flags
);
634 setxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
635 const char __user
*name
, const void __user
*value
, size_t size
,
638 struct xattr_name kname
;
639 struct xattr_ctx ctx
= {
648 error
= setxattr_copy(name
, &ctx
);
652 error
= do_setxattr(idmap
, d
, &ctx
);
658 static int path_setxattr(const char __user
*pathname
,
659 const char __user
*name
, const void __user
*value
,
660 size_t size
, int flags
, unsigned int lookup_flags
)
666 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
669 error
= mnt_want_write(path
.mnt
);
671 error
= setxattr(mnt_idmap(path
.mnt
), path
.dentry
, name
,
673 mnt_drop_write(path
.mnt
);
676 if (retry_estale(error
, lookup_flags
)) {
677 lookup_flags
|= LOOKUP_REVAL
;
683 SYSCALL_DEFINE5(setxattr
, const char __user
*, pathname
,
684 const char __user
*, name
, const void __user
*, value
,
685 size_t, size
, int, flags
)
687 return path_setxattr(pathname
, name
, value
, size
, flags
, LOOKUP_FOLLOW
);
690 SYSCALL_DEFINE5(lsetxattr
, const char __user
*, pathname
,
691 const char __user
*, name
, const void __user
*, value
,
692 size_t, size
, int, flags
)
694 return path_setxattr(pathname
, name
, value
, size
, flags
, 0);
697 SYSCALL_DEFINE5(fsetxattr
, int, fd
, const char __user
*, name
,
698 const void __user
*,value
, size_t, size
, int, flags
)
700 struct fd f
= fdget(fd
);
706 error
= mnt_want_write_file(f
.file
);
708 error
= setxattr(file_mnt_idmap(f
.file
),
709 f
.file
->f_path
.dentry
, name
,
711 mnt_drop_write_file(f
.file
);
718 * Extended attribute GET operations
721 do_getxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
722 struct xattr_ctx
*ctx
)
725 char *kname
= ctx
->kname
->name
;
728 if (ctx
->size
> XATTR_SIZE_MAX
)
729 ctx
->size
= XATTR_SIZE_MAX
;
730 ctx
->kvalue
= kvzalloc(ctx
->size
, GFP_KERNEL
);
735 if (is_posix_acl_xattr(ctx
->kname
->name
))
736 error
= do_get_acl(idmap
, d
, kname
, ctx
->kvalue
, ctx
->size
);
738 error
= vfs_getxattr(idmap
, d
, kname
, ctx
->kvalue
, ctx
->size
);
740 if (ctx
->size
&& copy_to_user(ctx
->value
, ctx
->kvalue
, error
))
742 } else if (error
== -ERANGE
&& ctx
->size
>= XATTR_SIZE_MAX
) {
743 /* The file system tried to returned a value bigger
744 than XATTR_SIZE_MAX bytes. Not possible. */
752 getxattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
753 const char __user
*name
, void __user
*value
, size_t size
)
756 struct xattr_name kname
;
757 struct xattr_ctx ctx
= {
765 error
= strncpy_from_user(kname
.name
, name
, sizeof(kname
.name
));
766 if (error
== 0 || error
== sizeof(kname
.name
))
771 error
= do_getxattr(idmap
, d
, &ctx
);
777 static ssize_t
path_getxattr(const char __user
*pathname
,
778 const char __user
*name
, void __user
*value
,
779 size_t size
, unsigned int lookup_flags
)
784 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
787 error
= getxattr(mnt_idmap(path
.mnt
), path
.dentry
, name
, value
, size
);
789 if (retry_estale(error
, lookup_flags
)) {
790 lookup_flags
|= LOOKUP_REVAL
;
796 SYSCALL_DEFINE4(getxattr
, const char __user
*, pathname
,
797 const char __user
*, name
, void __user
*, value
, size_t, size
)
799 return path_getxattr(pathname
, name
, value
, size
, LOOKUP_FOLLOW
);
802 SYSCALL_DEFINE4(lgetxattr
, const char __user
*, pathname
,
803 const char __user
*, name
, void __user
*, value
, size_t, size
)
805 return path_getxattr(pathname
, name
, value
, size
, 0);
808 SYSCALL_DEFINE4(fgetxattr
, int, fd
, const char __user
*, name
,
809 void __user
*, value
, size_t, size
)
811 struct fd f
= fdget(fd
);
812 ssize_t error
= -EBADF
;
817 error
= getxattr(file_mnt_idmap(f
.file
), f
.file
->f_path
.dentry
,
824 * Extended attribute LIST operations
827 listxattr(struct dentry
*d
, char __user
*list
, size_t size
)
833 if (size
> XATTR_LIST_MAX
)
834 size
= XATTR_LIST_MAX
;
835 klist
= kvmalloc(size
, GFP_KERNEL
);
840 error
= vfs_listxattr(d
, klist
, size
);
842 if (size
&& copy_to_user(list
, klist
, error
))
844 } else if (error
== -ERANGE
&& size
>= XATTR_LIST_MAX
) {
845 /* The file system tried to returned a list bigger
846 than XATTR_LIST_MAX bytes. Not possible. */
855 static ssize_t
path_listxattr(const char __user
*pathname
, char __user
*list
,
856 size_t size
, unsigned int lookup_flags
)
861 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
864 error
= listxattr(path
.dentry
, list
, size
);
866 if (retry_estale(error
, lookup_flags
)) {
867 lookup_flags
|= LOOKUP_REVAL
;
873 SYSCALL_DEFINE3(listxattr
, const char __user
*, pathname
, char __user
*, list
,
876 return path_listxattr(pathname
, list
, size
, LOOKUP_FOLLOW
);
879 SYSCALL_DEFINE3(llistxattr
, const char __user
*, pathname
, char __user
*, list
,
882 return path_listxattr(pathname
, list
, size
, 0);
885 SYSCALL_DEFINE3(flistxattr
, int, fd
, char __user
*, list
, size_t, size
)
887 struct fd f
= fdget(fd
);
888 ssize_t error
= -EBADF
;
893 error
= listxattr(f
.file
->f_path
.dentry
, list
, size
);
899 * Extended attribute REMOVE operations
902 removexattr(struct mnt_idmap
*idmap
, struct dentry
*d
,
903 const char __user
*name
)
906 char kname
[XATTR_NAME_MAX
+ 1];
908 error
= strncpy_from_user(kname
, name
, sizeof(kname
));
909 if (error
== 0 || error
== sizeof(kname
))
914 if (is_posix_acl_xattr(kname
))
915 return vfs_remove_acl(idmap
, d
, kname
);
917 return vfs_removexattr(idmap
, d
, kname
);
920 static int path_removexattr(const char __user
*pathname
,
921 const char __user
*name
, unsigned int lookup_flags
)
926 error
= user_path_at(AT_FDCWD
, pathname
, lookup_flags
, &path
);
929 error
= mnt_want_write(path
.mnt
);
931 error
= removexattr(mnt_idmap(path
.mnt
), path
.dentry
, name
);
932 mnt_drop_write(path
.mnt
);
935 if (retry_estale(error
, lookup_flags
)) {
936 lookup_flags
|= LOOKUP_REVAL
;
942 SYSCALL_DEFINE2(removexattr
, const char __user
*, pathname
,
943 const char __user
*, name
)
945 return path_removexattr(pathname
, name
, LOOKUP_FOLLOW
);
948 SYSCALL_DEFINE2(lremovexattr
, const char __user
*, pathname
,
949 const char __user
*, name
)
951 return path_removexattr(pathname
, name
, 0);
954 SYSCALL_DEFINE2(fremovexattr
, int, fd
, const char __user
*, name
)
956 struct fd f
= fdget(fd
);
962 error
= mnt_want_write_file(f
.file
);
964 error
= removexattr(file_mnt_idmap(f
.file
),
965 f
.file
->f_path
.dentry
, name
);
966 mnt_drop_write_file(f
.file
);
972 int xattr_list_one(char **buffer
, ssize_t
*remaining_size
, const char *name
)
976 len
= strlen(name
) + 1;
978 if (*remaining_size
< len
)
980 memcpy(*buffer
, name
, len
);
983 *remaining_size
-= len
;
988 * generic_listxattr - run through a dentry's xattr list() operations
989 * @dentry: dentry to list the xattrs
990 * @buffer: result buffer
991 * @buffer_size: size of @buffer
993 * Combine the results of the list() operation from every xattr_handler in the
994 * xattr_handler stack.
996 * Note that this will not include the entries for POSIX ACLs.
999 generic_listxattr(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
1001 const struct xattr_handler
*handler
, * const *handlers
= dentry
->d_sb
->s_xattr
;
1002 ssize_t remaining_size
= buffer_size
;
1005 for_each_xattr_handler(handlers
, handler
) {
1006 if (!handler
->name
|| (handler
->list
&& !handler
->list(dentry
)))
1008 err
= xattr_list_one(&buffer
, &remaining_size
, handler
->name
);
1013 return err
? err
: buffer_size
- remaining_size
;
1015 EXPORT_SYMBOL(generic_listxattr
);
1018 * xattr_full_name - Compute full attribute name from suffix
1020 * @handler: handler of the xattr_handler operation
1021 * @name: name passed to the xattr_handler operation
1023 * The get and set xattr handler operations are called with the remainder of
1024 * the attribute name after skipping the handler's prefix: for example, "foo"
1025 * is passed to the get operation of a handler with prefix "user." to get
1026 * attribute "user.foo". The full name is still "there" in the name though.
1028 * Note: the list xattr handler operation when called from the vfs is passed a
1029 * NULL name; some file systems use this operation internally, with varying
1032 const char *xattr_full_name(const struct xattr_handler
*handler
,
1035 size_t prefix_len
= strlen(xattr_prefix(handler
));
1037 return name
- prefix_len
;
1039 EXPORT_SYMBOL(xattr_full_name
);
1042 * simple_xattr_space - estimate the memory used by a simple xattr
1043 * @name: the full name of the xattr
1044 * @size: the size of its value
1046 * This takes no account of how much larger the two slab objects actually are:
1047 * that would depend on the slab implementation, when what is required is a
1048 * deterministic number, which grows with name length and size and quantity.
1050 * Return: The approximate number of bytes of memory used by such an xattr.
1052 size_t simple_xattr_space(const char *name
, size_t size
)
1055 * Use "40" instead of sizeof(struct simple_xattr), to return the
1056 * same result on 32-bit and 64-bit, and even if simple_xattr grows.
1058 return 40 + size
+ strlen(name
);
1062 * simple_xattr_free - free an xattr object
1063 * @xattr: the xattr object
1065 * Free the xattr object. Can handle @xattr being NULL.
1067 void simple_xattr_free(struct simple_xattr
*xattr
)
1075 * simple_xattr_alloc - allocate new xattr object
1076 * @value: value of the xattr object
1077 * @size: size of @value
1079 * Allocate a new xattr object and initialize respective members. The caller is
1080 * responsible for handling the name of the xattr.
1082 * Return: On success a new xattr object is returned. On failure NULL is
1085 struct simple_xattr
*simple_xattr_alloc(const void *value
, size_t size
)
1087 struct simple_xattr
*new_xattr
;
1091 len
= sizeof(*new_xattr
) + size
;
1092 if (len
< sizeof(*new_xattr
))
1095 new_xattr
= kvmalloc(len
, GFP_KERNEL_ACCOUNT
);
1099 new_xattr
->size
= size
;
1100 memcpy(new_xattr
->value
, value
, size
);
1105 * rbtree_simple_xattr_cmp - compare xattr name with current rbtree xattr entry
1107 * @node: current node
1109 * Compare the xattr name with the xattr name attached to @node in the rbtree.
1111 * Return: Negative value if continuing left, positive if continuing right, 0
1112 * if the xattr attached to @node matches @key.
1114 static int rbtree_simple_xattr_cmp(const void *key
, const struct rb_node
*node
)
1116 const char *xattr_name
= key
;
1117 const struct simple_xattr
*xattr
;
1119 xattr
= rb_entry(node
, struct simple_xattr
, rb_node
);
1120 return strcmp(xattr
->name
, xattr_name
);
1124 * rbtree_simple_xattr_node_cmp - compare two xattr rbtree nodes
1125 * @new_node: new node
1126 * @node: current node
1128 * Compare the xattr attached to @new_node with the xattr attached to @node.
1130 * Return: Negative value if continuing left, positive if continuing right, 0
1131 * if the xattr attached to @new_node matches the xattr attached to @node.
1133 static int rbtree_simple_xattr_node_cmp(struct rb_node
*new_node
,
1134 const struct rb_node
*node
)
1136 struct simple_xattr
*xattr
;
1137 xattr
= rb_entry(new_node
, struct simple_xattr
, rb_node
);
1138 return rbtree_simple_xattr_cmp(xattr
->name
, node
);
1142 * simple_xattr_get - get an xattr object
1143 * @xattrs: the header of the xattr object
1144 * @name: the name of the xattr to retrieve
1145 * @buffer: the buffer to store the value into
1146 * @size: the size of @buffer
1148 * Try to find and retrieve the xattr object associated with @name.
1149 * If @buffer is provided store the value of @xattr in @buffer
1150 * otherwise just return the length. The size of @buffer is limited
1151 * to XATTR_SIZE_MAX which currently is 65536.
1153 * Return: On success the length of the xattr value is returned. On error a
1154 * negative error code is returned.
1156 int simple_xattr_get(struct simple_xattrs
*xattrs
, const char *name
,
1157 void *buffer
, size_t size
)
1159 struct simple_xattr
*xattr
= NULL
;
1160 struct rb_node
*rbp
;
1163 read_lock(&xattrs
->lock
);
1164 rbp
= rb_find(name
, &xattrs
->rb_root
, rbtree_simple_xattr_cmp
);
1166 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1169 if (size
< xattr
->size
)
1172 memcpy(buffer
, xattr
->value
, xattr
->size
);
1175 read_unlock(&xattrs
->lock
);
1180 * simple_xattr_set - set an xattr object
1181 * @xattrs: the header of the xattr object
1182 * @name: the name of the xattr to retrieve
1183 * @value: the value to store along the xattr
1184 * @size: the size of @value
1185 * @flags: the flags determining how to set the xattr
1187 * Set a new xattr object.
1188 * If @value is passed a new xattr object will be allocated. If XATTR_REPLACE
1189 * is specified in @flags a matching xattr object for @name must already exist.
1190 * If it does it will be replaced with the new xattr object. If it doesn't we
1191 * fail. If XATTR_CREATE is specified and a matching xattr does already exist
1192 * we fail. If it doesn't we create a new xattr. If @flags is zero we simply
1193 * insert the new xattr replacing any existing one.
1195 * If @value is empty and a matching xattr object is found we delete it if
1196 * XATTR_REPLACE is specified in @flags or @flags is zero.
1198 * If @value is empty and no matching xattr object for @name is found we do
1199 * nothing if XATTR_CREATE is specified in @flags or @flags is zero. For
1200 * XATTR_REPLACE we fail as mentioned above.
1202 * Return: On success, the removed or replaced xattr is returned, to be freed
1203 * by the caller; or NULL if none. On failure a negative error code is returned.
1205 struct simple_xattr
*simple_xattr_set(struct simple_xattrs
*xattrs
,
1206 const char *name
, const void *value
,
1207 size_t size
, int flags
)
1209 struct simple_xattr
*old_xattr
= NULL
, *new_xattr
= NULL
;
1210 struct rb_node
*parent
= NULL
, **rbp
;
1213 /* value == NULL means remove */
1215 new_xattr
= simple_xattr_alloc(value
, size
);
1217 return ERR_PTR(-ENOMEM
);
1219 new_xattr
->name
= kstrdup(name
, GFP_KERNEL_ACCOUNT
);
1220 if (!new_xattr
->name
) {
1221 simple_xattr_free(new_xattr
);
1222 return ERR_PTR(-ENOMEM
);
1226 write_lock(&xattrs
->lock
);
1227 rbp
= &xattrs
->rb_root
.rb_node
;
1230 ret
= rbtree_simple_xattr_cmp(name
, *rbp
);
1232 rbp
= &(*rbp
)->rb_left
;
1234 rbp
= &(*rbp
)->rb_right
;
1236 old_xattr
= rb_entry(*rbp
, struct simple_xattr
, rb_node
);
1242 /* Fail if XATTR_CREATE is requested and the xattr exists. */
1243 if (flags
& XATTR_CREATE
) {
1249 rb_replace_node(&old_xattr
->rb_node
,
1250 &new_xattr
->rb_node
, &xattrs
->rb_root
);
1252 rb_erase(&old_xattr
->rb_node
, &xattrs
->rb_root
);
1254 /* Fail if XATTR_REPLACE is requested but no xattr is found. */
1255 if (flags
& XATTR_REPLACE
) {
1261 * If XATTR_CREATE or no flags are specified together with a
1262 * new value simply insert it.
1265 rb_link_node(&new_xattr
->rb_node
, parent
, rbp
);
1266 rb_insert_color(&new_xattr
->rb_node
, &xattrs
->rb_root
);
1270 * If XATTR_CREATE or no flags are specified and neither an
1271 * old or new xattr exist then we don't need to do anything.
1276 write_unlock(&xattrs
->lock
);
1279 simple_xattr_free(new_xattr
);
1280 return ERR_PTR(err
);
1283 static bool xattr_is_trusted(const char *name
)
1285 return !strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
);
1289 * simple_xattr_list - list all xattr objects
1290 * @inode: inode from which to get the xattrs
1291 * @xattrs: the header of the xattr object
1292 * @buffer: the buffer to store all xattrs into
1293 * @size: the size of @buffer
1295 * List all xattrs associated with @inode. If @buffer is NULL we returned
1296 * the required size of the buffer. If @buffer is provided we store the
1297 * xattrs value into it provided it is big enough.
1299 * Note, the number of xattr names that can be listed with listxattr(2) is
1300 * limited to XATTR_LIST_MAX aka 65536 bytes. If a larger buffer is passed
1301 * then vfs_listxattr() caps it to XATTR_LIST_MAX and if more xattr names
1302 * are found it will return -E2BIG.
1304 * Return: On success the required size or the size of the copied xattrs is
1305 * returned. On error a negative error code is returned.
1307 ssize_t
simple_xattr_list(struct inode
*inode
, struct simple_xattrs
*xattrs
,
1308 char *buffer
, size_t size
)
1310 bool trusted
= ns_capable_noaudit(&init_user_ns
, CAP_SYS_ADMIN
);
1311 struct simple_xattr
*xattr
;
1312 struct rb_node
*rbp
;
1313 ssize_t remaining_size
= size
;
1316 err
= posix_acl_listxattr(inode
, &buffer
, &remaining_size
);
1320 read_lock(&xattrs
->lock
);
1321 for (rbp
= rb_first(&xattrs
->rb_root
); rbp
; rbp
= rb_next(rbp
)) {
1322 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1324 /* skip "trusted." attributes for unprivileged callers */
1325 if (!trusted
&& xattr_is_trusted(xattr
->name
))
1328 err
= xattr_list_one(&buffer
, &remaining_size
, xattr
->name
);
1332 read_unlock(&xattrs
->lock
);
1334 return err
? err
: size
- remaining_size
;
1338 * rbtree_simple_xattr_less - compare two xattr rbtree nodes
1339 * @new_node: new node
1340 * @node: current node
1342 * Compare the xattr attached to @new_node with the xattr attached to @node.
1343 * Note that this function technically tolerates duplicate entries.
1345 * Return: True if insertion point in the rbtree is found.
1347 static bool rbtree_simple_xattr_less(struct rb_node
*new_node
,
1348 const struct rb_node
*node
)
1350 return rbtree_simple_xattr_node_cmp(new_node
, node
) < 0;
1354 * simple_xattr_add - add xattr objects
1355 * @xattrs: the header of the xattr object
1356 * @new_xattr: the xattr object to add
1358 * Add an xattr object to @xattrs. This assumes no replacement or removal
1359 * of matching xattrs is wanted. Should only be called during inode
1360 * initialization when a few distinct initial xattrs are supposed to be set.
1362 void simple_xattr_add(struct simple_xattrs
*xattrs
,
1363 struct simple_xattr
*new_xattr
)
1365 write_lock(&xattrs
->lock
);
1366 rb_add(&new_xattr
->rb_node
, &xattrs
->rb_root
, rbtree_simple_xattr_less
);
1367 write_unlock(&xattrs
->lock
);
1371 * simple_xattrs_init - initialize new xattr header
1372 * @xattrs: header to initialize
1374 * Initialize relevant fields of a an xattr header.
1376 void simple_xattrs_init(struct simple_xattrs
*xattrs
)
1378 xattrs
->rb_root
= RB_ROOT
;
1379 rwlock_init(&xattrs
->lock
);
1383 * simple_xattrs_free - free xattrs
1384 * @xattrs: xattr header whose xattrs to destroy
1385 * @freed_space: approximate number of bytes of memory freed from @xattrs
1387 * Destroy all xattrs in @xattr. When this is called no one can hold a
1388 * reference to any of the xattrs anymore.
1390 void simple_xattrs_free(struct simple_xattrs
*xattrs
, size_t *freed_space
)
1392 struct rb_node
*rbp
;
1396 rbp
= rb_first(&xattrs
->rb_root
);
1398 struct simple_xattr
*xattr
;
1399 struct rb_node
*rbp_next
;
1401 rbp_next
= rb_next(rbp
);
1402 xattr
= rb_entry(rbp
, struct simple_xattr
, rb_node
);
1403 rb_erase(&xattr
->rb_node
, &xattrs
->rb_root
);
1405 *freed_space
+= simple_xattr_space(xattr
->name
,
1407 simple_xattr_free(xattr
);