386a532ee5a9acff40b2d4855c42e656213b202f
[linux-2.6.git] / fs / xattr.c
1 /*
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>
12 #include <linux/smp_lock.h>
13 #include <linux/file.h>
14 #include <linux/xattr.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 <asm/uaccess.h>
21
22 /*
23  * Extended attribute SET operations
24  */
25 static long
26 setxattr(struct dentry *d, char __user *name, void __user *value,
27          size_t size, int flags)
28 {
29         int error;
30         void *kvalue = NULL;
31         char kname[XATTR_NAME_MAX + 1];
32
33         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
34                 return -EINVAL;
35
36         error = strncpy_from_user(kname, name, sizeof(kname));
37         if (error == 0 || error == sizeof(kname))
38                 error = -ERANGE;
39         if (error < 0)
40                 return error;
41
42         if (size) {
43                 if (size > XATTR_SIZE_MAX)
44                         return -E2BIG;
45                 kvalue = kmalloc(size, GFP_KERNEL);
46                 if (!kvalue)
47                         return -ENOMEM;
48                 if (copy_from_user(kvalue, value, size)) {
49                         kfree(kvalue);
50                         return -EFAULT;
51                 }
52         }
53
54         mutex_lock(&d->d_inode->i_mutex);
55         error = security_inode_setxattr(d, kname, kvalue, size, flags);
56         if (error)
57                 goto out;
58         error = -EOPNOTSUPP;
59         if (d->d_inode->i_op && d->d_inode->i_op->setxattr) {
60                 error = d->d_inode->i_op->setxattr(d, kname, kvalue,
61                                                    size, flags);
62                 if (!error) {
63                         fsnotify_xattr(d);
64                         security_inode_post_setxattr(d, kname, kvalue,
65                                                      size, flags);
66                 }
67         } else if (!strncmp(kname, XATTR_SECURITY_PREFIX,
68                             sizeof XATTR_SECURITY_PREFIX - 1)) {
69                 const char *suffix = kname + sizeof XATTR_SECURITY_PREFIX - 1;
70                 error = security_inode_setsecurity(d->d_inode, suffix, kvalue,
71                                                    size, flags);
72                 if (!error)
73                         fsnotify_xattr(d);
74         }
75 out:
76         mutex_unlock(&d->d_inode->i_mutex);
77         kfree(kvalue);
78         return error;
79 }
80
81 asmlinkage long
82 sys_setxattr(char __user *path, char __user *name, void __user *value,
83              size_t size, int flags)
84 {
85         struct nameidata nd;
86         int error;
87
88         error = user_path_walk(path, &nd);
89         if (error)
90                 return error;
91         error = setxattr(nd.dentry, name, value, size, flags);
92         path_release(&nd);
93         return error;
94 }
95
96 asmlinkage long
97 sys_lsetxattr(char __user *path, char __user *name, void __user *value,
98               size_t size, int flags)
99 {
100         struct nameidata nd;
101         int error;
102
103         error = user_path_walk_link(path, &nd);
104         if (error)
105                 return error;
106         error = setxattr(nd.dentry, name, value, size, flags);
107         path_release(&nd);
108         return error;
109 }
110
111 asmlinkage long
112 sys_fsetxattr(int fd, char __user *name, void __user *value,
113               size_t size, int flags)
114 {
115         struct file *f;
116         int error = -EBADF;
117
118         f = fget(fd);
119         if (!f)
120                 return error;
121         error = setxattr(f->f_dentry, name, value, size, flags);
122         fput(f);
123         return error;
124 }
125
126 /*
127  * Extended attribute GET operations
128  */
129 static ssize_t
130 getxattr(struct dentry *d, char __user *name, void __user *value, size_t size)
131 {
132         ssize_t error;
133         void *kvalue = NULL;
134         char kname[XATTR_NAME_MAX + 1];
135
136         error = strncpy_from_user(kname, name, sizeof(kname));
137         if (error == 0 || error == sizeof(kname))
138                 error = -ERANGE;
139         if (error < 0)
140                 return error;
141
142         if (size) {
143                 if (size > XATTR_SIZE_MAX)
144                         size = XATTR_SIZE_MAX;
145                 kvalue = kzalloc(size, GFP_KERNEL);
146                 if (!kvalue)
147                         return -ENOMEM;
148         }
149
150         error = security_inode_getxattr(d, kname);
151         if (error)
152                 goto out;
153         error = -EOPNOTSUPP;
154         if (d->d_inode->i_op && d->d_inode->i_op->getxattr)
155                 error = d->d_inode->i_op->getxattr(d, kname, kvalue, size);
156
157         if (!strncmp(kname, XATTR_SECURITY_PREFIX,
158                      sizeof XATTR_SECURITY_PREFIX - 1)) {
159                 const char *suffix = kname + sizeof XATTR_SECURITY_PREFIX - 1;
160                 int rv = security_inode_getsecurity(d->d_inode, suffix, kvalue,
161                                                     size, error);
162                 /* Security module active: overwrite error value */
163                 if (rv != -EOPNOTSUPP)
164                         error = rv;
165         }
166         if (error > 0) {
167                 if (size && copy_to_user(value, kvalue, error))
168                         error = -EFAULT;
169         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
170                 /* The file system tried to returned a value bigger
171                    than XATTR_SIZE_MAX bytes. Not possible. */
172                 error = -E2BIG;
173         }
174 out:
175         kfree(kvalue);
176         return error;
177 }
178
179 asmlinkage ssize_t
180 sys_getxattr(char __user *path, char __user *name, void __user *value,
181              size_t size)
182 {
183         struct nameidata nd;
184         ssize_t error;
185
186         error = user_path_walk(path, &nd);
187         if (error)
188                 return error;
189         error = getxattr(nd.dentry, name, value, size);
190         path_release(&nd);
191         return error;
192 }
193
194 asmlinkage ssize_t
195 sys_lgetxattr(char __user *path, char __user *name, void __user *value,
196               size_t size)
197 {
198         struct nameidata nd;
199         ssize_t error;
200
201         error = user_path_walk_link(path, &nd);
202         if (error)
203                 return error;
204         error = getxattr(nd.dentry, name, value, size);
205         path_release(&nd);
206         return error;
207 }
208
209 asmlinkage ssize_t
210 sys_fgetxattr(int fd, char __user *name, void __user *value, size_t size)
211 {
212         struct file *f;
213         ssize_t error = -EBADF;
214
215         f = fget(fd);
216         if (!f)
217                 return error;
218         error = getxattr(f->f_dentry, name, value, size);
219         fput(f);
220         return error;
221 }
222
223 /*
224  * Extended attribute LIST operations
225  */
226 static ssize_t
227 listxattr(struct dentry *d, char __user *list, size_t size)
228 {
229         ssize_t error;
230         char *klist = NULL;
231
232         if (size) {
233                 if (size > XATTR_LIST_MAX)
234                         size = XATTR_LIST_MAX;
235                 klist = kmalloc(size, GFP_KERNEL);
236                 if (!klist)
237                         return -ENOMEM;
238         }
239
240         error = security_inode_listxattr(d);
241         if (error)
242                 goto out;
243         error = -EOPNOTSUPP;
244         if (d->d_inode->i_op && d->d_inode->i_op->listxattr) {
245                 error = d->d_inode->i_op->listxattr(d, klist, size);
246         } else {
247                 error = security_inode_listsecurity(d->d_inode, klist, size);
248                 if (size && error > size)
249                         error = -ERANGE;
250         }
251         if (error > 0) {
252                 if (size && copy_to_user(list, klist, error))
253                         error = -EFAULT;
254         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
255                 /* The file system tried to returned a list bigger
256                    than XATTR_LIST_MAX bytes. Not possible. */
257                 error = -E2BIG;
258         }
259 out:
260         kfree(klist);
261         return error;
262 }
263
264 asmlinkage ssize_t
265 sys_listxattr(char __user *path, char __user *list, size_t size)
266 {
267         struct nameidata nd;
268         ssize_t error;
269
270         error = user_path_walk(path, &nd);
271         if (error)
272                 return error;
273         error = listxattr(nd.dentry, list, size);
274         path_release(&nd);
275         return error;
276 }
277
278 asmlinkage ssize_t
279 sys_llistxattr(char __user *path, char __user *list, size_t size)
280 {
281         struct nameidata nd;
282         ssize_t error;
283
284         error = user_path_walk_link(path, &nd);
285         if (error)
286                 return error;
287         error = listxattr(nd.dentry, list, size);
288         path_release(&nd);
289         return error;
290 }
291
292 asmlinkage ssize_t
293 sys_flistxattr(int fd, char __user *list, size_t size)
294 {
295         struct file *f;
296         ssize_t error = -EBADF;
297
298         f = fget(fd);
299         if (!f)
300                 return error;
301         error = listxattr(f->f_dentry, list, size);
302         fput(f);
303         return error;
304 }
305
306 /*
307  * Extended attribute REMOVE operations
308  */
309 static long
310 removexattr(struct dentry *d, char __user *name)
311 {
312         int error;
313         char kname[XATTR_NAME_MAX + 1];
314
315         error = strncpy_from_user(kname, name, sizeof(kname));
316         if (error == 0 || error == sizeof(kname))
317                 error = -ERANGE;
318         if (error < 0)
319                 return error;
320
321         error = -EOPNOTSUPP;
322         if (d->d_inode->i_op && d->d_inode->i_op->removexattr) {
323                 error = security_inode_removexattr(d, kname);
324                 if (error)
325                         goto out;
326                 mutex_lock(&d->d_inode->i_mutex);
327                 error = d->d_inode->i_op->removexattr(d, kname);
328                 mutex_unlock(&d->d_inode->i_mutex);
329                 if (!error)
330                         fsnotify_xattr(d);
331         }
332 out:
333         return error;
334 }
335
336 asmlinkage long
337 sys_removexattr(char __user *path, char __user *name)
338 {
339         struct nameidata nd;
340         int error;
341
342         error = user_path_walk(path, &nd);
343         if (error)
344                 return error;
345         error = removexattr(nd.dentry, name);
346         path_release(&nd);
347         return error;
348 }
349
350 asmlinkage long
351 sys_lremovexattr(char __user *path, char __user *name)
352 {
353         struct nameidata nd;
354         int error;
355
356         error = user_path_walk_link(path, &nd);
357         if (error)
358                 return error;
359         error = removexattr(nd.dentry, name);
360         path_release(&nd);
361         return error;
362 }
363
364 asmlinkage long
365 sys_fremovexattr(int fd, char __user *name)
366 {
367         struct file *f;
368         int error = -EBADF;
369
370         f = fget(fd);
371         if (!f)
372                 return error;
373         error = removexattr(f->f_dentry, name);
374         fput(f);
375         return error;
376 }
377
378
379 static const char *
380 strcmp_prefix(const char *a, const char *a_prefix)
381 {
382         while (*a_prefix && *a == *a_prefix) {
383                 a++;
384                 a_prefix++;
385         }
386         return *a_prefix ? NULL : a;
387 }
388
389 /*
390  * In order to implement different sets of xattr operations for each xattr
391  * prefix with the generic xattr API, a filesystem should create a
392  * null-terminated array of struct xattr_handler (one for each prefix) and
393  * hang a pointer to it off of the s_xattr field of the superblock.
394  *
395  * The generic_fooxattr() functions will use this list to dispatch xattr
396  * operations to the correct xattr_handler.
397  */
398 #define for_each_xattr_handler(handlers, handler)               \
399                 for ((handler) = *(handlers)++;                 \
400                         (handler) != NULL;                      \
401                         (handler) = *(handlers)++)
402
403 /*
404  * Find the xattr_handler with the matching prefix.
405  */
406 static struct xattr_handler *
407 xattr_resolve_name(struct xattr_handler **handlers, const char **name)
408 {
409         struct xattr_handler *handler;
410
411         if (!*name)
412                 return NULL;
413
414         for_each_xattr_handler(handlers, handler) {
415                 const char *n = strcmp_prefix(*name, handler->prefix);
416                 if (n) {
417                         *name = n;
418                         break;
419                 }
420         }
421         return handler;
422 }
423
424 /*
425  * Find the handler for the prefix and dispatch its get() operation.
426  */
427 ssize_t
428 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
429 {
430         struct xattr_handler *handler;
431         struct inode *inode = dentry->d_inode;
432
433         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
434         if (!handler)
435                 return -EOPNOTSUPP;
436         return handler->get(inode, name, buffer, size);
437 }
438
439 /*
440  * Combine the results of the list() operation from every xattr_handler in the
441  * list.
442  */
443 ssize_t
444 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
445 {
446         struct inode *inode = dentry->d_inode;
447         struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
448         unsigned int size = 0;
449
450         if (!buffer) {
451                 for_each_xattr_handler(handlers, handler)
452                         size += handler->list(inode, NULL, 0, NULL, 0);
453         } else {
454                 char *buf = buffer;
455
456                 for_each_xattr_handler(handlers, handler) {
457                         size = handler->list(inode, buf, buffer_size, NULL, 0);
458                         if (size > buffer_size)
459                                 return -ERANGE;
460                         buf += size;
461                         buffer_size -= size;
462                 }
463                 size = buf - buffer;
464         }
465         return size;
466 }
467
468 /*
469  * Find the handler for the prefix and dispatch its set() operation.
470  */
471 int
472 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
473 {
474         struct xattr_handler *handler;
475         struct inode *inode = dentry->d_inode;
476
477         if (size == 0)
478                 value = "";  /* empty EA, do not remove */
479         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
480         if (!handler)
481                 return -EOPNOTSUPP;
482         return handler->set(inode, name, value, size, flags);
483 }
484
485 /*
486  * Find the handler for the prefix and dispatch its set() operation to remove
487  * any associated extended attribute.
488  */
489 int
490 generic_removexattr(struct dentry *dentry, const char *name)
491 {
492         struct xattr_handler *handler;
493         struct inode *inode = dentry->d_inode;
494
495         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
496         if (!handler)
497                 return -EOPNOTSUPP;
498         return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
499 }
500
501 EXPORT_SYMBOL(generic_getxattr);
502 EXPORT_SYMBOL(generic_listxattr);
503 EXPORT_SYMBOL(generic_setxattr);
504 EXPORT_SYMBOL(generic_removexattr);