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