46fc1c20a6b1c65ccd72a8f18106283b01197916
[linux-3.10.git] / fs / reiserfs / xattr.c
1 /*
2  * linux/fs/reiserfs/xattr.c
3  *
4  * Copyright (c) 2002 by Jeff Mahoney, <jeffm@suse.com>
5  *
6  */
7
8 /*
9  * In order to implement EA/ACLs in a clean, backwards compatible manner,
10  * they are implemented as files in a "private" directory.
11  * Each EA is in it's own file, with the directory layout like so (/ is assumed
12  * to be relative to fs root). Inside the /.reiserfs_priv/xattrs directory,
13  * directories named using the capital-hex form of the objectid and
14  * generation number are used. Inside each directory are individual files
15  * named with the name of the extended attribute.
16  *
17  * So, for objectid 12648430, we could have:
18  * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_access
19  * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_default
20  * /.reiserfs_priv/xattrs/C0FFEE.0/user.Content-Type
21  * .. or similar.
22  *
23  * The file contents are the text of the EA. The size is known based on the
24  * stat data describing the file.
25  *
26  * In the case of system.posix_acl_access and system.posix_acl_default, since
27  * these are special cases for filesystem ACLs, they are interpreted by the
28  * kernel, in addition, they are negatively and positively cached and attached
29  * to the inode so that unnecessary lookups are avoided.
30  *
31  * Locking works like so:
32  * Directory components (xattr root, xattr dir) are protectd by their i_mutex.
33  * The xattrs themselves are protected by the xattr_sem.
34  */
35
36 #include "reiserfs.h"
37 #include <linux/capability.h>
38 #include <linux/dcache.h>
39 #include <linux/namei.h>
40 #include <linux/errno.h>
41 #include <linux/gfp.h>
42 #include <linux/fs.h>
43 #include <linux/file.h>
44 #include <linux/pagemap.h>
45 #include <linux/xattr.h>
46 #include "xattr.h"
47 #include "acl.h"
48 #include <asm/uaccess.h>
49 #include <net/checksum.h>
50 #include <linux/stat.h>
51 #include <linux/quotaops.h>
52 #include <linux/security.h>
53
54 #define PRIVROOT_NAME ".reiserfs_priv"
55 #define XAROOT_NAME   "xattrs"
56
57
58 /* Helpers for inode ops. We do this so that we don't have all the VFS
59  * overhead and also for proper i_mutex annotation.
60  * dir->i_mutex must be held for all of them. */
61 #ifdef CONFIG_REISERFS_FS_XATTR
62 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
63 {
64         BUG_ON(!mutex_is_locked(&dir->i_mutex));
65         return dir->i_op->create(dir, dentry, mode, NULL);
66 }
67 #endif
68
69 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
70 {
71         BUG_ON(!mutex_is_locked(&dir->i_mutex));
72         return dir->i_op->mkdir(dir, dentry, mode);
73 }
74
75 /* We use I_MUTEX_CHILD here to silence lockdep. It's safe because xattr
76  * mutation ops aren't called during rename or splace, which are the
77  * only other users of I_MUTEX_CHILD. It violates the ordering, but that's
78  * better than allocating another subclass just for this code. */
79 static int xattr_unlink(struct inode *dir, struct dentry *dentry)
80 {
81         int error;
82         BUG_ON(!mutex_is_locked(&dir->i_mutex));
83
84         reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
85                                         I_MUTEX_CHILD, dir->i_sb);
86         error = dir->i_op->unlink(dir, dentry);
87         mutex_unlock(&dentry->d_inode->i_mutex);
88
89         if (!error)
90                 d_delete(dentry);
91         return error;
92 }
93
94 static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
95 {
96         int error;
97         BUG_ON(!mutex_is_locked(&dir->i_mutex));
98
99         reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
100                                         I_MUTEX_CHILD, dir->i_sb);
101         error = dir->i_op->rmdir(dir, dentry);
102         if (!error)
103                 dentry->d_inode->i_flags |= S_DEAD;
104         mutex_unlock(&dentry->d_inode->i_mutex);
105         if (!error)
106                 d_delete(dentry);
107
108         return error;
109 }
110
111 #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE)
112
113 static struct dentry *open_xa_root(struct super_block *sb, int flags)
114 {
115         struct dentry *privroot = REISERFS_SB(sb)->priv_root;
116         struct dentry *xaroot;
117         if (!privroot->d_inode)
118                 return ERR_PTR(-ENODATA);
119
120         mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
121
122         xaroot = dget(REISERFS_SB(sb)->xattr_root);
123         if (!xaroot)
124                 xaroot = ERR_PTR(-ENODATA);
125         else if (!xaroot->d_inode) {
126                 int err = -ENODATA;
127                 if (xattr_may_create(flags))
128                         err = xattr_mkdir(privroot->d_inode, xaroot, 0700);
129                 if (err) {
130                         dput(xaroot);
131                         xaroot = ERR_PTR(err);
132                 }
133         }
134
135         mutex_unlock(&privroot->d_inode->i_mutex);
136         return xaroot;
137 }
138
139 static struct dentry *open_xa_dir(const struct inode *inode, int flags)
140 {
141         struct dentry *xaroot, *xadir;
142         char namebuf[17];
143
144         xaroot = open_xa_root(inode->i_sb, flags);
145         if (IS_ERR(xaroot))
146                 return xaroot;
147
148         snprintf(namebuf, sizeof(namebuf), "%X.%X",
149                  le32_to_cpu(INODE_PKEY(inode)->k_objectid),
150                  inode->i_generation);
151
152         mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
153
154         xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
155         if (!IS_ERR(xadir) && !xadir->d_inode) {
156                 int err = -ENODATA;
157                 if (xattr_may_create(flags))
158                         err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
159                 if (err) {
160                         dput(xadir);
161                         xadir = ERR_PTR(err);
162                 }
163         }
164
165         mutex_unlock(&xaroot->d_inode->i_mutex);
166         dput(xaroot);
167         return xadir;
168 }
169
170 /* The following are side effects of other operations that aren't explicitly
171  * modifying extended attributes. This includes operations such as permissions
172  * or ownership changes, object deletions, etc. */
173 struct reiserfs_dentry_buf {
174         struct dentry *xadir;
175         int count;
176         struct dentry *dentries[8];
177 };
178
179 static int
180 fill_with_dentries(void *buf, const char *name, int namelen, loff_t offset,
181                     u64 ino, unsigned int d_type)
182 {
183         struct reiserfs_dentry_buf *dbuf = buf;
184         struct dentry *dentry;
185         WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
186
187         if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
188                 return -ENOSPC;
189
190         if (name[0] == '.' && (name[1] == '\0' ||
191                                (name[1] == '.' && name[2] == '\0')))
192                 return 0;
193
194         dentry = lookup_one_len(name, dbuf->xadir, namelen);
195         if (IS_ERR(dentry)) {
196                 return PTR_ERR(dentry);
197         } else if (!dentry->d_inode) {
198                 /* A directory entry exists, but no file? */
199                 reiserfs_error(dentry->d_sb, "xattr-20003",
200                                "Corrupted directory: xattr %s listed but "
201                                "not found for file %s.\n",
202                                dentry->d_name.name, dbuf->xadir->d_name.name);
203                 dput(dentry);
204                 return -EIO;
205         }
206
207         dbuf->dentries[dbuf->count++] = dentry;
208         return 0;
209 }
210
211 static void
212 cleanup_dentry_buf(struct reiserfs_dentry_buf *buf)
213 {
214         int i;
215         for (i = 0; i < buf->count; i++)
216                 if (buf->dentries[i])
217                         dput(buf->dentries[i]);
218 }
219
220 static int reiserfs_for_each_xattr(struct inode *inode,
221                                    int (*action)(struct dentry *, void *),
222                                    void *data)
223 {
224         struct dentry *dir;
225         int i, err = 0;
226         loff_t pos = 0;
227         struct reiserfs_dentry_buf buf = {
228                 .count = 0,
229         };
230
231         /* Skip out, an xattr has no xattrs associated with it */
232         if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1)
233                 return 0;
234
235         reiserfs_write_unlock(inode->i_sb);
236         dir = open_xa_dir(inode, XATTR_REPLACE);
237         if (IS_ERR(dir)) {
238                 err = PTR_ERR(dir);
239                 reiserfs_write_lock(inode->i_sb);
240                 goto out;
241         } else if (!dir->d_inode) {
242                 err = 0;
243                 reiserfs_write_lock(inode->i_sb);
244                 goto out_dir;
245         }
246
247         mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
248
249         reiserfs_write_lock(inode->i_sb);
250
251         buf.xadir = dir;
252         err = reiserfs_readdir_dentry(dir, &buf, fill_with_dentries, &pos);
253         while ((err == 0 || err == -ENOSPC) && buf.count) {
254                 err = 0;
255
256                 for (i = 0; i < buf.count && buf.dentries[i]; i++) {
257                         int lerr = 0;
258                         struct dentry *dentry = buf.dentries[i];
259
260                         if (err == 0 && !S_ISDIR(dentry->d_inode->i_mode))
261                                 lerr = action(dentry, data);
262
263                         dput(dentry);
264                         buf.dentries[i] = NULL;
265                         err = lerr ?: err;
266                 }
267                 buf.count = 0;
268                 if (!err)
269                         err = reiserfs_readdir_dentry(dir, &buf,
270                                                       fill_with_dentries, &pos);
271         }
272         mutex_unlock(&dir->d_inode->i_mutex);
273
274         /* Clean up after a failed readdir */
275         cleanup_dentry_buf(&buf);
276
277         if (!err) {
278                 /* We start a transaction here to avoid a ABBA situation
279                  * between the xattr root's i_mutex and the journal lock.
280                  * This doesn't incur much additional overhead since the
281                  * new transaction will just nest inside the
282                  * outer transaction. */
283                 int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
284                              4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
285                 struct reiserfs_transaction_handle th;
286                 err = journal_begin(&th, inode->i_sb, blocks);
287                 if (!err) {
288                         int jerror;
289                         reiserfs_mutex_lock_nested_safe(
290                                           &dir->d_parent->d_inode->i_mutex,
291                                           I_MUTEX_XATTR, inode->i_sb);
292                         err = action(dir, data);
293                         jerror = journal_end(&th, inode->i_sb, blocks);
294                         mutex_unlock(&dir->d_parent->d_inode->i_mutex);
295                         err = jerror ?: err;
296                 }
297         }
298 out_dir:
299         dput(dir);
300 out:
301         /* -ENODATA isn't an error */
302         if (err == -ENODATA)
303                 err = 0;
304         return err;
305 }
306
307 static int delete_one_xattr(struct dentry *dentry, void *data)
308 {
309         struct inode *dir = dentry->d_parent->d_inode;
310
311         /* This is the xattr dir, handle specially. */
312         if (S_ISDIR(dentry->d_inode->i_mode))
313                 return xattr_rmdir(dir, dentry);
314
315         return xattr_unlink(dir, dentry);
316 }
317
318 static int chown_one_xattr(struct dentry *dentry, void *data)
319 {
320         struct iattr *attrs = data;
321         return reiserfs_setattr(dentry, attrs);
322 }
323
324 /* No i_mutex, but the inode is unconnected. */
325 int reiserfs_delete_xattrs(struct inode *inode)
326 {
327         int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL);
328         if (err)
329                 reiserfs_warning(inode->i_sb, "jdm-20004",
330                                  "Couldn't delete all xattrs (%d)\n", err);
331         return err;
332 }
333
334 /* inode->i_mutex: down */
335 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
336 {
337         int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs);
338         if (err)
339                 reiserfs_warning(inode->i_sb, "jdm-20007",
340                                  "Couldn't chown all xattrs (%d)\n", err);
341         return err;
342 }
343
344 #ifdef CONFIG_REISERFS_FS_XATTR
345 /* Returns a dentry corresponding to a specific extended attribute file
346  * for the inode. If flags allow, the file is created. Otherwise, a
347  * valid or negative dentry, or an error is returned. */
348 static struct dentry *xattr_lookup(struct inode *inode, const char *name,
349                                     int flags)
350 {
351         struct dentry *xadir, *xafile;
352         int err = 0;
353
354         xadir = open_xa_dir(inode, flags);
355         if (IS_ERR(xadir))
356                 return ERR_CAST(xadir);
357
358         mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
359         xafile = lookup_one_len(name, xadir, strlen(name));
360         if (IS_ERR(xafile)) {
361                 err = PTR_ERR(xafile);
362                 goto out;
363         }
364
365         if (xafile->d_inode && (flags & XATTR_CREATE))
366                 err = -EEXIST;
367
368         if (!xafile->d_inode) {
369                 err = -ENODATA;
370                 if (xattr_may_create(flags))
371                         err = xattr_create(xadir->d_inode, xafile,
372                                               0700|S_IFREG);
373         }
374
375         if (err)
376                 dput(xafile);
377 out:
378         mutex_unlock(&xadir->d_inode->i_mutex);
379         dput(xadir);
380         if (err)
381                 return ERR_PTR(err);
382         return xafile;
383 }
384
385 /* Internal operations on file data */
386 static inline void reiserfs_put_page(struct page *page)
387 {
388         kunmap(page);
389         page_cache_release(page);
390 }
391
392 static struct page *reiserfs_get_page(struct inode *dir, size_t n)
393 {
394         struct address_space *mapping = dir->i_mapping;
395         struct page *page;
396         /* We can deadlock if we try to free dentries,
397            and an unlink/rmdir has just occurred - GFP_NOFS avoids this */
398         mapping_set_gfp_mask(mapping, GFP_NOFS);
399         page = read_mapping_page(mapping, n >> PAGE_CACHE_SHIFT, NULL);
400         if (!IS_ERR(page)) {
401                 kmap(page);
402                 if (PageError(page))
403                         goto fail;
404         }
405         return page;
406
407       fail:
408         reiserfs_put_page(page);
409         return ERR_PTR(-EIO);
410 }
411
412 static inline __u32 xattr_hash(const char *msg, int len)
413 {
414         return csum_partial(msg, len, 0);
415 }
416
417 int reiserfs_commit_write(struct file *f, struct page *page,
418                           unsigned from, unsigned to);
419
420 static void update_ctime(struct inode *inode)
421 {
422         struct timespec now = current_fs_time(inode->i_sb);
423         if (inode_unhashed(inode) || !inode->i_nlink ||
424             timespec_equal(&inode->i_ctime, &now))
425                 return;
426
427         inode->i_ctime = CURRENT_TIME_SEC;
428         mark_inode_dirty(inode);
429 }
430
431 static int lookup_and_delete_xattr(struct inode *inode, const char *name)
432 {
433         int err = 0;
434         struct dentry *dentry, *xadir;
435
436         xadir = open_xa_dir(inode, XATTR_REPLACE);
437         if (IS_ERR(xadir))
438                 return PTR_ERR(xadir);
439
440         mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
441         dentry = lookup_one_len(name, xadir, strlen(name));
442         if (IS_ERR(dentry)) {
443                 err = PTR_ERR(dentry);
444                 goto out_dput;
445         }
446
447         if (dentry->d_inode) {
448                 reiserfs_write_lock(inode->i_sb);
449                 err = xattr_unlink(xadir->d_inode, dentry);
450                 reiserfs_write_unlock(inode->i_sb);
451                 update_ctime(inode);
452         }
453
454         dput(dentry);
455 out_dput:
456         mutex_unlock(&xadir->d_inode->i_mutex);
457         dput(xadir);
458         return err;
459 }
460
461
462 /* Generic extended attribute operations that can be used by xa plugins */
463
464 /*
465  * inode->i_mutex: down
466  */
467 int
468 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
469                           struct inode *inode, const char *name,
470                           const void *buffer, size_t buffer_size, int flags)
471 {
472         int err = 0;
473         struct dentry *dentry;
474         struct page *page;
475         char *data;
476         size_t file_pos = 0;
477         size_t buffer_pos = 0;
478         size_t new_size;
479         __u32 xahash = 0;
480
481         if (get_inode_sd_version(inode) == STAT_DATA_V1)
482                 return -EOPNOTSUPP;
483
484         reiserfs_write_unlock(inode->i_sb);
485
486         if (!buffer) {
487                 err = lookup_and_delete_xattr(inode, name);
488                 reiserfs_write_lock(inode->i_sb);
489                 return err;
490         }
491
492         dentry = xattr_lookup(inode, name, flags);
493         if (IS_ERR(dentry)) {
494                 reiserfs_write_lock(inode->i_sb);
495                 return PTR_ERR(dentry);
496         }
497
498         down_write(&REISERFS_I(inode)->i_xattr_sem);
499
500         reiserfs_write_lock(inode->i_sb);
501
502         xahash = xattr_hash(buffer, buffer_size);
503         while (buffer_pos < buffer_size || buffer_pos == 0) {
504                 size_t chunk;
505                 size_t skip = 0;
506                 size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1));
507                 if (buffer_size - buffer_pos > PAGE_CACHE_SIZE)
508                         chunk = PAGE_CACHE_SIZE;
509                 else
510                         chunk = buffer_size - buffer_pos;
511
512                 page = reiserfs_get_page(dentry->d_inode, file_pos);
513                 if (IS_ERR(page)) {
514                         err = PTR_ERR(page);
515                         goto out_unlock;
516                 }
517
518                 lock_page(page);
519                 data = page_address(page);
520
521                 if (file_pos == 0) {
522                         struct reiserfs_xattr_header *rxh;
523                         skip = file_pos = sizeof(struct reiserfs_xattr_header);
524                         if (chunk + skip > PAGE_CACHE_SIZE)
525                                 chunk = PAGE_CACHE_SIZE - skip;
526                         rxh = (struct reiserfs_xattr_header *)data;
527                         rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
528                         rxh->h_hash = cpu_to_le32(xahash);
529                 }
530
531                 err = __reiserfs_write_begin(page, page_offset, chunk + skip);
532                 if (!err) {
533                         if (buffer)
534                                 memcpy(data + skip, buffer + buffer_pos, chunk);
535                         err = reiserfs_commit_write(NULL, page, page_offset,
536                                                     page_offset + chunk +
537                                                     skip);
538                 }
539                 unlock_page(page);
540                 reiserfs_put_page(page);
541                 buffer_pos += chunk;
542                 file_pos += chunk;
543                 skip = 0;
544                 if (err || buffer_size == 0 || !buffer)
545                         break;
546         }
547
548         new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
549         if (!err && new_size < i_size_read(dentry->d_inode)) {
550                 struct iattr newattrs = {
551                         .ia_ctime = current_fs_time(inode->i_sb),
552                         .ia_size = new_size,
553                         .ia_valid = ATTR_SIZE | ATTR_CTIME,
554                 };
555
556                 reiserfs_write_unlock(inode->i_sb);
557                 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
558                 inode_dio_wait(dentry->d_inode);
559                 reiserfs_write_lock(inode->i_sb);
560
561                 err = reiserfs_setattr(dentry, &newattrs);
562                 mutex_unlock(&dentry->d_inode->i_mutex);
563         } else
564                 update_ctime(inode);
565 out_unlock:
566         up_write(&REISERFS_I(inode)->i_xattr_sem);
567         dput(dentry);
568         return err;
569 }
570
571 /* We need to start a transaction to maintain lock ordering */
572 int reiserfs_xattr_set(struct inode *inode, const char *name,
573                        const void *buffer, size_t buffer_size, int flags)
574 {
575
576         struct reiserfs_transaction_handle th;
577         int error, error2;
578         size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size);
579
580         if (!(flags & XATTR_REPLACE))
581                 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode);
582
583         reiserfs_write_lock(inode->i_sb);
584         error = journal_begin(&th, inode->i_sb, jbegin_count);
585         if (error) {
586                 reiserfs_write_unlock(inode->i_sb);
587                 return error;
588         }
589
590         error = reiserfs_xattr_set_handle(&th, inode, name,
591                                           buffer, buffer_size, flags);
592
593         error2 = journal_end(&th, inode->i_sb, jbegin_count);
594         if (error == 0)
595                 error = error2;
596         reiserfs_write_unlock(inode->i_sb);
597
598         return error;
599 }
600
601 /*
602  * inode->i_mutex: down
603  */
604 int
605 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
606                    size_t buffer_size)
607 {
608         ssize_t err = 0;
609         struct dentry *dentry;
610         size_t isize;
611         size_t file_pos = 0;
612         size_t buffer_pos = 0;
613         struct page *page;
614         __u32 hash = 0;
615
616         if (name == NULL)
617                 return -EINVAL;
618
619         /* We can't have xattrs attached to v1 items since they don't have
620          * generation numbers */
621         if (get_inode_sd_version(inode) == STAT_DATA_V1)
622                 return -EOPNOTSUPP;
623
624         dentry = xattr_lookup(inode, name, XATTR_REPLACE);
625         if (IS_ERR(dentry)) {
626                 err = PTR_ERR(dentry);
627                 goto out;
628         }
629
630         down_read(&REISERFS_I(inode)->i_xattr_sem);
631
632         isize = i_size_read(dentry->d_inode);
633
634         /* Just return the size needed */
635         if (buffer == NULL) {
636                 err = isize - sizeof(struct reiserfs_xattr_header);
637                 goto out_unlock;
638         }
639
640         if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
641                 err = -ERANGE;
642                 goto out_unlock;
643         }
644
645         while (file_pos < isize) {
646                 size_t chunk;
647                 char *data;
648                 size_t skip = 0;
649                 if (isize - file_pos > PAGE_CACHE_SIZE)
650                         chunk = PAGE_CACHE_SIZE;
651                 else
652                         chunk = isize - file_pos;
653
654                 page = reiserfs_get_page(dentry->d_inode, file_pos);
655                 if (IS_ERR(page)) {
656                         err = PTR_ERR(page);
657                         goto out_unlock;
658                 }
659
660                 lock_page(page);
661                 data = page_address(page);
662                 if (file_pos == 0) {
663                         struct reiserfs_xattr_header *rxh =
664                             (struct reiserfs_xattr_header *)data;
665                         skip = file_pos = sizeof(struct reiserfs_xattr_header);
666                         chunk -= skip;
667                         /* Magic doesn't match up.. */
668                         if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
669                                 unlock_page(page);
670                                 reiserfs_put_page(page);
671                                 reiserfs_warning(inode->i_sb, "jdm-20001",
672                                                  "Invalid magic for xattr (%s) "
673                                                  "associated with %k", name,
674                                                  INODE_PKEY(inode));
675                                 err = -EIO;
676                                 goto out_unlock;
677                         }
678                         hash = le32_to_cpu(rxh->h_hash);
679                 }
680                 memcpy(buffer + buffer_pos, data + skip, chunk);
681                 unlock_page(page);
682                 reiserfs_put_page(page);
683                 file_pos += chunk;
684                 buffer_pos += chunk;
685                 skip = 0;
686         }
687         err = isize - sizeof(struct reiserfs_xattr_header);
688
689         if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
690             hash) {
691                 reiserfs_warning(inode->i_sb, "jdm-20002",
692                                  "Invalid hash for xattr (%s) associated "
693                                  "with %k", name, INODE_PKEY(inode));
694                 err = -EIO;
695         }
696
697 out_unlock:
698         up_read(&REISERFS_I(inode)->i_xattr_sem);
699         dput(dentry);
700
701 out:
702         return err;
703 }
704
705 /*
706  * In order to implement different sets of xattr operations for each xattr
707  * prefix with the generic xattr API, a filesystem should create a
708  * null-terminated array of struct xattr_handler (one for each prefix) and
709  * hang a pointer to it off of the s_xattr field of the superblock.
710  *
711  * The generic_fooxattr() functions will use this list to dispatch xattr
712  * operations to the correct xattr_handler.
713  */
714 #define for_each_xattr_handler(handlers, handler)               \
715                 for ((handler) = *(handlers)++;                 \
716                         (handler) != NULL;                      \
717                         (handler) = *(handlers)++)
718
719 /* This is the implementation for the xattr plugin infrastructure */
720 static inline const struct xattr_handler *
721 find_xattr_handler_prefix(const struct xattr_handler **handlers,
722                            const char *name)
723 {
724         const struct xattr_handler *xah;
725
726         if (!handlers)
727                 return NULL;
728
729         for_each_xattr_handler(handlers, xah) {
730                 if (strncmp(xah->prefix, name, strlen(xah->prefix)) == 0)
731                         break;
732         }
733
734         return xah;
735 }
736
737
738 /*
739  * Inode operation getxattr()
740  */
741 ssize_t
742 reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
743                   size_t size)
744 {
745         const struct xattr_handler *handler;
746
747         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
748
749         if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
750                 return -EOPNOTSUPP;
751
752         return handler->get(dentry, name, buffer, size, handler->flags);
753 }
754
755 /*
756  * Inode operation setxattr()
757  *
758  * dentry->d_inode->i_mutex down
759  */
760 int
761 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
762                   size_t size, int flags)
763 {
764         const struct xattr_handler *handler;
765
766         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
767
768         if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
769                 return -EOPNOTSUPP;
770
771         return handler->set(dentry, name, value, size, flags, handler->flags);
772 }
773
774 /*
775  * Inode operation removexattr()
776  *
777  * dentry->d_inode->i_mutex down
778  */
779 int reiserfs_removexattr(struct dentry *dentry, const char *name)
780 {
781         const struct xattr_handler *handler;
782         handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name);
783
784         if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
785                 return -EOPNOTSUPP;
786
787         return handler->set(dentry, name, NULL, 0, XATTR_REPLACE, handler->flags);
788 }
789
790 struct listxattr_buf {
791         size_t size;
792         size_t pos;
793         char *buf;
794         struct dentry *dentry;
795 };
796
797 static int listxattr_filler(void *buf, const char *name, int namelen,
798                             loff_t offset, u64 ino, unsigned int d_type)
799 {
800         struct listxattr_buf *b = (struct listxattr_buf *)buf;
801         size_t size;
802         if (name[0] != '.' ||
803             (namelen != 1 && (name[1] != '.' || namelen != 2))) {
804                 const struct xattr_handler *handler;
805                 handler = find_xattr_handler_prefix(b->dentry->d_sb->s_xattr,
806                                                     name);
807                 if (!handler)   /* Unsupported xattr name */
808                         return 0;
809                 if (b->buf) {
810                         size = handler->list(b->dentry, b->buf + b->pos,
811                                          b->size, name, namelen,
812                                          handler->flags);
813                         if (size > b->size)
814                                 return -ERANGE;
815                 } else {
816                         size = handler->list(b->dentry, NULL, 0, name,
817                                              namelen, handler->flags);
818                 }
819
820                 b->pos += size;
821         }
822         return 0;
823 }
824
825 /*
826  * Inode operation listxattr()
827  *
828  * We totally ignore the generic listxattr here because it would be stupid
829  * not to. Since the xattrs are organized in a directory, we can just
830  * readdir to find them.
831  */
832 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
833 {
834         struct dentry *dir;
835         int err = 0;
836         loff_t pos = 0;
837         struct listxattr_buf buf = {
838                 .dentry = dentry,
839                 .buf = buffer,
840                 .size = buffer ? size : 0,
841         };
842
843         if (!dentry->d_inode)
844                 return -EINVAL;
845
846         if (!dentry->d_sb->s_xattr ||
847             get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
848                 return -EOPNOTSUPP;
849
850         dir = open_xa_dir(dentry->d_inode, XATTR_REPLACE);
851         if (IS_ERR(dir)) {
852                 err = PTR_ERR(dir);
853                 if (err == -ENODATA)
854                         err = 0;  /* Not an error if there aren't any xattrs */
855                 goto out;
856         }
857
858         mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
859         err = reiserfs_readdir_dentry(dir, &buf, listxattr_filler, &pos);
860         mutex_unlock(&dir->d_inode->i_mutex);
861
862         if (!err)
863                 err = buf.pos;
864
865         dput(dir);
866 out:
867         return err;
868 }
869
870 static int create_privroot(struct dentry *dentry)
871 {
872         int err;
873         struct inode *inode = dentry->d_parent->d_inode;
874         WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
875
876         err = xattr_mkdir(inode, dentry, 0700);
877         if (err || !dentry->d_inode) {
878                 reiserfs_warning(dentry->d_sb, "jdm-20006",
879                                  "xattrs/ACLs enabled and couldn't "
880                                  "find/create .reiserfs_priv. "
881                                  "Failing mount.");
882                 return -EOPNOTSUPP;
883         }
884
885         dentry->d_inode->i_flags |= S_PRIVATE;
886         reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
887                       "storage.\n", PRIVROOT_NAME);
888
889         return 0;
890 }
891
892 #else
893 int __init reiserfs_xattr_register_handlers(void) { return 0; }
894 void reiserfs_xattr_unregister_handlers(void) {}
895 static int create_privroot(struct dentry *dentry) { return 0; }
896 #endif
897
898 /* Actual operations that are exported to VFS-land */
899 const struct xattr_handler *reiserfs_xattr_handlers[] = {
900 #ifdef CONFIG_REISERFS_FS_XATTR
901         &reiserfs_xattr_user_handler,
902         &reiserfs_xattr_trusted_handler,
903 #endif
904 #ifdef CONFIG_REISERFS_FS_SECURITY
905         &reiserfs_xattr_security_handler,
906 #endif
907 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
908         &reiserfs_posix_acl_access_handler,
909         &reiserfs_posix_acl_default_handler,
910 #endif
911         NULL
912 };
913
914 static int xattr_mount_check(struct super_block *s)
915 {
916         /* We need generation numbers to ensure that the oid mapping is correct
917          * v3.5 filesystems don't have them. */
918         if (old_format_only(s)) {
919                 if (reiserfs_xattrs_optional(s)) {
920                         /* Old format filesystem, but optional xattrs have
921                          * been enabled. Error out. */
922                         reiserfs_warning(s, "jdm-2005",
923                                          "xattrs/ACLs not supported "
924                                          "on pre-v3.6 format filesystems. "
925                                          "Failing mount.");
926                         return -EOPNOTSUPP;
927                 }
928         }
929
930         return 0;
931 }
932
933 int reiserfs_permission(struct inode *inode, int mask)
934 {
935         /*
936          * We don't do permission checks on the internal objects.
937          * Permissions are determined by the "owning" object.
938          */
939         if (IS_PRIVATE(inode))
940                 return 0;
941
942         return generic_permission(inode, mask);
943 }
944
945 static int xattr_hide_revalidate(struct dentry *dentry, struct nameidata *nd)
946 {
947         return -EPERM;
948 }
949
950 static const struct dentry_operations xattr_lookup_poison_ops = {
951         .d_revalidate = xattr_hide_revalidate,
952 };
953
954 int reiserfs_lookup_privroot(struct super_block *s)
955 {
956         struct dentry *dentry;
957         int err = 0;
958
959         /* If we don't have the privroot located yet - go find it */
960         reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
961         dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
962                                 strlen(PRIVROOT_NAME));
963         if (!IS_ERR(dentry)) {
964                 REISERFS_SB(s)->priv_root = dentry;
965                 d_set_d_op(dentry, &xattr_lookup_poison_ops);
966                 if (dentry->d_inode)
967                         dentry->d_inode->i_flags |= S_PRIVATE;
968         } else
969                 err = PTR_ERR(dentry);
970         mutex_unlock(&s->s_root->d_inode->i_mutex);
971
972         return err;
973 }
974
975 /* We need to take a copy of the mount flags since things like
976  * MS_RDONLY don't get set until *after* we're called.
977  * mount_flags != mount_options */
978 int reiserfs_xattr_init(struct super_block *s, int mount_flags)
979 {
980         int err = 0;
981         struct dentry *privroot = REISERFS_SB(s)->priv_root;
982
983         err = xattr_mount_check(s);
984         if (err)
985                 goto error;
986
987         if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
988                 reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
989                 err = create_privroot(REISERFS_SB(s)->priv_root);
990                 mutex_unlock(&s->s_root->d_inode->i_mutex);
991         }
992
993         if (privroot->d_inode) {
994                 s->s_xattr = reiserfs_xattr_handlers;
995                 reiserfs_mutex_lock_safe(&privroot->d_inode->i_mutex, s);
996                 if (!REISERFS_SB(s)->xattr_root) {
997                         struct dentry *dentry;
998                         dentry = lookup_one_len(XAROOT_NAME, privroot,
999                                                 strlen(XAROOT_NAME));
1000                         if (!IS_ERR(dentry))
1001                                 REISERFS_SB(s)->xattr_root = dentry;
1002                         else
1003                                 err = PTR_ERR(dentry);
1004                 }
1005                 mutex_unlock(&privroot->d_inode->i_mutex);
1006         }
1007
1008 error:
1009         if (err) {
1010                 clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt));
1011                 clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt));
1012         }
1013
1014         /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1015         if (reiserfs_posixacl(s))
1016                 s->s_flags |= MS_POSIXACL;
1017         else
1018                 s->s_flags &= ~MS_POSIXACL;
1019
1020         return err;
1021 }