blob: d51b8f9db921ce4c01c2858cfc56b9ecd6ca71f5 [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
Christoph Hellwig5be196e2006-01-09 20:51:55 -080069int
David Howells8f0cfa52008-04-29 00:59:41 -070070vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
Christoph Hellwig5be196e2006-01-09 20:51:55 -080071 size_t size, int flags)
72{
73 struct inode *inode = dentry->d_inode;
74 int error;
75
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080076 error = xattr_permission(inode, name, MAY_WRITE);
77 if (error)
78 return error;
79
Christoph Hellwig5be196e2006-01-09 20:51:55 -080080 mutex_lock(&inode->i_mutex);
81 error = security_inode_setxattr(dentry, name, value, size, flags);
82 if (error)
83 goto out;
84 error = -EOPNOTSUPP;
85 if (inode->i_op->setxattr) {
86 error = inode->i_op->setxattr(dentry, name, value, size, flags);
87 if (!error) {
88 fsnotify_xattr(dentry);
89 security_inode_post_setxattr(dentry, name, value,
90 size, flags);
91 }
92 } else if (!strncmp(name, XATTR_SECURITY_PREFIX,
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -080093 XATTR_SECURITY_PREFIX_LEN)) {
94 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
Christoph Hellwig5be196e2006-01-09 20:51:55 -080095 error = security_inode_setsecurity(inode, suffix, value,
96 size, flags);
97 if (!error)
98 fsnotify_xattr(dentry);
99 }
100out:
101 mutex_unlock(&inode->i_mutex);
102 return error;
103}
104EXPORT_SYMBOL_GPL(vfs_setxattr);
105
106ssize_t
David P. Quigley42492592008-02-04 22:29:39 -0800107xattr_getsecurity(struct inode *inode, const char *name, void *value,
108 size_t size)
109{
110 void *buffer = NULL;
111 ssize_t len;
112
113 if (!value || !size) {
114 len = security_inode_getsecurity(inode, name, &buffer, false);
115 goto out_noalloc;
116 }
117
118 len = security_inode_getsecurity(inode, name, &buffer, true);
119 if (len < 0)
120 return len;
121 if (size < len) {
122 len = -ERANGE;
123 goto out;
124 }
125 memcpy(value, buffer, len);
126out:
127 security_release_secctx(buffer, len);
128out_noalloc:
129 return len;
130}
131EXPORT_SYMBOL_GPL(xattr_getsecurity);
132
133ssize_t
David Howells8f0cfa52008-04-29 00:59:41 -0700134vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800135{
136 struct inode *inode = dentry->d_inode;
137 int error;
138
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800139 error = xattr_permission(inode, name, MAY_READ);
140 if (error)
141 return error;
142
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800143 error = security_inode_getxattr(dentry, name);
144 if (error)
145 return error;
146
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800147 if (!strncmp(name, XATTR_SECURITY_PREFIX,
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800148 XATTR_SECURITY_PREFIX_LEN)) {
149 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
David P. Quigley42492592008-02-04 22:29:39 -0800150 int ret = xattr_getsecurity(inode, suffix, value, size);
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800151 /*
152 * Only overwrite the return value if a security module
153 * is actually active.
154 */
David P. Quigley4bea5802008-02-04 22:29:40 -0800155 if (ret == -EOPNOTSUPP)
156 goto nolsm;
157 return ret;
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800158 }
David P. Quigley4bea5802008-02-04 22:29:40 -0800159nolsm:
160 if (inode->i_op->getxattr)
161 error = inode->i_op->getxattr(dentry, name, value, size);
162 else
163 error = -EOPNOTSUPP;
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800164
165 return error;
166}
167EXPORT_SYMBOL_GPL(vfs_getxattr);
168
Bill Nottingham659564c2006-10-09 16:10:48 -0400169ssize_t
170vfs_listxattr(struct dentry *d, char *list, size_t size)
171{
172 ssize_t error;
173
174 error = security_inode_listxattr(d);
175 if (error)
176 return error;
177 error = -EOPNOTSUPP;
Al Viroacfa4382008-12-04 10:06:33 -0500178 if (d->d_inode->i_op->listxattr) {
Bill Nottingham659564c2006-10-09 16:10:48 -0400179 error = d->d_inode->i_op->listxattr(d, list, size);
180 } else {
181 error = security_inode_listsecurity(d->d_inode, list, size);
182 if (size && error > size)
183 error = -ERANGE;
184 }
185 return error;
186}
187EXPORT_SYMBOL_GPL(vfs_listxattr);
188
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800189int
David Howells8f0cfa52008-04-29 00:59:41 -0700190vfs_removexattr(struct dentry *dentry, const char *name)
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800191{
192 struct inode *inode = dentry->d_inode;
193 int error;
194
195 if (!inode->i_op->removexattr)
196 return -EOPNOTSUPP;
197
akpm@osdl.orge0ad7b02006-01-09 20:51:56 -0800198 error = xattr_permission(inode, name, MAY_WRITE);
199 if (error)
200 return error;
201
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800202 error = security_inode_removexattr(dentry, name);
203 if (error)
204 return error;
205
206 mutex_lock(&inode->i_mutex);
207 error = inode->i_op->removexattr(dentry, name);
208 mutex_unlock(&inode->i_mutex);
209
210 if (!error)
211 fsnotify_xattr(dentry);
212 return error;
213}
214EXPORT_SYMBOL_GPL(vfs_removexattr);
215
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217/*
218 * Extended attribute SET operations
219 */
220static long
David Howells8f0cfa52008-04-29 00:59:41 -0700221setxattr(struct dentry *d, const char __user *name, const void __user *value,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 size_t size, int flags)
223{
224 int error;
225 void *kvalue = NULL;
226 char kname[XATTR_NAME_MAX + 1];
227
228 if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
229 return -EINVAL;
230
231 error = strncpy_from_user(kname, name, sizeof(kname));
232 if (error == 0 || error == sizeof(kname))
233 error = -ERANGE;
234 if (error < 0)
235 return error;
236
237 if (size) {
238 if (size > XATTR_SIZE_MAX)
239 return -E2BIG;
Li Zefan3939fcd2009-04-08 15:06:12 +0800240 kvalue = memdup_user(value, size);
241 if (IS_ERR(kvalue))
242 return PTR_ERR(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 }
244
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800245 error = vfs_setxattr(d, kname, kvalue, size, flags);
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800246 kfree(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return error;
248}
249
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100250SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
251 const char __user *, name, const void __user *, value,
252 size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
Al Viro2d8f3032008-07-22 09:59:21 -0400254 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 int error;
256
Al Viro2d8f3032008-07-22 09:59:21 -0400257 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 if (error)
259 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400260 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800261 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400262 error = setxattr(path.dentry, name, value, size, flags);
263 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800264 }
Al Viro2d8f3032008-07-22 09:59:21 -0400265 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return error;
267}
268
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100269SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
270 const char __user *, name, const void __user *, value,
271 size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Al Viro2d8f3032008-07-22 09:59:21 -0400273 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 int error;
275
Al Viro2d8f3032008-07-22 09:59:21 -0400276 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (error)
278 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400279 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800280 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400281 error = setxattr(path.dentry, name, value, size, flags);
282 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800283 }
Al Viro2d8f3032008-07-22 09:59:21 -0400284 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return error;
286}
287
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100288SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
289 const void __user *,value, size_t, size, int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
291 struct file *f;
Amy Griffis73241cc2005-11-03 16:00:25 +0000292 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 int error = -EBADF;
294
295 f = fget(fd);
296 if (!f)
297 return error;
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -0800298 dentry = f->f_path.dentry;
Al Viro5a190ae2007-06-07 12:19:32 -0400299 audit_inode(NULL, dentry);
Dave Hansen18f335a2008-02-15 14:37:38 -0800300 error = mnt_want_write(f->f_path.mnt);
301 if (!error) {
302 error = setxattr(dentry, name, value, size, flags);
303 mnt_drop_write(f->f_path.mnt);
304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 fput(f);
306 return error;
307}
308
309/*
310 * Extended attribute GET operations
311 */
312static ssize_t
David Howells8f0cfa52008-04-29 00:59:41 -0700313getxattr(struct dentry *d, const char __user *name, void __user *value,
314 size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 ssize_t error;
317 void *kvalue = NULL;
318 char kname[XATTR_NAME_MAX + 1];
319
320 error = strncpy_from_user(kname, name, sizeof(kname));
321 if (error == 0 || error == sizeof(kname))
322 error = -ERANGE;
323 if (error < 0)
324 return error;
325
326 if (size) {
327 if (size > XATTR_SIZE_MAX)
328 size = XATTR_SIZE_MAX;
James Morrisd381d8a2005-10-30 14:59:22 -0800329 kvalue = kzalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 if (!kvalue)
331 return -ENOMEM;
332 }
333
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800334 error = vfs_getxattr(d, kname, kvalue, size);
Stephen Smalleyf549d6c2005-09-03 15:55:18 -0700335 if (error > 0) {
336 if (size && copy_to_user(value, kvalue, error))
337 error = -EFAULT;
338 } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
339 /* The file system tried to returned a value bigger
340 than XATTR_SIZE_MAX bytes. Not possible. */
341 error = -E2BIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800343 kfree(kvalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 return error;
345}
346
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100347SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
348 const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Al Viro2d8f3032008-07-22 09:59:21 -0400350 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 ssize_t error;
352
Al Viro2d8f3032008-07-22 09:59:21 -0400353 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (error)
355 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400356 error = getxattr(path.dentry, name, value, size);
357 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return error;
359}
360
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100361SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
362 const char __user *, name, void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363{
Al Viro2d8f3032008-07-22 09:59:21 -0400364 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 ssize_t error;
366
Al Viro2d8f3032008-07-22 09:59:21 -0400367 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 if (error)
369 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400370 error = getxattr(path.dentry, name, value, size);
371 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return error;
373}
374
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100375SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
376 void __user *, value, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
378 struct file *f;
379 ssize_t error = -EBADF;
380
381 f = fget(fd);
382 if (!f)
383 return error;
Al Viro5a190ae2007-06-07 12:19:32 -0400384 audit_inode(NULL, f->f_path.dentry);
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -0800385 error = getxattr(f->f_path.dentry, name, value, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 fput(f);
387 return error;
388}
389
390/*
391 * Extended attribute LIST operations
392 */
393static ssize_t
394listxattr(struct dentry *d, char __user *list, size_t size)
395{
396 ssize_t error;
397 char *klist = NULL;
398
399 if (size) {
400 if (size > XATTR_LIST_MAX)
401 size = XATTR_LIST_MAX;
402 klist = kmalloc(size, GFP_KERNEL);
403 if (!klist)
404 return -ENOMEM;
405 }
406
Bill Nottingham659564c2006-10-09 16:10:48 -0400407 error = vfs_listxattr(d, klist, size);
Stephen Smalleyf549d6c2005-09-03 15:55:18 -0700408 if (error > 0) {
409 if (size && copy_to_user(list, klist, error))
410 error = -EFAULT;
411 } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
412 /* The file system tried to returned a list bigger
413 than XATTR_LIST_MAX bytes. Not possible. */
414 error = -E2BIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800416 kfree(klist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return error;
418}
419
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100420SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
421 size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
Al Viro2d8f3032008-07-22 09:59:21 -0400423 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 ssize_t error;
425
Al Viro2d8f3032008-07-22 09:59:21 -0400426 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (error)
428 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400429 error = listxattr(path.dentry, list, size);
430 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return error;
432}
433
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100434SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
435 size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
Al Viro2d8f3032008-07-22 09:59:21 -0400437 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 ssize_t error;
439
Al Viro2d8f3032008-07-22 09:59:21 -0400440 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 if (error)
442 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400443 error = listxattr(path.dentry, list, size);
444 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 return error;
446}
447
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100448SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449{
450 struct file *f;
451 ssize_t error = -EBADF;
452
453 f = fget(fd);
454 if (!f)
455 return error;
Al Viro5a190ae2007-06-07 12:19:32 -0400456 audit_inode(NULL, f->f_path.dentry);
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -0800457 error = listxattr(f->f_path.dentry, list, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 fput(f);
459 return error;
460}
461
462/*
463 * Extended attribute REMOVE operations
464 */
465static long
David Howells8f0cfa52008-04-29 00:59:41 -0700466removexattr(struct dentry *d, const char __user *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
468 int error;
469 char kname[XATTR_NAME_MAX + 1];
470
471 error = strncpy_from_user(kname, name, sizeof(kname));
472 if (error == 0 || error == sizeof(kname))
473 error = -ERANGE;
474 if (error < 0)
475 return error;
476
Christoph Hellwig5be196e2006-01-09 20:51:55 -0800477 return vfs_removexattr(d, kname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478}
479
Heiko Carstens64fd1de2009-01-14 14:14:14 +0100480SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
481 const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
Al Viro2d8f3032008-07-22 09:59:21 -0400483 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 int error;
485
Al Viro2d8f3032008-07-22 09:59:21 -0400486 error = user_path(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 if (error)
488 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400489 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800490 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400491 error = removexattr(path.dentry, name);
492 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800493 }
Al Viro2d8f3032008-07-22 09:59:21 -0400494 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return error;
496}
497
Heiko Carstens6a6160a2009-01-14 14:14:15 +0100498SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
499 const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
Al Viro2d8f3032008-07-22 09:59:21 -0400501 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 int error;
503
Al Viro2d8f3032008-07-22 09:59:21 -0400504 error = user_lpath(pathname, &path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (error)
506 return error;
Al Viro2d8f3032008-07-22 09:59:21 -0400507 error = mnt_want_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800508 if (!error) {
Al Viro2d8f3032008-07-22 09:59:21 -0400509 error = removexattr(path.dentry, name);
510 mnt_drop_write(path.mnt);
Dave Hansen18f335a2008-02-15 14:37:38 -0800511 }
Al Viro2d8f3032008-07-22 09:59:21 -0400512 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return error;
514}
515
Heiko Carstens6a6160a2009-01-14 14:14:15 +0100516SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 struct file *f;
Amy Griffis73241cc2005-11-03 16:00:25 +0000519 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 int error = -EBADF;
521
522 f = fget(fd);
523 if (!f)
524 return error;
Josef "Jeff" Sipek0f7fc9e42006-12-08 02:36:35 -0800525 dentry = f->f_path.dentry;
Al Viro5a190ae2007-06-07 12:19:32 -0400526 audit_inode(NULL, dentry);
Dave Hansen18f335a2008-02-15 14:37:38 -0800527 error = mnt_want_write(f->f_path.mnt);
528 if (!error) {
529 error = removexattr(dentry, name);
530 mnt_drop_write(f->f_path.mnt);
531 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 fput(f);
533 return error;
534}
535
536
537static const char *
538strcmp_prefix(const char *a, const char *a_prefix)
539{
540 while (*a_prefix && *a == *a_prefix) {
541 a++;
542 a_prefix++;
543 }
544 return *a_prefix ? NULL : a;
545}
546
547/*
548 * In order to implement different sets of xattr operations for each xattr
549 * prefix with the generic xattr API, a filesystem should create a
550 * null-terminated array of struct xattr_handler (one for each prefix) and
551 * hang a pointer to it off of the s_xattr field of the superblock.
552 *
553 * The generic_fooxattr() functions will use this list to dispatch xattr
554 * operations to the correct xattr_handler.
555 */
556#define for_each_xattr_handler(handlers, handler) \
557 for ((handler) = *(handlers)++; \
558 (handler) != NULL; \
559 (handler) = *(handlers)++)
560
561/*
562 * Find the xattr_handler with the matching prefix.
563 */
564static struct xattr_handler *
565xattr_resolve_name(struct xattr_handler **handlers, const char **name)
566{
567 struct xattr_handler *handler;
568
569 if (!*name)
570 return NULL;
571
572 for_each_xattr_handler(handlers, handler) {
573 const char *n = strcmp_prefix(*name, handler->prefix);
574 if (n) {
575 *name = n;
576 break;
577 }
578 }
579 return handler;
580}
581
582/*
583 * Find the handler for the prefix and dispatch its get() operation.
584 */
585ssize_t
586generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
587{
588 struct xattr_handler *handler;
589 struct inode *inode = dentry->d_inode;
590
591 handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
592 if (!handler)
593 return -EOPNOTSUPP;
594 return handler->get(inode, name, buffer, size);
595}
596
597/*
598 * Combine the results of the list() operation from every xattr_handler in the
599 * list.
600 */
601ssize_t
602generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
603{
604 struct inode *inode = dentry->d_inode;
605 struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
606 unsigned int size = 0;
607
608 if (!buffer) {
609 for_each_xattr_handler(handlers, handler)
610 size += handler->list(inode, NULL, 0, NULL, 0);
611 } else {
612 char *buf = buffer;
613
614 for_each_xattr_handler(handlers, handler) {
615 size = handler->list(inode, buf, buffer_size, NULL, 0);
616 if (size > buffer_size)
617 return -ERANGE;
618 buf += size;
619 buffer_size -= size;
620 }
621 size = buf - buffer;
622 }
623 return size;
624}
625
626/*
627 * Find the handler for the prefix and dispatch its set() operation.
628 */
629int
630generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
631{
632 struct xattr_handler *handler;
633 struct inode *inode = dentry->d_inode;
634
635 if (size == 0)
636 value = ""; /* empty EA, do not remove */
637 handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
638 if (!handler)
639 return -EOPNOTSUPP;
640 return handler->set(inode, name, value, size, flags);
641}
642
643/*
644 * Find the handler for the prefix and dispatch its set() operation to remove
645 * any associated extended attribute.
646 */
647int
648generic_removexattr(struct dentry *dentry, const char *name)
649{
650 struct xattr_handler *handler;
651 struct inode *inode = dentry->d_inode;
652
653 handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
654 if (!handler)
655 return -EOPNOTSUPP;
656 return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
657}
658
659EXPORT_SYMBOL(generic_getxattr);
660EXPORT_SYMBOL(generic_listxattr);
661EXPORT_SYMBOL(generic_setxattr);
662EXPORT_SYMBOL(generic_removexattr);