CIFS: Remove __exit mark from cifs_exit_dns_resolver()
[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/file.h>
13 #include <linux/xattr.h>
14 #include <linux/mount.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 <linux/audit.h>
21 #include <asm/uaccess.h>
22
23
24 /*
25  * Check permissions for extended attribute access.  This is a bit complicated
26  * because different namespaces have very different rules.
27  */
28 static int
29 xattr_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) {
36                 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         /*
49          * The trusted.* namespace can only be accessed by a privileged user.
50          */
51         if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
52                 return (capable(CAP_SYS_ADMIN) ? 0 : -EPERM);
53
54         /* 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          */
58         if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
59                 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) &&
62                     (mask & MAY_WRITE) && !is_owner_or_cap(inode))
63                         return -EPERM;
64         }
65
66         return inode_permission(inode, mask);
67 }
68
69 /**
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  */
85 int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
86                 const void *value, size_t size, int flags)
87 {
88         struct inode *inode = dentry->d_inode;
89         int error = -EOPNOTSUPP;
90
91         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,
99                                 XATTR_SECURITY_PREFIX_LEN)) {
100                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
101                 error = security_inode_setsecurity(inode, suffix, value,
102                                                    size, flags);
103                 if (!error)
104                         fsnotify_xattr(dentry);
105         }
106
107         return error;
108 }
109
110
111 int
112 vfs_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
129 out:
130         mutex_unlock(&inode->i_mutex);
131         return error;
132 }
133 EXPORT_SYMBOL_GPL(vfs_setxattr);
134
135 ssize_t
136 xattr_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);
155 out:
156         security_release_secctx(buffer, len);
157 out_noalloc:
158         return len;
159 }
160 EXPORT_SYMBOL_GPL(xattr_getsecurity);
161
162 ssize_t
163 vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
164 {
165         struct inode *inode = dentry->d_inode;
166         int error;
167
168         error = xattr_permission(inode, name, MAY_READ);
169         if (error)
170                 return error;
171
172         error = security_inode_getxattr(dentry, name);
173         if (error)
174                 return error;
175
176         if (!strncmp(name, XATTR_SECURITY_PREFIX,
177                                 XATTR_SECURITY_PREFIX_LEN)) {
178                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
179                 int ret = xattr_getsecurity(inode, suffix, value, size);
180                 /*
181                  * Only overwrite the return value if a security module
182                  * is actually active.
183                  */
184                 if (ret == -EOPNOTSUPP)
185                         goto nolsm;
186                 return ret;
187         }
188 nolsm:
189         if (inode->i_op->getxattr)
190                 error = inode->i_op->getxattr(dentry, name, value, size);
191         else
192                 error = -EOPNOTSUPP;
193
194         return error;
195 }
196 EXPORT_SYMBOL_GPL(vfs_getxattr);
197
198 ssize_t
199 vfs_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;
207         if (d->d_inode->i_op->listxattr) {
208                 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 }
216 EXPORT_SYMBOL_GPL(vfs_listxattr);
217
218 int
219 vfs_removexattr(struct dentry *dentry, const char *name)
220 {
221         struct inode *inode = dentry->d_inode;
222         int error;
223
224         if (!inode->i_op->removexattr)
225                 return -EOPNOTSUPP;
226
227         error = xattr_permission(inode, name, MAY_WRITE);
228         if (error)
229                 return error;
230
231         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 }
243 EXPORT_SYMBOL_GPL(vfs_removexattr);
244
245
246 /*
247  * Extended attribute SET operations
248  */
249 static long
250 setxattr(struct dentry *d, const char __user *name, const void __user *value,
251          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;
269                 kvalue = memdup_user(value, size);
270                 if (IS_ERR(kvalue))
271                         return PTR_ERR(kvalue);
272         }
273
274         error = vfs_setxattr(d, kname, kvalue, size, flags);
275         kfree(kvalue);
276         return error;
277 }
278
279 SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
280                 const char __user *, name, const void __user *, value,
281                 size_t, size, int, flags)
282 {
283         struct path path;
284         int error;
285
286         error = user_path(pathname, &path);
287         if (error)
288                 return error;
289         error = mnt_want_write(path.mnt);
290         if (!error) {
291                 error = setxattr(path.dentry, name, value, size, flags);
292                 mnt_drop_write(path.mnt);
293         }
294         path_put(&path);
295         return error;
296 }
297
298 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
299                 const char __user *, name, const void __user *, value,
300                 size_t, size, int, flags)
301 {
302         struct path path;
303         int error;
304
305         error = user_lpath(pathname, &path);
306         if (error)
307                 return error;
308         error = mnt_want_write(path.mnt);
309         if (!error) {
310                 error = setxattr(path.dentry, name, value, size, flags);
311                 mnt_drop_write(path.mnt);
312         }
313         path_put(&path);
314         return error;
315 }
316
317 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
318                 const void __user *,value, size_t, size, int, flags)
319 {
320         struct file *f;
321         struct dentry *dentry;
322         int error = -EBADF;
323
324         f = fget(fd);
325         if (!f)
326                 return error;
327         dentry = f->f_path.dentry;
328         audit_inode(NULL, dentry);
329         error = mnt_want_write_file(f);
330         if (!error) {
331                 error = setxattr(dentry, name, value, size, flags);
332                 mnt_drop_write(f->f_path.mnt);
333         }
334         fput(f);
335         return error;
336 }
337
338 /*
339  * Extended attribute GET operations
340  */
341 static ssize_t
342 getxattr(struct dentry *d, const char __user *name, void __user *value,
343          size_t size)
344 {
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;
358                 kvalue = kzalloc(size, GFP_KERNEL);
359                 if (!kvalue)
360                         return -ENOMEM;
361         }
362
363         error = vfs_getxattr(d, kname, kvalue, size);
364         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;
371         }
372         kfree(kvalue);
373         return error;
374 }
375
376 SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
377                 const char __user *, name, void __user *, value, size_t, size)
378 {
379         struct path path;
380         ssize_t error;
381
382         error = user_path(pathname, &path);
383         if (error)
384                 return error;
385         error = getxattr(path.dentry, name, value, size);
386         path_put(&path);
387         return error;
388 }
389
390 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
391                 const char __user *, name, void __user *, value, size_t, size)
392 {
393         struct path path;
394         ssize_t error;
395
396         error = user_lpath(pathname, &path);
397         if (error)
398                 return error;
399         error = getxattr(path.dentry, name, value, size);
400         path_put(&path);
401         return error;
402 }
403
404 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
405                 void __user *, value, size_t, size)
406 {
407         struct file *f;
408         ssize_t error = -EBADF;
409
410         f = fget(fd);
411         if (!f)
412                 return error;
413         audit_inode(NULL, f->f_path.dentry);
414         error = getxattr(f->f_path.dentry, name, value, size);
415         fput(f);
416         return error;
417 }
418
419 /*
420  * Extended attribute LIST operations
421  */
422 static ssize_t
423 listxattr(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
436         error = vfs_listxattr(d, klist, size);
437         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;
444         }
445         kfree(klist);
446         return error;
447 }
448
449 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
450                 size_t, size)
451 {
452         struct path path;
453         ssize_t error;
454
455         error = user_path(pathname, &path);
456         if (error)
457                 return error;
458         error = listxattr(path.dentry, list, size);
459         path_put(&path);
460         return error;
461 }
462
463 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
464                 size_t, size)
465 {
466         struct path path;
467         ssize_t error;
468
469         error = user_lpath(pathname, &path);
470         if (error)
471                 return error;
472         error = listxattr(path.dentry, list, size);
473         path_put(&path);
474         return error;
475 }
476
477 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
478 {
479         struct file *f;
480         ssize_t error = -EBADF;
481
482         f = fget(fd);
483         if (!f)
484                 return error;
485         audit_inode(NULL, f->f_path.dentry);
486         error = listxattr(f->f_path.dentry, list, size);
487         fput(f);
488         return error;
489 }
490
491 /*
492  * Extended attribute REMOVE operations
493  */
494 static long
495 removexattr(struct dentry *d, const char __user *name)
496 {
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
506         return vfs_removexattr(d, kname);
507 }
508
509 SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
510                 const char __user *, name)
511 {
512         struct path path;
513         int error;
514
515         error = user_path(pathname, &path);
516         if (error)
517                 return error;
518         error = mnt_want_write(path.mnt);
519         if (!error) {
520                 error = removexattr(path.dentry, name);
521                 mnt_drop_write(path.mnt);
522         }
523         path_put(&path);
524         return error;
525 }
526
527 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
528                 const char __user *, name)
529 {
530         struct path path;
531         int error;
532
533         error = user_lpath(pathname, &path);
534         if (error)
535                 return error;
536         error = mnt_want_write(path.mnt);
537         if (!error) {
538                 error = removexattr(path.dentry, name);
539                 mnt_drop_write(path.mnt);
540         }
541         path_put(&path);
542         return error;
543 }
544
545 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
546 {
547         struct file *f;
548         struct dentry *dentry;
549         int error = -EBADF;
550
551         f = fget(fd);
552         if (!f)
553                 return error;
554         dentry = f->f_path.dentry;
555         audit_inode(NULL, dentry);
556         error = mnt_want_write_file(f);
557         if (!error) {
558                 error = removexattr(dentry, name);
559                 mnt_drop_write(f->f_path.mnt);
560         }
561         fput(f);
562         return error;
563 }
564
565
566 static const char *
567 strcmp_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  */
593 static const struct xattr_handler *
594 xattr_resolve_name(const struct xattr_handler **handlers, const char **name)
595 {
596         const 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  */
614 ssize_t
615 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
616 {
617         const struct xattr_handler *handler;
618
619         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
620         if (!handler)
621                 return -EOPNOTSUPP;
622         return handler->get(dentry, name, buffer, size, handler->flags);
623 }
624
625 /*
626  * Combine the results of the list() operation from every xattr_handler in the
627  * list.
628  */
629 ssize_t
630 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
631 {
632         const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
633         unsigned int size = 0;
634
635         if (!buffer) {
636                 for_each_xattr_handler(handlers, handler) {
637                         size += handler->list(dentry, NULL, 0, NULL, 0,
638                                               handler->flags);
639                 }
640         } else {
641                 char *buf = buffer;
642
643                 for_each_xattr_handler(handlers, handler) {
644                         size = handler->list(dentry, buf, buffer_size,
645                                              NULL, 0, handler->flags);
646                         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  */
659 int
660 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
661 {
662         const struct xattr_handler *handler;
663
664         if (size == 0)
665                 value = "";  /* empty EA, do not remove */
666         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
667         if (!handler)
668                 return -EOPNOTSUPP;
669         return handler->set(dentry, name, value, size, 0, handler->flags);
670 }
671
672 /*
673  * Find the handler for the prefix and dispatch its set() operation to remove
674  * any associated extended attribute.
675  */
676 int
677 generic_removexattr(struct dentry *dentry, const char *name)
678 {
679         const struct xattr_handler *handler;
680
681         handler = xattr_resolve_name(dentry->d_sb->s_xattr, &name);
682         if (!handler)
683                 return -EOPNOTSUPP;
684         return handler->set(dentry, name, NULL, 0,
685                             XATTR_REPLACE, handler->flags);
686 }
687
688 EXPORT_SYMBOL(generic_getxattr);
689 EXPORT_SYMBOL(generic_listxattr);
690 EXPORT_SYMBOL(generic_setxattr);
691 EXPORT_SYMBOL(generic_removexattr);