blob: 46f87e828b484ebabf84422150eb8b9938481971 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 File: fs/xattr.c
3
4 Extended attribute handling.
5
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>
9 */
10#include <linux/fs.h>
11#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/file.h>
13#include <linux/xattr.h>
Dave Hansen18f335a2008-02-15 14:37:38 -080014#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/namei.h>
16#include <linux/security.h>
17#include <linux/syscalls.h>
18#include <linux/module.h>
Robert Love0eeca282005-07-12 17:06:03 -040019#include <linux/fsnotify.h>
Amy Griffis73241cc2005-11-03 16:00:25 +000020#include <linux/audit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/uaccess.h>
22
Christoph Hellwig5be196e2006-01-09 20:51:55 -080023
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080024/*
25 * Check permissions for extended attribute access. This is a bit complicated
26 * because different namespaces have very different rules.
27 */
28static int
29xattr_permission(struct inode *inode, const char *name, int mask)
30{
31 /*
32 * We can never set or remove an extended attribute on a read-only
33 * filesystem or on an immutable / append-only inode.
34 */
35 if (mask & MAY_WRITE) {
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080036 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
37 return -EPERM;
38 }
39
40 /*
41 * No restriction for security.* and system.* from the VFS. Decision
42 * on these is left to the underlying filesystem / security module.
43 */
44 if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
45 !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
46 return 0;
47
48 /*
Andreas Gruenbacherf1f2d872006-11-02 22:07:29 -080049 * The trusted.* namespace can only be accessed by a privileged user.
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080050 */
51 if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
52 return (capable(CAP_SYS_ADMIN) ? 0 : -EPERM);
53
Andreas Gruenbacherf1f2d872006-11-02 22:07:29 -080054 /* In user.* namespace, only regular files and directories can have
55 * extended attributes. For sticky directories, only the owner and
56 * privileged user can write attributes.
57 */
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080058 if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
Andreas Gruenbacherf1f2d872006-11-02 22:07:29 -080059 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
60 return -EPERM;
61 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
Satyam Sharma3bd858a2007-07-17 15:00:08 +053062 (mask & MAY_WRITE) && !is_owner_or_cap(inode))
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080063 return -EPERM;
64 }
65
Al Virof419a2e2008-07-22 00:07:17 -040066 return inode_permission(inode, mask);
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080067}
68
David P. Quigleyb1ab7e42009-09-03 14:25:56 -040069/**
70 * __vfs_setxattr_noperm - perform setxattr operation without performing
71 * permission checks.
72 *
73 * @dentry - object to perform setxattr on
74 * @name - xattr name to set
75 * @value - value to set @name to
76 * @size - size of @value
77 * @flags - flags to pass into filesystem operations
78 *
79 * returns the result of the internal setxattr or setsecurity operations.
80 *
81 * This function requires the caller to lock the inode's i_mutex before it
82 * is executed. It also assumes that the caller will make the appropriate
83 * permission checks.
84 */
85int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
86 const void *value, size_t size, int flags)
Christoph Hellwig5be196e2006-01-09 20:51:55 -080087{
88 struct inode *inode = dentry->d_inode;
David P. Quigleyb1ab7e42009-09-03 14:25:56 -040089 int error = -EOPNOTSUPP;
Christoph Hellwig5be196e2006-01-09 20:51:55 -080090
Christoph Hellwig5be196e2006-01-09 20:51:55 -080091 if (inode->i_op->setxattr) {
92 error = inode->i_op->setxattr(dentry, name, value, size, flags);
93 if (!error) {
94 fsnotify_xattr(dentry);
95 security_inode_post_setxattr(dentry, name, value,
96 size, flags);
97 }
98 } else if (!strncmp(name, XATTR_SECURITY_PREFIX,
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080099 XATTR_SECURITY_PREFIX_LEN)) {
100 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800101 error = security_inode_setsecurity(inode, suffix, value,
102 size, flags);
103 if (!error)
104 fsnotify_xattr(dentry);
105 }
David P. Quigleyb1ab7e42009-09-03 14:25:56 -0400106
107 return error;
108}
109
110
111int
112vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
113 size_t size, int flags)
114{
115 struct inode *inode = dentry->d_inode;
116 int error;
117
118 error = xattr_permission(inode, name, MAY_WRITE);
119 if (error)
120 return error;
121
122 mutex_lock(&inode->i_mutex);
123 error = security_inode_setxattr(dentry, name, value, size, flags);
124 if (error)
125 goto out;
126
127 error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
128
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800129out:
130 mutex_unlock(&inode->i_mutex);
131 return error;
132}
133EXPORT_SYMBOL_GPL(vfs_setxattr);
134
135ssize_t
David P. Quigley42492592008-02-04 22:29:39 -0800136xattr_getsecurity(struct inode *inode, const char *name, void *value,
137 size_t size)
138{
139 void *buffer = NULL;
140 ssize_t len;
141
142 if (!value || !size) {
143 len = security_inode_getsecurity(inode, name, &buffer, false);
144 goto out_noalloc;
145 }
146
147 len = security_inode_getsecurity(inode, name, &buffer, true);
148 if (len < 0)
149 return len;
150 if (size < len) {
151 len = -ERANGE;
152 goto out;
153 }
154 memcpy(value, buffer, len);
155out:
156 security_release_secctx(buffer, len);
157out_noalloc:
158 return len;
159}
160EXPORT_SYMBOL_GPL(xattr_getsecurity);
161
162ssize_t
David Howells8f0cfa52008-04-29 00:59:41 -0700163vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800164{
165 struct inode *inode = dentry->d_inode;
166 int error;
167
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800168 error = xattr_permission(inode, name, MAY_READ);
169 if (error)
170 return error;
171
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800172 error = security_inode_getxattr(dentry, name);
173 if (error)
174 return error;
175
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800176 if (!strncmp(name, XATTR_SECURITY_PREFIX,
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800177 XATTR_SECURITY_PREFIX_LEN)) {
178 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
David P. Quigley42492592008-02-04 22:29:39 -0800179 int ret = xattr_getsecurity(inode, suffix, value, size);
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800180 /*
181 * Only overwrite the return value if a security module
182 * is actually active.
183 */
David P. Quigley4bea5802008-02-04 22:29:40 -0800184 if (ret == -EOPNOTSUPP)
185 goto nolsm;
186 return ret;
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800187 }
David P. Quigley4bea5802008-02-04 22:29:40 -0800188nolsm:
189 if (inode->i_op->getxattr)
190 error = inode->i_op->getxattr(dentry, name, value, size);
191 else
192 error = -EOPNOTSUPP;
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800193
194 return error;
195}
196EXPORT_SYMBOL_GPL(vfs_getxattr);
197
Bill Nottingham659564c2006-10-09 16:10:48 -0400198ssize_t
199vfs_listxattr(struct dentry *d, char *list, size_t size)
200{
201 ssize_t error;
202
203 error = security_inode_listxattr(d);
204 if (error)
205 return error;
206 error = -EOPNOTSUPP;
Al Viroacfa4382008-12-04 10:06:33 -0500207 if (d->d_inode->i_op->listxattr) {
Bill Nottingham659564c2006-10-09 16:10:48 -0400208 error = d->d_inode->i_op->listxattr(d, list, size);
209 } else {
210 error = security_inode_listsecurity(d->d_inode, list, size);
211 if (size && error > size)
212 error = -ERANGE;
213 }
214 return error;
215}
216EXPORT_SYMBOL_GPL(vfs_listxattr);
217
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800218int
David Howells8f0cfa52008-04-29 00:59:41 -0700219vfs_removexattr(struct dentry *dentry, const char *name)
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800220{
221 struct inode *inode = dentry->d_inode;
222 int error;
223
224 if (!inode->i_op->removexattr)
225 return -EOPNOTSUPP;
226
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800227 error = xattr_permission(inode, name, MAY_WRITE);
228 if (error)
229 return error;
230
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800231 error = security_inode_removexattr(dentry, name);
232 if (error)
233 return error;
234
235 mutex_lock(&inode->i_mutex);
236 error = inode->i_op->removexattr(dentry, name);
237 mutex_unlock(&inode->i_mutex);
238
239 if (!error)
240 fsnotify_xattr(dentry);
241 return error;
242}
243EXPORT_SYMBOL_GPL(vfs_removexattr);
244
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246/*
247 * Extended attribute SET operations
248 */
249static long
David Howells8f0cfa52008-04-29 00:59:41 -0700250setxattr(struct dentry *d, const char __user *name, const void __user *value,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 size_t size, int flags)
252{
253 int error;
254 void *kvalue = NULL;
255 char kname[XATTR_NAME_MAX + 1];
256
257 if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
258 return -EINVAL;
259
260 error = strncpy_from_user(kname, name, sizeof(kname));
261 if (error == 0 || error == sizeof(kname))
262 error = -ERANGE;
263 if (error < 0)
264 return error;
265
266 if (size) {
267 if (size > XATTR_SIZE_MAX)
268 return -E2BIG;
Li Zefan3939fcd2009-04-08 15:06:12 +0800269 kvalue = memdup_user(value, size);
270 if (IS_ERR(kvalue))
271 return PTR_ERR(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
273
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800274 error = vfs_setxattr(d, kname, kvalue, size, flags);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800275 kfree(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return error;
277}
278
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100279SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
280 const char __user *, name, const void __user *, value,
281 size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
Al Viro2d8f3032008-07-22 09:59:21 -0400283 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 int error;
285
Al Viro2d8f3032008-07-22 09:59:21 -0400286 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 if (error)
288 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400289 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800290 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400291 error = setxattr(path.dentry, name, value, size, flags);
292 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800293 }
Al Viro2d8f3032008-07-22 09:59:21 -0400294 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 return error;
296}
297
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100298SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
299 const char __user *, name, const void __user *, value,
300 size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301{
Al Viro2d8f3032008-07-22 09:59:21 -0400302 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 int error;
304
Al Viro2d8f3032008-07-22 09:59:21 -0400305 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (error)
307 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400308 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800309 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400310 error = setxattr(path.dentry, name, value, size, flags);
311 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800312 }
Al Viro2d8f3032008-07-22 09:59:21 -0400313 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 return error;
315}
316
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100317SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
318 const void __user *,value, size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
320 struct file *f;
Amy Griffis73241cc2005-11-03 16:00:25 +0000321 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 int error = -EBADF;
323
324 f = fget(fd);
325 if (!f)
326 return error;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800327 dentry = f->f_path.dentry;
Al Viro5a190ae2007-06-07 12:19:32 -0400328 audit_inode(NULL, dentry);
npiggin@suse.de96029c42009-04-26 20:25:55 +1000329 error = mnt_want_write_file(f);
Dave Hansen18f335a2008-02-15 14:37:38 -0800330 if (!error) {
331 error = setxattr(dentry, name, value, size, flags);
332 mnt_drop_write(f->f_path.mnt);
333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 fput(f);
335 return error;
336}
337
338/*
339 * Extended attribute GET operations
340 */
341static ssize_t
David Howells8f0cfa52008-04-29 00:59:41 -0700342getxattr(struct dentry *d, const char __user *name, void __user *value,
343 size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344{
345 ssize_t error;
346 void *kvalue = NULL;
347 char kname[XATTR_NAME_MAX + 1];
348
349 error = strncpy_from_user(kname, name, sizeof(kname));
350 if (error == 0 || error == sizeof(kname))
351 error = -ERANGE;
352 if (error < 0)
353 return error;
354
355 if (size) {
356 if (size > XATTR_SIZE_MAX)
357 size = XATTR_SIZE_MAX;
James Morrisd381d8a2005-10-30 14:59:22 -0800358 kvalue = kzalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (!kvalue)
360 return -ENOMEM;
361 }
362
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800363 error = vfs_getxattr(d, kname, kvalue, size);
Stephen Smalleyf549d6c2005-09-03 15:55:18 -0700364 if (error > 0) {
365 if (size && copy_to_user(value, kvalue, error))
366 error = -EFAULT;
367 } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
368 /* The file system tried to returned a value bigger
369 than XATTR_SIZE_MAX bytes. Not possible. */
370 error = -E2BIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800372 kfree(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 return error;
374}
375
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100376SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
377 const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Al Viro2d8f3032008-07-22 09:59:21 -0400379 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 ssize_t error;
381
Al Viro2d8f3032008-07-22 09:59:21 -0400382 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (error)
384 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400385 error = getxattr(path.dentry, name, value, size);
386 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 return error;
388}
389
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100390SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
391 const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Al Viro2d8f3032008-07-22 09:59:21 -0400393 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 ssize_t error;
395
Al Viro2d8f3032008-07-22 09:59:21 -0400396 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (error)
398 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400399 error = getxattr(path.dentry, name, value, size);
400 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return error;
402}
403
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100404SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
405 void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 struct file *f;
408 ssize_t error = -EBADF;
409
410 f = fget(fd);
411 if (!f)
412 return error;
Al Viro5a190ae2007-06-07 12:19:32 -0400413 audit_inode(NULL, f->f_path.dentry);
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800414 error = getxattr(f->f_path.dentry, name, value, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 fput(f);
416 return error;
417}
418
419/*
420 * Extended attribute LIST operations
421 */
422static ssize_t
423listxattr(struct dentry *d, char __user *list, size_t size)
424{
425 ssize_t error;
426 char *klist = NULL;
427
428 if (size) {
429 if (size > XATTR_LIST_MAX)
430 size = XATTR_LIST_MAX;
431 klist = kmalloc(size, GFP_KERNEL);
432 if (!klist)
433 return -ENOMEM;
434 }
435
Bill Nottingham659564c2006-10-09 16:10:48 -0400436 error = vfs_listxattr(d, klist, size);
Stephen Smalleyf549d6c2005-09-03 15:55:18 -0700437 if (error > 0) {
438 if (size && copy_to_user(list, klist, error))
439 error = -EFAULT;
440 } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
441 /* The file system tried to returned a list bigger
442 than XATTR_LIST_MAX bytes. Not possible. */
443 error = -E2BIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800445 kfree(klist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return error;
447}
448
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100449SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
450 size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Al Viro2d8f3032008-07-22 09:59:21 -0400452 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 ssize_t error;
454
Al Viro2d8f3032008-07-22 09:59:21 -0400455 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (error)
457 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400458 error = listxattr(path.dentry, list, size);
459 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 return error;
461}
462
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100463SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
464 size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Al Viro2d8f3032008-07-22 09:59:21 -0400466 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 ssize_t error;
468
Al Viro2d8f3032008-07-22 09:59:21 -0400469 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 if (error)
471 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400472 error = listxattr(path.dentry, list, size);
473 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return error;
475}
476
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100477SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 struct file *f;
480 ssize_t error = -EBADF;
481
482 f = fget(fd);
483 if (!f)
484 return error;
Al Viro5a190ae2007-06-07 12:19:32 -0400485 audit_inode(NULL, f->f_path.dentry);
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800486 error = listxattr(f->f_path.dentry, list, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 fput(f);
488 return error;
489}
490
491/*
492 * Extended attribute REMOVE operations
493 */
494static long
David Howells8f0cfa52008-04-29 00:59:41 -0700495removexattr(struct dentry *d, const char __user *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 int error;
498 char kname[XATTR_NAME_MAX + 1];
499
500 error = strncpy_from_user(kname, name, sizeof(kname));
501 if (error == 0 || error == sizeof(kname))
502 error = -ERANGE;
503 if (error < 0)
504 return error;
505
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800506 return vfs_removexattr(d, kname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100509SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
510 const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Al Viro2d8f3032008-07-22 09:59:21 -0400512 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 int error;
514
Al Viro2d8f3032008-07-22 09:59:21 -0400515 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (error)
517 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400518 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800519 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400520 error = removexattr(path.dentry, name);
521 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800522 }
Al Viro2d8f3032008-07-22 09:59:21 -0400523 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return error;
525}
526
Heiko Carstens6a6160a2009-01-14 14:14:15 +0100527SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
528 const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
Al Viro2d8f3032008-07-22 09:59:21 -0400530 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 int error;
532
Al Viro2d8f3032008-07-22 09:59:21 -0400533 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (error)
535 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400536 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800537 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400538 error = removexattr(path.dentry, name);
539 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800540 }
Al Viro2d8f3032008-07-22 09:59:21 -0400541 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 return error;
543}
544
Heiko Carstens6a6160a2009-01-14 14:14:15 +0100545SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546{
547 struct file *f;
Amy Griffis73241cc2005-11-03 16:00:25 +0000548 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 int error = -EBADF;
550
551 f = fget(fd);
552 if (!f)
553 return error;
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -0800554 dentry = f->f_path.dentry;
Al Viro5a190ae2007-06-07 12:19:32 -0400555 audit_inode(NULL, dentry);
npiggin@suse.de96029c42009-04-26 20:25:55 +1000556 error = mnt_want_write_file(f);
Dave Hansen18f335a2008-02-15 14:37:38 -0800557 if (!error) {
558 error = removexattr(dentry, name);
559 mnt_drop_write(f->f_path.mnt);
560 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 fput(f);
562 return error;
563}
564
565
566static const char *
567strcmp_prefix(const char *a, const char *a_prefix)
568{
569 while (*a_prefix && *a == *a_prefix) {
570 a++;
571 a_prefix++;
572 }
573 return *a_prefix ? NULL : a;
574}
575
576/*
577 * In order to implement different sets of xattr operations for each xattr
578 * prefix with the generic xattr API, a filesystem should create a
579 * null-terminated array of struct xattr_handler (one for each prefix) and
580 * hang a pointer to it off of the s_xattr field of the superblock.
581 *
582 * The generic_fooxattr() functions will use this list to dispatch xattr
583 * operations to the correct xattr_handler.
584 */
585#define for_each_xattr_handler(handlers, handler) \
586 for ((handler) = *(handlers)++; \
587 (handler) != NULL; \
588 (handler) = *(handlers)++)
589
590/*
591 * Find the xattr_handler with the matching prefix.
592 */
593static struct xattr_handler *
594xattr_resolve_name(struct xattr_handler **handlers, const char **name)
595{
596 struct xattr_handler *handler;
597
598 if (!*name)
599 return NULL;
600
601 for_each_xattr_handler(handlers, handler) {
602 const char *n = strcmp_prefix(*name, handler->prefix);
603 if (n) {
604 *name = n;
605 break;
606 }
607 }
608 return handler;
609}
610
611/*
612 * Find the handler for the prefix and dispatch its get() operation.
613 */
614ssize_t
615generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
616{
617 struct xattr_handler *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Christoph Hellwig431547b2009-11-13 09:52:56 +0000619 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 if (!handler)
621 return -EOPNOTSUPP;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000622 return handler->get(dentry, name, buffer, size, handler->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623}
624
625/*
626 * Combine the results of the list() operation from every xattr_handler in the
627 * list.
628 */
629ssize_t
630generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
631{
Christoph Hellwig431547b2009-11-13 09:52:56 +0000632 struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 unsigned int size = 0;
634
635 if (!buffer) {
Christoph Hellwig431547b2009-11-13 09:52:56 +0000636 for_each_xattr_handler(handlers, handler) {
637 size += handler->list(dentry, NULL, 0, NULL, 0,
638 handler->flags);
639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 } else {
641 char *buf = buffer;
642
643 for_each_xattr_handler(handlers, handler) {
Christoph Hellwig431547b2009-11-13 09:52:56 +0000644 size = handler->list(dentry, buf, buffer_size,
645 NULL, 0, handler->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 if (size > buffer_size)
647 return -ERANGE;
648 buf += size;
649 buffer_size -= size;
650 }
651 size = buf - buffer;
652 }
653 return size;
654}
655
656/*
657 * Find the handler for the prefix and dispatch its set() operation.
658 */
659int
660generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
661{
662 struct xattr_handler *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664 if (size == 0)
665 value = ""; /* empty EA, do not remove */
Christoph Hellwig431547b2009-11-13 09:52:56 +0000666 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 if (!handler)
668 return -EOPNOTSUPP;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000669 return handler->set(dentry, name, value, size, 0, handler->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670}
671
672/*
673 * Find the handler for the prefix and dispatch its set() operation to remove
674 * any associated extended attribute.
675 */
676int
677generic_removexattr(struct dentry *dentry, const char *name)
678{
679 struct xattr_handler *handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Christoph Hellwig431547b2009-11-13 09:52:56 +0000681 handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 if (!handler)
683 return -EOPNOTSUPP;
Christoph Hellwig431547b2009-11-13 09:52:56 +0000684 return handler->set(dentry, name, NULL, 0,
685 XATTR_REPLACE, handler->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686}
687
688EXPORT_SYMBOL(generic_getxattr);
689EXPORT_SYMBOL(generic_listxattr);
690EXPORT_SYMBOL(generic_setxattr);
691EXPORT_SYMBOL(generic_removexattr);