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