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