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/syscalls.h>
18 #include <linux/module.h>
19 #include <linux/fsnotify.h>
20 #include <linux/audit.h>
21 #include <asm/uaccess.h>
25 * Check permissions for extended attribute access. This is a bit complicated
26 * because different namespaces have very different rules.
29 xattr_permission(struct inode *inode, const char *name, int mask)
32 * We can never set or remove an extended attribute on a read-only
33 * filesystem or on an immutable / append-only inode.
35 if (mask & MAY_WRITE) {
36 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
41 * No restriction for security.* and system.* from the VFS. Decision
42 * on these is left to the underlying filesystem / security module.
44 if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
45 !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
49 * The trusted.* namespace can only be accessed by privileged users.
51 if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
52 if (!capable(CAP_SYS_ADMIN))
53 return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
58 * In the user.* namespace, only regular files and directories can have
59 * extended attributes. For sticky directories, only the owner and
60 * privileged users can write attributes.
62 if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
63 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
64 return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
65 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
66 (mask & MAY_WRITE) && !inode_owner_or_capable(inode))
70 return inode_permission(inode, mask);
74 * __vfs_setxattr_noperm - perform setxattr operation without performing
77 * @dentry - object to perform setxattr on
78 * @name - xattr name to set
79 * @value - value to set @name to
80 * @size - size of @value
81 * @flags - flags to pass into filesystem operations
83 * returns the result of the internal setxattr or setsecurity operations.
85 * This function requires the caller to lock the inode's i_mutex before it
86 * is executed. It also assumes that the caller will make the appropriate
89 int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
90 const void *value, size_t size, int flags)
92 struct inode *inode = dentry->d_inode;
93 int error = -EOPNOTSUPP;
94 int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
95 XATTR_SECURITY_PREFIX_LEN);
98 inode->i_flags &= ~S_NOSEC;
99 if (inode->i_op->setxattr) {
100 error = inode->i_op->setxattr(dentry, name, value, size, flags);
102 fsnotify_xattr(dentry);
103 security_inode_post_setxattr(dentry, name, value,
107 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
108 error = security_inode_setsecurity(inode, suffix, value,
111 fsnotify_xattr(dentry);
119 vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
120 size_t size, int flags)
122 struct inode *inode = dentry->d_inode;
125 error = xattr_permission(inode, name, MAY_WRITE);
129 mutex_lock(&inode->i_mutex);
130 error = security_inode_setxattr(dentry, name, value, size, flags);
134 error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
137 mutex_unlock(&inode->i_mutex);
140 EXPORT_SYMBOL_GPL(vfs_setxattr);
143 xattr_getsecurity(struct inode *inode, const char *name, void *value,
149 if (!value || !size) {
150 len = security_inode_getsecurity(inode, name, &buffer, false);
154 len = security_inode_getsecurity(inode, name, &buffer, true);
161 memcpy(value, buffer, len);
163 security_release_secctx(buffer, len);
167 EXPORT_SYMBOL_GPL(xattr_getsecurity);
170 vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
172 struct inode *inode = dentry->d_inode;
175 error = xattr_permission(inode, name, MAY_READ);
179 error = security_inode_getxattr(dentry, name);
183 if (!strncmp(name, XATTR_SECURITY_PREFIX,
184 XATTR_SECURITY_PREFIX_LEN)) {
185 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
186 int ret = xattr_getsecurity(inode, suffix, value, size);
188 * Only overwrite the return value if a security module
189 * is actually active.
191 if (ret == -EOPNOTSUPP)
196 if (inode->i_op->getxattr)
197 error = inode->i_op->getxattr(dentry, name, value, size);
203 EXPORT_SYMBOL_GPL(vfs_getxattr);
206 vfs_listxattr(struct dentry *d, char *list, size_t size)
210 error = security_inode_listxattr(d);
214 if (d->d_inode->i_op->listxattr) {
215 error = d->d_inode->i_op->listxattr(d, list, size);
217 error = security_inode_listsecurity(d->d_inode, list, size);
218 if (size && error > size)
223 EXPORT_SYMBOL_GPL(vfs_listxattr);
226 vfs_removexattr(struct dentry *dentry, const char *name)
228 struct inode *inode = dentry->d_inode;
231 if (!inode->i_op->removexattr)
234 error = xattr_permission(inode, name, MAY_WRITE);
238 error = security_inode_removexattr(dentry, name);
242 mutex_lock(&inode->i_mutex);
243 error = inode->i_op->removexattr(dentry, name);
244 mutex_unlock(&inode->i_mutex);
247 fsnotify_xattr(dentry);
250 EXPORT_SYMBOL_GPL(vfs_removexattr);
254 * Extended attribute SET operations
257 setxattr(struct dentry *d, const char __user *name, const void __user *value,
258 size_t size, int flags)
262 char kname[XATTR_NAME_MAX + 1];
264 if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
267 error = strncpy_from_user(kname, name, sizeof(kname));
268 if (error == 0 || error == sizeof(kname))
274 if (size > XATTR_SIZE_MAX)
276 kvalue = memdup_user(value, size);
278 return PTR_ERR(kvalue);
281 error = vfs_setxattr(d, kname, kvalue, size, flags);
286 SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
287 const char __user *, name, const void __user *, value,
288 size_t, size, int, flags)
293 error = user_path(pathname, &path);
296 error = mnt_want_write(path.mnt);
298 error = setxattr(path.dentry, name, value, size, flags);
299 mnt_drop_write(path.mnt);
305 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
306 const char __user *, name, const void __user *, value,
307 size_t, size, int, flags)
312 error = user_lpath(pathname, &path);
315 error = mnt_want_write(path.mnt);
317 error = setxattr(path.dentry, name, value, size, flags);
318 mnt_drop_write(path.mnt);
324 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
325 const void __user *,value, size_t, size, int, flags)
328 struct dentry *dentry;
334 dentry = f->f_path.dentry;
335 audit_inode(NULL, dentry);
336 error = mnt_want_write_file(f);
338 error = setxattr(dentry, name, value, size, flags);
339 mnt_drop_write(f->f_path.mnt);
346 * Extended attribute GET operations
349 getxattr(struct dentry *d, const char __user *name, void __user *value,
354 char kname[XATTR_NAME_MAX + 1];
356 error = strncpy_from_user(kname, name, sizeof(kname));
357 if (error == 0 || error == sizeof(kname))
363 if (size > XATTR_SIZE_MAX)
364 size = XATTR_SIZE_MAX;
365 kvalue = kzalloc(size, GFP_KERNEL);
370 error = vfs_getxattr(d, kname, kvalue, size);
372 if (size && copy_to_user(value, kvalue, error))
374 } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
375 /* The file system tried to returned a value bigger
376 than XATTR_SIZE_MAX bytes. Not possible. */
383 SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
384 const char __user *, name, void __user *, value, size_t, size)
389 error = user_path(pathname, &path);
392 error = getxattr(path.dentry, name, value, size);
397 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
398 const char __user *, name, void __user *, value, size_t, size)
403 error = user_lpath(pathname, &path);
406 error = getxattr(path.dentry, name, value, size);
411 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
412 void __user *, value, size_t, size)
415 ssize_t error = -EBADF;
420 audit_inode(NULL, f->f_path.dentry);
421 error = getxattr(f->f_path.dentry, name, value, size);
427 * Extended attribute LIST operations
430 listxattr(struct dentry *d, char __user *list, size_t size)
436 if (size > XATTR_LIST_MAX)
437 size = XATTR_LIST_MAX;
438 klist = kmalloc(size, GFP_KERNEL);
443 error = vfs_listxattr(d, klist, size);
445 if (size && copy_to_user(list, klist, error))
447 } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
448 /* The file system tried to returned a list bigger
449 than XATTR_LIST_MAX bytes. Not possible. */
456 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
462 error = user_path(pathname, &path);
465 error = listxattr(path.dentry, list, size);
470 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
476 error = user_lpath(pathname, &path);
479 error = listxattr(path.dentry, list, size);
484 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
487 ssize_t error = -EBADF;
492 audit_inode(NULL, f->f_path.dentry);
493 error = listxattr(f->f_path.dentry, list, size);
499 * Extended attribute REMOVE operations
502 removexattr(struct dentry *d, const char __user *name)
505 char kname[XATTR_NAME_MAX + 1];
507 error = strncpy_from_user(kname, name, sizeof(kname));
508 if (error == 0 || error == sizeof(kname))
513 return vfs_removexattr(d, kname);
516 SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
517 const char __user *, name)
522 error = user_path(pathname, &path);
525 error = mnt_want_write(path.mnt);
527 error = removexattr(path.dentry, name);
528 mnt_drop_write(path.mnt);
534 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
535 const char __user *, name)
540 error = user_lpath(pathname, &path);
543 error = mnt_want_write(path.mnt);
545 error = removexattr(path.dentry, name);
546 mnt_drop_write(path.mnt);
552 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
555 struct dentry *dentry;
561 dentry = f->f_path.dentry;
562 audit_inode(NULL, dentry);
563 error = mnt_want_write_file(f);
565 error = removexattr(dentry, name);
566 mnt_drop_write(f->f_path.mnt);
574 strcmp_prefix(const char *a, const char *a_prefix)
576 while (*a_prefix && *a == *a_prefix) {
580 return *a_prefix ? NULL : a;
584 * In order to implement different sets of xattr operations for each xattr
585 * prefix with the generic xattr API, a filesystem should create a
586 * null-terminated array of struct xattr_handler (one for each prefix) and
587 * hang a pointer to it off of the s_xattr field of the superblock.
589 * The generic_fooxattr() functions will use this list to dispatch xattr
590 * operations to the correct xattr_handler.
592 #define for_each_xattr_handler(handlers, handler) \
593 for ((handler) = *(handlers)++; \
595 (handler) = *(handlers)++)
598 * Find the xattr_handler with the matching prefix.
600 static const struct xattr_handler *
601 xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
603 const struct xattr_handler *handler;
608 for_each_xattr_handler(handlers, handler) {
609 const char *n = strcmp_prefix(*name, handler->prefix);
619 * Find the handler for the prefix and dispatch its get() operation.
622 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
624 const struct xattr_handler *handler;
626 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
629 return handler->get(dentry, name, buffer, size, handler->flags);
633 * Combine the results of the list() operation from every xattr_handler in the
637 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
639 const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
640 unsigned int size = 0;
643 for_each_xattr_handler(handlers, handler) {
644 size += handler->list(dentry, NULL, 0, NULL, 0,
650 for_each_xattr_handler(handlers, handler) {
651 size = handler->list(dentry, buf, buffer_size,
652 NULL, 0, handler->flags);
653 if (size > buffer_size)
664 * Find the handler for the prefix and dispatch its set() operation.
667 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
669 const struct xattr_handler *handler;
672 value = ""; /* empty EA, do not remove */
673 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
676 return handler->set(dentry, name, value, size, flags, handler->flags);
680 * Find the handler for the prefix and dispatch its set() operation to remove
681 * any associated extended attribute.
684 generic_removexattr(struct dentry *dentry, const char *name)
686 const struct xattr_handler *handler;
688 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
691 return handler->set(dentry, name, NULL, 0,
692 XATTR_REPLACE, handler->flags);
695 EXPORT_SYMBOL(generic_getxattr);
696 EXPORT_SYMBOL(generic_listxattr);
697 EXPORT_SYMBOL(generic_setxattr);
698 EXPORT_SYMBOL(generic_removexattr);