cregit-Linux how code gets into the kernel

Release 4.11 fs/xattr.c

Directory: fs
/*
  File: fs/xattr.c

  Extended attribute handling.

  Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
  Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
  Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
 */
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/xattr.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/security.h>
#include <linux/evm.h>
#include <linux/syscalls.h>
#include <linux/export.h>
#include <linux/fsnotify.h>
#include <linux/audit.h>
#include <linux/vmalloc.h>
#include <linux/posix_acl_xattr.h>

#include <linux/uaccess.h>


static const char * strcmp_prefix(const char *a, const char *a_prefix) { while (*a_prefix && *a == *a_prefix) { a++; a_prefix++; } return *a_prefix ? NULL : a; }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher45100.00%1100.00%
Total45100.00%1100.00%

/* * In order to implement different sets of xattr operations for each xattr * prefix, a filesystem should create a null-terminated array of struct * xattr_handler (one for each prefix) and hang a pointer to it off of the * s_xattr field of the superblock. */ #define for_each_xattr_handler(handlers, handler) \ if (handlers) \ for ((handler) = *(handlers)++; \ (handler) != NULL; \ (handler) = *(handlers)++) /* * Find the xattr_handler with the matching prefix. */
static const struct xattr_handler * xattr_resolve_name(struct inode *inode, const char **name) { const struct xattr_handler **handlers = inode->i_sb->s_xattr; const struct xattr_handler *handler; if (!(inode->i_opflags & IOP_XATTR)) { if (unlikely(is_bad_inode(inode))) return ERR_PTR(-EIO); return ERR_PTR(-EOPNOTSUPP); } for_each_xattr_handler(handlers, handler) { const char *n; n = strcmp_prefix(*name, xattr_prefix(handler)); if (n) { if (!handler->prefix ^ !*n) { if (*n) continue; return ERR_PTR(-EINVAL); } *name = n; return handler; } } return ERR_PTR(-EOPNOTSUPP); }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher149100.00%3100.00%
Total149100.00%3100.00%

/* * Check permissions for extended attribute access. This is a bit complicated * because different namespaces have very different rules. */
static int xattr_permission(struct inode *inode, const char *name, int mask) { /* * We can never set or remove an extended attribute on a read-only * filesystem or on an immutable / append-only inode. */ if (mask & MAY_WRITE) { if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) return -EPERM; /* * Updating an xattr will likely cause i_uid and i_gid * to be writen back improperly if their true value is * unknown to the vfs. */ if (HAS_UNMAPPED_ID(inode)) return -EPERM; } /* * No restriction for security.* and system.* from the VFS. Decision * on these is left to the underlying filesystem / security module. */ if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) || !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) return 0; /* * The trusted.* namespace can only be accessed by privileged users. */ if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) { if (!capable(CAP_SYS_ADMIN)) return (mask & MAY_WRITE) ? -EPERM : -ENODATA; return 0; } /* * In the user.* namespace, only regular files and directories can have * extended attributes. For sticky directories, only the owner and * privileged users can write attributes. */ if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) { if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode)) return (mask & MAY_WRITE) ? -EPERM : -ENODATA; if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) && (mask & MAY_WRITE) && !inode_owner_or_capable(inode)) return -EPERM; } return inode_permission(inode, mask); }

Contributors

PersonTokensPropCommitsCommitProp
Andrew Morton13966.83%114.29%
Andreas Gruenbacher5425.96%228.57%
Eric W. Biedermann125.77%114.29%
Serge E. Hallyn10.48%114.29%
Al Viro10.48%114.29%
Satyam Sharma10.48%114.29%
Total208100.00%7100.00%


int __vfs_setxattr(struct dentry *dentry, struct inode *inode, const char *name, const void *value, size_t size, int flags) { const struct xattr_handler *handler; handler = xattr_resolve_name(inode, &name); if (IS_ERR(handler)) return PTR_ERR(handler); if (!handler->set) return -EOPNOTSUPP; if (size == 0) value = ""; /* empty EA, do not remove */ return handler->set(handler, dentry, inode, name, value, size, flags); }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher102100.00%2100.00%
Total102100.00%2100.00%

EXPORT_SYMBOL(__vfs_setxattr); /** * __vfs_setxattr_noperm - perform setxattr operation without performing * permission checks. * * @dentry - object to perform setxattr on * @name - xattr name to set * @value - value to set @name to * @size - size of @value * @flags - flags to pass into filesystem operations * * returns the result of the internal setxattr or setsecurity operations. * * This function requires the caller to lock the inode's i_mutex before it * is executed. It also assumes that the caller will make the appropriate * permission checks. */
int __vfs_setxattr_noperm(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = -EAGAIN; int issec = !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN); if (issec) inode->i_flags &= ~S_NOSEC; if (inode->i_opflags & IOP_XATTR) { error = __vfs_setxattr(dentry, inode, name, value, size, flags); if (!error) { fsnotify_xattr(dentry); security_inode_post_setxattr(dentry, name, value, size, flags); } } else { if (unlikely(is_bad_inode(inode))) return -EIO; } if (error == -EAGAIN) { error = -EOPNOTSUPP; if (issec) { const char *suffix = name + XATTR_SECURITY_PREFIX_LEN; error = security_inode_setsecurity(inode, suffix, value, size, flags); if (!error) fsnotify_xattr(dentry); } } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig10756.02%111.11%
Andreas Gruenbacher4925.65%444.44%
Andi Kleen2412.57%111.11%
David P. Quigley73.66%111.11%
David Howells21.05%111.11%
Al Viro21.05%111.11%
Total191100.00%9100.00%


int vfs_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error; error = xattr_permission(inode, name, MAY_WRITE); if (error) return error; inode_lock(inode); error = security_inode_setxattr(dentry, name, value, size, flags); if (error) goto out; error = __vfs_setxattr_noperm(dentry, name, value, size, flags); out: inode_unlock(inode); return error; }

Contributors

PersonTokensPropCommitsCommitProp
David P. Quigley9688.89%133.33%
Christoph Hellwig109.26%133.33%
Al Viro21.85%133.33%
Total108100.00%3100.00%

EXPORT_SYMBOL_GPL(vfs_setxattr);
ssize_t xattr_getsecurity(struct inode *inode, const char *name, void *value, size_t size) { void *buffer = NULL; ssize_t len; if (!value || !size) { len = security_inode_getsecurity(inode, name, &buffer, false); goto out_noalloc; } len = security_inode_getsecurity(inode, name, &buffer, true); if (len < 0) return len; if (size < len) { len = -ERANGE; goto out; } memcpy(value, buffer, len); out: security_release_secctx(buffer, len); out_noalloc: return len; }

Contributors

PersonTokensPropCommitsCommitProp
David P. Quigley11999.17%150.00%
Christoph Hellwig10.83%150.00%
Total120100.00%2100.00%

EXPORT_SYMBOL_GPL(xattr_getsecurity); /* * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr * * Allocate memory, if not already allocated, or re-allocate correct size, * before retrieving the extended attribute. * * Returns the result of alloc, if failed, or the getxattr operation. */
ssize_t vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value, size_t xattr_size, gfp_t flags) { const struct xattr_handler *handler; struct inode *inode = dentry->d_inode; char *value = *xattr_value; int error; error = xattr_permission(inode, name, MAY_READ); if (error) return error; handler = xattr_resolve_name(inode, &name); if (IS_ERR(handler)) return PTR_ERR(handler); if (!handler->get) return -EOPNOTSUPP; error = handler->get(handler, dentry, inode, name, NULL, 0); if (error < 0) return error; if (!value || (error > xattr_size)) { value = krealloc(*xattr_value, error + 1, flags); if (!value) return -ENOMEM; memset(value, 0, error + 1); } error = handler->get(handler, dentry, inode, name, value, error); *xattr_value = value; return error; }

Contributors

PersonTokensPropCommitsCommitProp
Mimi Zohar16279.02%133.33%
Andreas Gruenbacher3919.02%133.33%
Al Viro41.95%133.33%
Total205100.00%3100.00%


ssize_t __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name, void *value, size_t size) { const struct xattr_handler *handler; handler = xattr_resolve_name(inode, &name); if (IS_ERR(handler)) return PTR_ERR(handler); if (!handler->get) return -EOPNOTSUPP; return handler->get(handler, dentry, inode, name, value, size); }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher8498.82%266.67%
David P. Quigley11.18%133.33%
Total85100.00%3100.00%

EXPORT_SYMBOL(__vfs_getxattr);
ssize_t vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size) { struct inode *inode = dentry->d_inode; int error; error = xattr_permission(inode, name, MAY_READ); if (error) return error; error = security_inode_getxattr(dentry, name); if (error) return error; if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) { const char *suffix = name + XATTR_SECURITY_PREFIX_LEN; int ret = xattr_getsecurity(inode, suffix, value, size); /* * Only overwrite the return value if a security module * is actually active. */ if (ret == -EOPNOTSUPP) goto nolsm; return ret; } nolsm: return __vfs_getxattr(dentry, inode, name, value, size); }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig8965.93%114.29%
David P. Quigley2014.81%228.57%
Andrew Morton2014.81%114.29%
Andreas Gruenbacher32.22%114.29%
Al Viro21.48%114.29%
David Howells10.74%114.29%
Total135100.00%7100.00%

EXPORT_SYMBOL_GPL(vfs_getxattr);
ssize_t vfs_listxattr(struct dentry *dentry, char *list, size_t size) { struct inode *inode = d_inode(dentry); ssize_t error; error = security_inode_listxattr(dentry); if (error) return error; if (inode->i_op->listxattr && (inode->i_opflags & IOP_XATTR)) { error = -EOPNOTSUPP; error = inode->i_op->listxattr(dentry, list, size); } else { error = security_inode_listsecurity(inode, list, size); if (size && error > size) error = -ERANGE; } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Bill Nottingham8374.11%150.00%
Andreas Gruenbacher2925.89%150.00%
Total112100.00%2100.00%

EXPORT_SYMBOL_GPL(vfs_listxattr);
int __vfs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = d_inode(dentry); const struct xattr_handler *handler; handler = xattr_resolve_name(inode, &name); if (IS_ERR(handler)) return PTR_ERR(handler); if (!handler->set) return -EOPNOTSUPP; return handler->set(handler, dentry, inode, name, NULL, 0, XATTR_REPLACE); }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher5665.88%250.00%
Christoph Hellwig2832.94%125.00%
David Howells11.18%125.00%
Total85100.00%4100.00%

EXPORT_SYMBOL(__vfs_removexattr);
int vfs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error; error = xattr_permission(inode, name, MAY_WRITE); if (error) return error; inode_lock(inode); error = security_inode_removexattr(dentry, name); if (error) goto out; error = __vfs_removexattr(dentry, name); if (!error) { fsnotify_xattr(dentry); evm_inode_post_removexattr(dentry, name); } out: inode_unlock(inode); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig3533.65%114.29%
Andreas Gruenbacher2725.96%114.29%
Andrew Morton1817.31%114.29%
Mimi Zohar1312.50%228.57%
Dmitry Kasatkin98.65%114.29%
Al Viro21.92%114.29%
Total104100.00%7100.00%

EXPORT_SYMBOL_GPL(vfs_removexattr); /* * Extended attribute SET operations */
static long setxattr(struct dentry *d, const char __user *name, const void __user *value, size_t size, int flags) { int error; void *kvalue = NULL; char kname[XATTR_NAME_MAX + 1]; if (flags & ~(XATTR_CREATE|XATTR_REPLACE)) return -EINVAL; error = strncpy_from_user(kname, name, sizeof(kname)); if (error == 0 || error == sizeof(kname)) error = -ERANGE; if (error < 0) return error; if (size) { if (size > XATTR_SIZE_MAX) return -E2BIG; kvalue = kmalloc(size, GFP_KERNEL | __GFP_NOWARN); if (!kvalue) { kvalue = vmalloc(size); if (!kvalue) return -ENOMEM; } if (copy_from_user(kvalue, value, size)) { error = -EFAULT; goto out; } if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) || (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0)) posix_acl_fix_xattr_from_user(kvalue, size); } error = vfs_setxattr(d, kname, kvalue, size, flags); out: kvfree(kvalue); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds7834.06%19.09%
Andrew Morton5724.89%218.18%
Nathan Scott3213.97%19.09%
Eric W. Biedermann3113.54%19.09%
Stephen D. Smalley156.55%19.09%
Christoph Hellwig73.06%19.09%
Richard Weinberger31.31%19.09%
Andries E. Brouwer20.87%19.09%
Li Zefan20.87%19.09%
David Howells20.87%19.09%
Total229100.00%11100.00%


static int path_setxattr(const char __user *pathname, const char __user *name, const void __user *value, size_t size, int flags, unsigned int lookup_flags) { struct path path; int error; retry: error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); if (error) return error; error = mnt_want_write(path.mnt); if (!error) { error = setxattr(path.dentry, name, value, size, flags); mnt_drop_write(path.mnt); } path_put(&path); if (retry_estale(error, lookup_flags)) { lookup_flags |= LOOKUP_REVAL; goto retry; } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds4332.82%114.29%
Eric Biggers3224.43%114.29%
Jeff Layton2519.08%114.29%
Dave Hansen2317.56%114.29%
Jan Blunck43.05%228.57%
Al Viro43.05%114.29%
Total131100.00%7100.00%

SYSCALL_DEFINE5(setxattr, const char __user *, pathname, const char __user *, name, const void __user *, value, size_t, size, int, flags) { return path_setxattr(pathname, name, value, size, flags, LOOKUP_FOLLOW); } SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname, const char __user *, name, const void __user *, value, size_t, size, int, flags) { return path_setxattr(pathname, name, value, size, flags, 0); } SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name, const void __user *,value, size_t, size, int, flags) { struct fd f = fdget(fd); int error = -EBADF; if (!f.file) return error; audit_file(f.file); error = mnt_want_write_file(f.file); if (!error) { error = setxattr(f.file->f_path.dentry, name, value, size, flags); mnt_drop_write_file(f.file); } fdput(f); return error; } /* * Extended attribute GET operations */
static ssize_t getxattr(struct dentry *d, const char __user *name, void __user *value, size_t size) { ssize_t error; void *kvalue = NULL; char kname[XATTR_NAME_MAX + 1]; error = strncpy_from_user(kname, name, sizeof(kname)); if (error == 0 || error == sizeof(kname)) error = -ERANGE; if (error < 0) return error; if (size) { if (size > XATTR_SIZE_MAX) size = XATTR_SIZE_MAX; kvalue = kzalloc(size, GFP_KERNEL | __GFP_NOWARN); if (!kvalue) { kvalue = vmalloc(size); if (!kvalue) return -ENOMEM; } } error = vfs_getxattr(d, kname, kvalue, size); if (error > 0) { if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) || (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0)) posix_acl_fix_xattr_to_user(kvalue, size); if (size && copy_to_user(value, kvalue, error)) error = -EFAULT; } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) { /* The file system tried to returned a value bigger than XATTR_SIZE_MAX bytes. Not possible. */ error = -E2BIG; } kvfree(kvalue); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds8536.80%16.25%
Andrew Morton4519.48%212.50%
Nathan Scott3515.15%318.75%
Eric W. Biedermann3113.42%16.25%
Sasha Levin146.06%16.25%
Stephen D. Smalley104.33%212.50%
Richard Weinberger31.30%16.25%
Greg Kroah-Hartman31.30%16.25%
Andries E. Brouwer20.87%16.25%
James Morris10.43%16.25%
Christoph Hellwig10.43%16.25%
David Howells10.43%16.25%
Total231100.00%16100.00%


static ssize_t path_getxattr(const char __user *pathname, const char __user *name, void __user *value, size_t size, unsigned int lookup_flags) { struct path path; ssize_t error; retry: error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); if (error) return error; error = getxattr(path.dentry, name, value, size); path_put(&path); if (retry_estale(error, lookup_flags)) { lookup_flags |= LOOKUP_REVAL; goto retry; } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds4039.22%114.29%
Eric Biggers2827.45%114.29%
Jeff Layton2524.51%114.29%
Jan Blunck43.92%228.57%
Al Viro43.92%114.29%
Nathan Scott10.98%114.29%
Total102100.00%7100.00%

SYSCALL_DEFINE4(getxattr, const char __user *, pathname, const char __user *, name, void __user *, value, size_t, size) { return path_getxattr(pathname, name, value, size, LOOKUP_FOLLOW); } SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname, const char __user *, name, void __user *, value, size_t, size) { return path_getxattr(pathname, name, value, size, 0); } SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name, void __user *, value, size_t, size) { struct fd f = fdget(fd); ssize_t error = -EBADF; if (!f.file) return error; audit_file(f.file); error = getxattr(f.file->f_path.dentry, name, value, size); fdput(f); return error; } /* * Extended attribute LIST operations */
static ssize_t listxattr(struct dentry *d, char __user *list, size_t size) { ssize_t error; char *klist = NULL; if (size) { if (size > XATTR_LIST_MAX) size = XATTR_LIST_MAX; klist = kmalloc(size, __GFP_NOWARN | GFP_KERNEL); if (!klist) { klist = vmalloc(size); if (!klist) return -ENOMEM; } } error = vfs_listxattr(d, klist, size); if (error > 0) { if (size && copy_to_user(list, klist, error)) error = -EFAULT; } else if (error == -ERANGE && size >= XATTR_LIST_MAX) { /* The file system tried to returned a list bigger than XATTR_LIST_MAX bytes. Not possible. */ error = -E2BIG; } kvfree(klist); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds6444.76%19.09%
Andrew Morton5840.56%327.27%
Stephen D. Smalley117.69%19.09%
Nathan Scott32.10%218.18%
Richard Weinberger32.10%19.09%
Dave Jones21.40%19.09%
Bill Nottingham10.70%19.09%
Andries E. Brouwer10.70%19.09%
Total143100.00%11100.00%


static ssize_t path_listxattr(const char __user *pathname, char __user *list, size_t size, unsigned int lookup_flags) { struct path path; ssize_t error; retry: error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); if (error) return error; error = listxattr(path.dentry, list, size); path_put(&path); if (retry_estale(error, lookup_flags)) { lookup_flags |= LOOKUP_REVAL; goto retry; } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds3840.43%114.29%
Jeff Layton2526.60%114.29%
Eric Biggers2223.40%114.29%
Jan Blunck44.26%228.57%
Al Viro44.26%114.29%
Nathan Scott11.06%114.29%
Total94100.00%7100.00%

SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list, size_t, size) { return path_listxattr(pathname, list, size, LOOKUP_FOLLOW); } SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list, size_t, size) { return path_listxattr(pathname, list, size, 0); } SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size) { struct fd f = fdget(fd); ssize_t error = -EBADF; if (!f.file) return error; audit_file(f.file); error = listxattr(f.file->f_path.dentry, list, size); fdput(f); return error; } /* * Extended attribute REMOVE operations */
static long removexattr(struct dentry *d, const char __user *name) { int error; char kname[XATTR_NAME_MAX + 1]; error = strncpy_from_user(kname, name, sizeof(kname)); if (error == 0 || error == sizeof(kname)) error = -ERANGE; if (error < 0) return error; return vfs_removexattr(d, kname); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds4153.25%120.00%
Nathan Scott3241.56%120.00%
Christoph Hellwig22.60%120.00%
Andries E. Brouwer11.30%120.00%
David Howells11.30%120.00%
Total77100.00%5100.00%


static int path_removexattr(const char __user *pathname, const char __user *name, unsigned int lookup_flags) { struct path path; int error; retry: error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path); if (error) return error; error = mnt_want_write(path.mnt); if (!error) { error = removexattr(path.dentry, name); mnt_drop_write(path.mnt); } path_put(&path); if (retry_estale(error, lookup_flags)) { lookup_flags |= LOOKUP_REVAL; goto retry; } return error; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds3732.74%114.29%
Jeff Layton2522.12%114.29%
Dave Hansen2320.35%114.29%
Eric Biggers2017.70%114.29%
Al Viro43.54%114.29%
Jan Blunck43.54%228.57%
Total113100.00%7100.00%

SYSCALL_DEFINE2(removexattr, const char __user *, pathname, const char __user *, name) { return path_removexattr(pathname, name, LOOKUP_FOLLOW); } SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname, const char __user *, name) { return path_removexattr(pathname, name, 0); } SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name) { struct fd f = fdget(fd); int error = -EBADF; if (!f.file) return error; audit_file(f.file); error = mnt_want_write_file(f.file); if (!error) { error = removexattr(f.file->f_path.dentry, name); mnt_drop_write_file(f.file); } fdput(f); return error; } /* * Combine the results of the list() operation from every xattr_handler in the * list. */
ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size) { const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr; unsigned int size = 0; if (!buffer) { for_each_xattr_handler(handlers, handler) { if (!handler->name || (handler->list && !handler->list(dentry))) continue; size += strlen(handler->name) + 1; } } else { char *buf = buffer; size_t len; for_each_xattr_handler(handlers, handler) { if (!handler->name || (handler->list && !handler->list(dentry))) continue; len = strlen(handler->name); if (len + 1 > buffer_size) return -ERANGE; memcpy(buf, handler->name, len + 1); buf += len + 1; buffer_size -= len + 1; } size = buf - buffer; } return size; }

Contributors

PersonTokensPropCommitsCommitProp
James Morris10154.89%116.67%
Andreas Gruenbacher7741.85%350.00%
Christoph Hellwig52.72%116.67%
Stephen Hemminger10.54%116.67%
Total184100.00%6100.00%

EXPORT_SYMBOL(generic_listxattr); /** * xattr_full_name - Compute full attribute name from suffix * * @handler: handler of the xattr_handler operation * @name: name passed to the xattr_handler operation * * The get and set xattr handler operations are called with the remainder of * the attribute name after skipping the handler's prefix: for example, "foo" * is passed to the get operation of a handler with prefix "user." to get * attribute "user.foo". The full name is still "there" in the name though. * * Note: the list xattr handler operation when called from the vfs is passed a * NULL name; some file systems use this operation internally, with varying * semantics. */
const char *xattr_full_name(const struct xattr_handler *handler, const char *name) { size_t prefix_len = strlen(xattr_prefix(handler)); return name - prefix_len; }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher34100.00%2100.00%
Total34100.00%2100.00%

EXPORT_SYMBOL(xattr_full_name); /* * Allocate new xattr and copy in the value; but leave the name to callers. */
struct simple_xattr *simple_xattr_alloc(const void *value, size_t size) { struct simple_xattr *new_xattr; size_t len; /* wrap around? */ len = sizeof(*new_xattr) + size; if (len < sizeof(*new_xattr)) return NULL; new_xattr = kmalloc(len, GFP_KERNEL); if (!new_xattr) return NULL; new_xattr->size = size; memcpy(new_xattr->value, value, size); return new_xattr; }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho8398.81%150.00%
Hugh Dickins11.19%150.00%
Total84100.00%2100.00%

/* * xattr GET operation for in-memory/pseudo filesystems */
int simple_xattr_get(struct simple_xattrs *xattrs, const char *name, void *buffer, size_t size) { struct simple_xattr *xattr; int ret = -ENODATA; spin_lock(&xattrs->lock); list_for_each_entry(xattr, &xattrs->head, list) { if (strcmp(name, xattr->name)) continue; ret = xattr->size; if (buffer) { if (size < xattr->size) ret = -ERANGE; else memcpy(buffer, xattr->value, xattr->size); } break; } spin_unlock(&xattrs->lock); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho114100.00%1100.00%
Total114100.00%1100.00%

/** * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems * @xattrs: target simple_xattr list * @name: name of the extended attribute * @value: value of the xattr. If %NULL, will remove the attribute. * @size: size of the new xattr * @flags: %XATTR_{CREATE|REPLACE} * * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails * with -EEXIST. If %XATTR_REPLACE is set, the xattr should exist; * otherwise, fails with -ENODATA. * * Returns 0 on success, -errno on failure. */
int simple_xattr_set(struct simple_xattrs *xattrs, const char *name, const void *value, size_t size, int flags) { struct simple_xattr *xattr; struct simple_xattr *new_xattr = NULL; int err = 0; /* value == NULL means remove */ if (value) { new_xattr = simple_xattr_alloc(value, size); if (!new_xattr) return -ENOMEM; new_xattr->name = kstrdup(name, GFP_KERNEL); if (!new_xattr->name) { kfree(new_xattr); return -ENOMEM; } } spin_lock(&xattrs->lock); list_for_each_entry(xattr, &xattrs->head, list) { if (!strcmp(name, xattr->name)) { if (flags & XATTR_CREATE) { xattr = new_xattr; err = -EEXIST; } else if (new_xattr) { list_replace(&xattr->list, &new_xattr->list); } else { list_del(&xattr->list); } goto out; } } if (flags & XATTR_REPLACE) { xattr = new_xattr; err = -ENODATA; } else { list_add(&new_xattr->list, &xattrs->head); xattr = NULL; } out: spin_unlock(&xattrs->lock); if (xattr) { kfree(xattr->name); kfree(xattr); } return err; }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho24598.79%133.33%
David Rientjes20.81%133.33%
Andreas Gruenbacher10.40%133.33%
Total248100.00%3100.00%


static bool xattr_is_trusted(const char *name) { return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN); }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho22100.00%1100.00%
Total22100.00%1100.00%


static int xattr_list_one(char **buffer, ssize_t *remaining_size, const char *name) { size_t len = strlen(name) + 1; if (*buffer) { if (*remaining_size < len) return -ERANGE; memcpy(*buffer, name, len); *buffer += len; } *remaining_size -= len; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher71100.00%1100.00%
Total71100.00%1100.00%

/* * xattr LIST operation for in-memory/pseudo filesystems */
ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs, char *buffer, size_t size) { bool trusted = capable(CAP_SYS_ADMIN); struct simple_xattr *xattr; ssize_t remaining_size = size; int err = 0; #ifdef CONFIG_FS_POSIX_ACL if (inode->i_acl) { err = xattr_list_one(&buffer, &remaining_size, XATTR_NAME_POSIX_ACL_ACCESS); if (err) return err; } if (inode->i_default_acl) { err = xattr_list_one(&buffer, &remaining_size, XATTR_NAME_POSIX_ACL_DEFAULT); if (err) return err; } #endif spin_lock(&xattrs->lock); list_for_each_entry(xattr, &xattrs->head, list) { /* skip "trusted." attributes for unprivileged callers */ if (!trusted && xattr_is_trusted(xattr->name)) continue; err = xattr_list_one(&buffer, &remaining_size, xattr->name); if (err) break; } spin_unlock(&xattrs->lock); return err ? err : size - remaining_size; }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho8448.00%133.33%
Andreas Gruenbacher8448.00%133.33%
Mateusz Guzik74.00%133.33%
Total175100.00%3100.00%

/* * Adds an extended attribute to the list */
void simple_xattr_list_add(struct simple_xattrs *xattrs, struct simple_xattr *new_xattr) { spin_lock(&xattrs->lock); list_add(&new_xattr->list, &xattrs->head); spin_unlock(&xattrs->lock); }

Contributors

PersonTokensPropCommitsCommitProp
Aristeu Sergio Rozanski Filho44100.00%1100.00%
Total44100.00%1100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Andreas Gruenbacher93820.90%1617.98%
Linus Torvalds64014.26%22.25%
Aristeu Sergio Rozanski Filho59613.28%22.25%
Andrew Morton3417.60%55.62%
Christoph Hellwig3036.75%33.37%
David P. Quigley2495.55%33.37%
Eric Biggers2244.99%11.12%
Mimi Zohar1793.99%33.37%
Heiko Carstens1403.12%22.25%
Jeff Layton1132.52%88.99%
James Morris1112.47%22.25%
Al Viro1092.43%88.99%
Nathan Scott1062.36%33.37%
Dave Hansen891.98%11.12%
Bill Nottingham891.98%11.12%
Eric W. Biedermann771.72%22.25%
Stephen D. Smalley360.80%22.25%
Amy Griffis250.56%22.25%
Andi Kleen240.53%11.12%
Jan Blunck160.36%22.25%
Sasha Levin140.31%11.12%
Richard Weinberger90.20%11.12%
Dmitry Kasatkin90.20%11.12%
David Howells80.18%11.12%
Mateusz Guzik70.16%11.12%
Greg Kroah-Hartman60.13%22.25%
Josef 'Jeff' Sipek60.13%11.12%
Andries E. Brouwer60.13%11.12%
Robert Love30.07%11.12%
Arnd Bergmann30.07%11.12%
David Rientjes20.04%11.12%
Dave Jones20.04%11.12%
Nicholas Piggin20.04%11.12%
Li Zefan20.04%11.12%
Hugh Dickins10.02%11.12%
Serge E. Hallyn10.02%11.12%
Satyam Sharma10.02%11.12%
Paul Gortmaker10.02%11.12%
Stephen Hemminger10.02%11.12%
Total4489100.00%89100.00%
Directory: fs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.