This source file includes following definitions.
- xattr_create
- xattr_mkdir
- xattr_unlink
- xattr_rmdir
- open_xa_root
- open_xa_dir
- fill_with_dentries
- cleanup_dentry_buf
- reiserfs_for_each_xattr
- delete_one_xattr
- chown_one_xattr
- reiserfs_delete_xattrs
- reiserfs_chown_xattrs
- xattr_lookup
- reiserfs_put_page
- reiserfs_get_page
- xattr_hash
- update_ctime
- lookup_and_delete_xattr
- reiserfs_xattr_set_handle
- reiserfs_xattr_set
- reiserfs_xattr_get
- find_xattr_handler_prefix
- listxattr_filler
- reiserfs_listxattr
- create_privroot
- reiserfs_xattr_register_handlers
- reiserfs_xattr_unregister_handlers
- create_privroot
- xattr_mount_check
- reiserfs_permission
- xattr_hide_revalidate
- reiserfs_lookup_privroot
- reiserfs_xattr_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37 #include "reiserfs.h"
38 #include <linux/capability.h>
39 #include <linux/dcache.h>
40 #include <linux/namei.h>
41 #include <linux/errno.h>
42 #include <linux/gfp.h>
43 #include <linux/fs.h>
44 #include <linux/file.h>
45 #include <linux/pagemap.h>
46 #include <linux/xattr.h>
47 #include "xattr.h"
48 #include "acl.h"
49 #include <linux/uaccess.h>
50 #include <net/checksum.h>
51 #include <linux/stat.h>
52 #include <linux/quotaops.h>
53 #include <linux/security.h>
54 #include <linux/posix_acl_xattr.h>
55
56 #define PRIVROOT_NAME ".reiserfs_priv"
57 #define XAROOT_NAME "xattrs"
58
59
60
61
62
63
64
65 #ifdef CONFIG_REISERFS_FS_XATTR
66 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode)
67 {
68 BUG_ON(!inode_is_locked(dir));
69 return dir->i_op->create(dir, dentry, mode, true);
70 }
71 #endif
72
73 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
74 {
75 BUG_ON(!inode_is_locked(dir));
76 return dir->i_op->mkdir(dir, dentry, mode);
77 }
78
79
80
81
82
83
84
85 static int xattr_unlink(struct inode *dir, struct dentry *dentry)
86 {
87 int error;
88
89 BUG_ON(!inode_is_locked(dir));
90
91 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
92 error = dir->i_op->unlink(dir, dentry);
93 inode_unlock(d_inode(dentry));
94
95 if (!error)
96 d_delete(dentry);
97 return error;
98 }
99
100 static int xattr_rmdir(struct inode *dir, struct dentry *dentry)
101 {
102 int error;
103
104 BUG_ON(!inode_is_locked(dir));
105
106 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD);
107 error = dir->i_op->rmdir(dir, dentry);
108 if (!error)
109 d_inode(dentry)->i_flags |= S_DEAD;
110 inode_unlock(d_inode(dentry));
111 if (!error)
112 d_delete(dentry);
113
114 return error;
115 }
116
117 #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE)
118
119 static struct dentry *open_xa_root(struct super_block *sb, int flags)
120 {
121 struct dentry *privroot = REISERFS_SB(sb)->priv_root;
122 struct dentry *xaroot;
123
124 if (d_really_is_negative(privroot))
125 return ERR_PTR(-EOPNOTSUPP);
126
127 inode_lock_nested(d_inode(privroot), I_MUTEX_XATTR);
128
129 xaroot = dget(REISERFS_SB(sb)->xattr_root);
130 if (!xaroot)
131 xaroot = ERR_PTR(-EOPNOTSUPP);
132 else if (d_really_is_negative(xaroot)) {
133 int err = -ENODATA;
134
135 if (xattr_may_create(flags))
136 err = xattr_mkdir(d_inode(privroot), xaroot, 0700);
137 if (err) {
138 dput(xaroot);
139 xaroot = ERR_PTR(err);
140 }
141 }
142
143 inode_unlock(d_inode(privroot));
144 return xaroot;
145 }
146
147 static struct dentry *open_xa_dir(const struct inode *inode, int flags)
148 {
149 struct dentry *xaroot, *xadir;
150 char namebuf[17];
151
152 xaroot = open_xa_root(inode->i_sb, flags);
153 if (IS_ERR(xaroot))
154 return xaroot;
155
156 snprintf(namebuf, sizeof(namebuf), "%X.%X",
157 le32_to_cpu(INODE_PKEY(inode)->k_objectid),
158 inode->i_generation);
159
160 inode_lock_nested(d_inode(xaroot), I_MUTEX_XATTR);
161
162 xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
163 if (!IS_ERR(xadir) && d_really_is_negative(xadir)) {
164 int err = -ENODATA;
165
166 if (xattr_may_create(flags))
167 err = xattr_mkdir(d_inode(xaroot), xadir, 0700);
168 if (err) {
169 dput(xadir);
170 xadir = ERR_PTR(err);
171 }
172 }
173
174 inode_unlock(d_inode(xaroot));
175 dput(xaroot);
176 return xadir;
177 }
178
179
180
181
182
183
184 struct reiserfs_dentry_buf {
185 struct dir_context ctx;
186 struct dentry *xadir;
187 int count;
188 int err;
189 struct dentry *dentries[8];
190 };
191
192 static int
193 fill_with_dentries(struct dir_context *ctx, const char *name, int namelen,
194 loff_t offset, u64 ino, unsigned int d_type)
195 {
196 struct reiserfs_dentry_buf *dbuf =
197 container_of(ctx, struct reiserfs_dentry_buf, ctx);
198 struct dentry *dentry;
199
200 WARN_ON_ONCE(!inode_is_locked(d_inode(dbuf->xadir)));
201
202 if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
203 return -ENOSPC;
204
205 if (name[0] == '.' && (namelen < 2 ||
206 (namelen == 2 && name[1] == '.')))
207 return 0;
208
209 dentry = lookup_one_len(name, dbuf->xadir, namelen);
210 if (IS_ERR(dentry)) {
211 dbuf->err = PTR_ERR(dentry);
212 return PTR_ERR(dentry);
213 } else if (d_really_is_negative(dentry)) {
214
215 reiserfs_error(dentry->d_sb, "xattr-20003",
216 "Corrupted directory: xattr %pd listed but "
217 "not found for file %pd.\n",
218 dentry, dbuf->xadir);
219 dput(dentry);
220 dbuf->err = -EIO;
221 return -EIO;
222 }
223
224 dbuf->dentries[dbuf->count++] = dentry;
225 return 0;
226 }
227
228 static void
229 cleanup_dentry_buf(struct reiserfs_dentry_buf *buf)
230 {
231 int i;
232
233 for (i = 0; i < buf->count; i++)
234 if (buf->dentries[i])
235 dput(buf->dentries[i]);
236 }
237
238 static int reiserfs_for_each_xattr(struct inode *inode,
239 int (*action)(struct dentry *, void *),
240 void *data)
241 {
242 struct dentry *dir;
243 int i, err = 0;
244 struct reiserfs_dentry_buf buf = {
245 .ctx.actor = fill_with_dentries,
246 };
247
248
249 if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1)
250 return 0;
251
252 dir = open_xa_dir(inode, XATTR_REPLACE);
253 if (IS_ERR(dir)) {
254 err = PTR_ERR(dir);
255 goto out;
256 } else if (d_really_is_negative(dir)) {
257 err = 0;
258 goto out_dir;
259 }
260
261 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
262
263 buf.xadir = dir;
264 while (1) {
265 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
266 if (err)
267 break;
268 if (buf.err) {
269 err = buf.err;
270 break;
271 }
272 if (!buf.count)
273 break;
274 for (i = 0; !err && i < buf.count && buf.dentries[i]; i++) {
275 struct dentry *dentry = buf.dentries[i];
276
277 if (!d_is_dir(dentry))
278 err = action(dentry, data);
279
280 dput(dentry);
281 buf.dentries[i] = NULL;
282 }
283 if (err)
284 break;
285 buf.count = 0;
286 }
287 inode_unlock(d_inode(dir));
288
289 cleanup_dentry_buf(&buf);
290
291 if (!err) {
292
293
294
295
296
297
298
299 int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
300 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
301 struct reiserfs_transaction_handle th;
302
303 reiserfs_write_lock(inode->i_sb);
304 err = journal_begin(&th, inode->i_sb, blocks);
305 reiserfs_write_unlock(inode->i_sb);
306 if (!err) {
307 int jerror;
308
309 inode_lock_nested(d_inode(dir->d_parent),
310 I_MUTEX_XATTR);
311 err = action(dir, data);
312 reiserfs_write_lock(inode->i_sb);
313 jerror = journal_end(&th);
314 reiserfs_write_unlock(inode->i_sb);
315 inode_unlock(d_inode(dir->d_parent));
316 err = jerror ?: err;
317 }
318 }
319 out_dir:
320 dput(dir);
321 out:
322
323
324
325
326
327 if (err == -ENODATA || err == -EOPNOTSUPP)
328 err = 0;
329 return err;
330 }
331
332 static int delete_one_xattr(struct dentry *dentry, void *data)
333 {
334 struct inode *dir = d_inode(dentry->d_parent);
335
336
337 if (d_is_dir(dentry))
338 return xattr_rmdir(dir, dentry);
339
340 return xattr_unlink(dir, dentry);
341 }
342
343 static int chown_one_xattr(struct dentry *dentry, void *data)
344 {
345 struct iattr *attrs = data;
346 int ia_valid = attrs->ia_valid;
347 int err;
348
349
350
351
352
353
354 attrs->ia_valid &= (ATTR_UID|ATTR_GID);
355 err = reiserfs_setattr(dentry, attrs);
356 attrs->ia_valid = ia_valid;
357
358 return err;
359 }
360
361
362 int reiserfs_delete_xattrs(struct inode *inode)
363 {
364 int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL);
365
366 if (err)
367 reiserfs_warning(inode->i_sb, "jdm-20004",
368 "Couldn't delete all xattrs (%d)\n", err);
369 return err;
370 }
371
372
373 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
374 {
375 int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs);
376
377 if (err)
378 reiserfs_warning(inode->i_sb, "jdm-20007",
379 "Couldn't chown all xattrs (%d)\n", err);
380 return err;
381 }
382
383 #ifdef CONFIG_REISERFS_FS_XATTR
384
385
386
387
388
389 static struct dentry *xattr_lookup(struct inode *inode, const char *name,
390 int flags)
391 {
392 struct dentry *xadir, *xafile;
393 int err = 0;
394
395 xadir = open_xa_dir(inode, flags);
396 if (IS_ERR(xadir))
397 return ERR_CAST(xadir);
398
399 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
400 xafile = lookup_one_len(name, xadir, strlen(name));
401 if (IS_ERR(xafile)) {
402 err = PTR_ERR(xafile);
403 goto out;
404 }
405
406 if (d_really_is_positive(xafile) && (flags & XATTR_CREATE))
407 err = -EEXIST;
408
409 if (d_really_is_negative(xafile)) {
410 err = -ENODATA;
411 if (xattr_may_create(flags))
412 err = xattr_create(d_inode(xadir), xafile,
413 0700|S_IFREG);
414 }
415
416 if (err)
417 dput(xafile);
418 out:
419 inode_unlock(d_inode(xadir));
420 dput(xadir);
421 if (err)
422 return ERR_PTR(err);
423 return xafile;
424 }
425
426
427 static inline void reiserfs_put_page(struct page *page)
428 {
429 kunmap(page);
430 put_page(page);
431 }
432
433 static struct page *reiserfs_get_page(struct inode *dir, size_t n)
434 {
435 struct address_space *mapping = dir->i_mapping;
436 struct page *page;
437
438
439
440
441 mapping_set_gfp_mask(mapping, GFP_NOFS);
442 page = read_mapping_page(mapping, n >> PAGE_SHIFT, NULL);
443 if (!IS_ERR(page)) {
444 kmap(page);
445 if (PageError(page))
446 goto fail;
447 }
448 return page;
449
450 fail:
451 reiserfs_put_page(page);
452 return ERR_PTR(-EIO);
453 }
454
455 static inline __u32 xattr_hash(const char *msg, int len)
456 {
457
458
459
460
461
462
463
464
465
466 return csum_partial(msg, len, 0);
467 }
468
469 int reiserfs_commit_write(struct file *f, struct page *page,
470 unsigned from, unsigned to);
471
472 static void update_ctime(struct inode *inode)
473 {
474 struct timespec64 now = current_time(inode);
475
476 if (inode_unhashed(inode) || !inode->i_nlink ||
477 timespec64_equal(&inode->i_ctime, &now))
478 return;
479
480 inode->i_ctime = current_time(inode);
481 mark_inode_dirty(inode);
482 }
483
484 static int lookup_and_delete_xattr(struct inode *inode, const char *name)
485 {
486 int err = 0;
487 struct dentry *dentry, *xadir;
488
489 xadir = open_xa_dir(inode, XATTR_REPLACE);
490 if (IS_ERR(xadir))
491 return PTR_ERR(xadir);
492
493 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR);
494 dentry = lookup_one_len(name, xadir, strlen(name));
495 if (IS_ERR(dentry)) {
496 err = PTR_ERR(dentry);
497 goto out_dput;
498 }
499
500 if (d_really_is_positive(dentry)) {
501 err = xattr_unlink(d_inode(xadir), dentry);
502 update_ctime(inode);
503 }
504
505 dput(dentry);
506 out_dput:
507 inode_unlock(d_inode(xadir));
508 dput(xadir);
509 return err;
510 }
511
512
513
514
515
516
517
518 int
519 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
520 struct inode *inode, const char *name,
521 const void *buffer, size_t buffer_size, int flags)
522 {
523 int err = 0;
524 struct dentry *dentry;
525 struct page *page;
526 char *data;
527 size_t file_pos = 0;
528 size_t buffer_pos = 0;
529 size_t new_size;
530 __u32 xahash = 0;
531
532 if (get_inode_sd_version(inode) == STAT_DATA_V1)
533 return -EOPNOTSUPP;
534
535 if (!buffer) {
536 err = lookup_and_delete_xattr(inode, name);
537 return err;
538 }
539
540 dentry = xattr_lookup(inode, name, flags);
541 if (IS_ERR(dentry))
542 return PTR_ERR(dentry);
543
544 down_write(&REISERFS_I(inode)->i_xattr_sem);
545
546 xahash = xattr_hash(buffer, buffer_size);
547 while (buffer_pos < buffer_size || buffer_pos == 0) {
548 size_t chunk;
549 size_t skip = 0;
550 size_t page_offset = (file_pos & (PAGE_SIZE - 1));
551
552 if (buffer_size - buffer_pos > PAGE_SIZE)
553 chunk = PAGE_SIZE;
554 else
555 chunk = buffer_size - buffer_pos;
556
557 page = reiserfs_get_page(d_inode(dentry), file_pos);
558 if (IS_ERR(page)) {
559 err = PTR_ERR(page);
560 goto out_unlock;
561 }
562
563 lock_page(page);
564 data = page_address(page);
565
566 if (file_pos == 0) {
567 struct reiserfs_xattr_header *rxh;
568
569 skip = file_pos = sizeof(struct reiserfs_xattr_header);
570 if (chunk + skip > PAGE_SIZE)
571 chunk = PAGE_SIZE - skip;
572 rxh = (struct reiserfs_xattr_header *)data;
573 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
574 rxh->h_hash = cpu_to_le32(xahash);
575 }
576
577 reiserfs_write_lock(inode->i_sb);
578 err = __reiserfs_write_begin(page, page_offset, chunk + skip);
579 if (!err) {
580 if (buffer)
581 memcpy(data + skip, buffer + buffer_pos, chunk);
582 err = reiserfs_commit_write(NULL, page, page_offset,
583 page_offset + chunk +
584 skip);
585 }
586 reiserfs_write_unlock(inode->i_sb);
587 unlock_page(page);
588 reiserfs_put_page(page);
589 buffer_pos += chunk;
590 file_pos += chunk;
591 skip = 0;
592 if (err || buffer_size == 0 || !buffer)
593 break;
594 }
595
596 new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
597 if (!err && new_size < i_size_read(d_inode(dentry))) {
598 struct iattr newattrs = {
599 .ia_ctime = current_time(inode),
600 .ia_size = new_size,
601 .ia_valid = ATTR_SIZE | ATTR_CTIME,
602 };
603
604 inode_lock_nested(d_inode(dentry), I_MUTEX_XATTR);
605 inode_dio_wait(d_inode(dentry));
606
607 err = reiserfs_setattr(dentry, &newattrs);
608 inode_unlock(d_inode(dentry));
609 } else
610 update_ctime(inode);
611 out_unlock:
612 up_write(&REISERFS_I(inode)->i_xattr_sem);
613 dput(dentry);
614 return err;
615 }
616
617
618 int reiserfs_xattr_set(struct inode *inode, const char *name,
619 const void *buffer, size_t buffer_size, int flags)
620 {
621
622 struct reiserfs_transaction_handle th;
623 int error, error2;
624 size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size);
625
626
627 if (!d_really_is_positive(REISERFS_SB(inode->i_sb)->priv_root))
628 return -EOPNOTSUPP;
629
630 if (!(flags & XATTR_REPLACE))
631 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode);
632
633 reiserfs_write_lock(inode->i_sb);
634 error = journal_begin(&th, inode->i_sb, jbegin_count);
635 reiserfs_write_unlock(inode->i_sb);
636 if (error) {
637 return error;
638 }
639
640 error = reiserfs_xattr_set_handle(&th, inode, name,
641 buffer, buffer_size, flags);
642
643 reiserfs_write_lock(inode->i_sb);
644 error2 = journal_end(&th);
645 reiserfs_write_unlock(inode->i_sb);
646 if (error == 0)
647 error = error2;
648
649 return error;
650 }
651
652
653
654
655 int
656 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
657 size_t buffer_size)
658 {
659 ssize_t err = 0;
660 struct dentry *dentry;
661 size_t isize;
662 size_t file_pos = 0;
663 size_t buffer_pos = 0;
664 struct page *page;
665 __u32 hash = 0;
666
667 if (name == NULL)
668 return -EINVAL;
669
670
671
672
673
674 if (get_inode_sd_version(inode) == STAT_DATA_V1)
675 return -EOPNOTSUPP;
676
677 dentry = xattr_lookup(inode, name, XATTR_REPLACE);
678 if (IS_ERR(dentry)) {
679 err = PTR_ERR(dentry);
680 goto out;
681 }
682
683 down_read(&REISERFS_I(inode)->i_xattr_sem);
684
685 isize = i_size_read(d_inode(dentry));
686
687
688 if (buffer == NULL) {
689 err = isize - sizeof(struct reiserfs_xattr_header);
690 goto out_unlock;
691 }
692
693 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
694 err = -ERANGE;
695 goto out_unlock;
696 }
697
698 while (file_pos < isize) {
699 size_t chunk;
700 char *data;
701 size_t skip = 0;
702
703 if (isize - file_pos > PAGE_SIZE)
704 chunk = PAGE_SIZE;
705 else
706 chunk = isize - file_pos;
707
708 page = reiserfs_get_page(d_inode(dentry), file_pos);
709 if (IS_ERR(page)) {
710 err = PTR_ERR(page);
711 goto out_unlock;
712 }
713
714 lock_page(page);
715 data = page_address(page);
716 if (file_pos == 0) {
717 struct reiserfs_xattr_header *rxh =
718 (struct reiserfs_xattr_header *)data;
719 skip = file_pos = sizeof(struct reiserfs_xattr_header);
720 chunk -= skip;
721
722 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
723 unlock_page(page);
724 reiserfs_put_page(page);
725 reiserfs_warning(inode->i_sb, "jdm-20001",
726 "Invalid magic for xattr (%s) "
727 "associated with %k", name,
728 INODE_PKEY(inode));
729 err = -EIO;
730 goto out_unlock;
731 }
732 hash = le32_to_cpu(rxh->h_hash);
733 }
734 memcpy(buffer + buffer_pos, data + skip, chunk);
735 unlock_page(page);
736 reiserfs_put_page(page);
737 file_pos += chunk;
738 buffer_pos += chunk;
739 skip = 0;
740 }
741 err = isize - sizeof(struct reiserfs_xattr_header);
742
743 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
744 hash) {
745 reiserfs_warning(inode->i_sb, "jdm-20002",
746 "Invalid hash for xattr (%s) associated "
747 "with %k", name, INODE_PKEY(inode));
748 err = -EIO;
749 }
750
751 out_unlock:
752 up_read(&REISERFS_I(inode)->i_xattr_sem);
753 dput(dentry);
754
755 out:
756 return err;
757 }
758
759
760
761
762
763
764
765
766
767
768 #define for_each_xattr_handler(handlers, handler) \
769 for ((handler) = *(handlers)++; \
770 (handler) != NULL; \
771 (handler) = *(handlers)++)
772
773
774 static inline const struct xattr_handler *
775 find_xattr_handler_prefix(const struct xattr_handler **handlers,
776 const char *name)
777 {
778 const struct xattr_handler *xah;
779
780 if (!handlers)
781 return NULL;
782
783 for_each_xattr_handler(handlers, xah) {
784 const char *prefix = xattr_prefix(xah);
785 if (strncmp(prefix, name, strlen(prefix)) == 0)
786 break;
787 }
788
789 return xah;
790 }
791
792 struct listxattr_buf {
793 struct dir_context ctx;
794 size_t size;
795 size_t pos;
796 char *buf;
797 struct dentry *dentry;
798 };
799
800 static int listxattr_filler(struct dir_context *ctx, const char *name,
801 int namelen, loff_t offset, u64 ino,
802 unsigned int d_type)
803 {
804 struct listxattr_buf *b =
805 container_of(ctx, struct listxattr_buf, ctx);
806 size_t size;
807
808 if (name[0] != '.' ||
809 (namelen != 1 && (name[1] != '.' || namelen != 2))) {
810 const struct xattr_handler *handler;
811
812 handler = find_xattr_handler_prefix(b->dentry->d_sb->s_xattr,
813 name);
814 if (!handler ||
815 (handler->list && !handler->list(b->dentry)))
816 return 0;
817 size = namelen + 1;
818 if (b->buf) {
819 if (b->pos + size > b->size) {
820 b->pos = -ERANGE;
821 return -ERANGE;
822 }
823 memcpy(b->buf + b->pos, name, namelen);
824 b->buf[b->pos + namelen] = 0;
825 }
826 b->pos += size;
827 }
828 return 0;
829 }
830
831
832
833
834
835
836
837
838 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
839 {
840 struct dentry *dir;
841 int err = 0;
842 struct listxattr_buf buf = {
843 .ctx.actor = listxattr_filler,
844 .dentry = dentry,
845 .buf = buffer,
846 .size = buffer ? size : 0,
847 };
848
849 if (d_really_is_negative(dentry))
850 return -EINVAL;
851
852 if (get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1)
853 return -EOPNOTSUPP;
854
855 dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE);
856 if (IS_ERR(dir)) {
857 err = PTR_ERR(dir);
858 if (err == -ENODATA)
859 err = 0;
860 goto out;
861 }
862
863 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR);
864 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx);
865 inode_unlock(d_inode(dir));
866
867 if (!err)
868 err = buf.pos;
869
870 dput(dir);
871 out:
872 return err;
873 }
874
875 static int create_privroot(struct dentry *dentry)
876 {
877 int err;
878 struct inode *inode = d_inode(dentry->d_parent);
879
880 WARN_ON_ONCE(!inode_is_locked(inode));
881
882 err = xattr_mkdir(inode, dentry, 0700);
883 if (err || d_really_is_negative(dentry)) {
884 reiserfs_warning(dentry->d_sb, "jdm-20006",
885 "xattrs/ACLs enabled and couldn't "
886 "find/create .reiserfs_priv. "
887 "Failing mount.");
888 return -EOPNOTSUPP;
889 }
890
891 d_inode(dentry)->i_flags |= S_PRIVATE;
892 d_inode(dentry)->i_opflags &= ~IOP_XATTR;
893 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
894 "storage.\n", PRIVROOT_NAME);
895
896 return 0;
897 }
898
899 #else
900 int __init reiserfs_xattr_register_handlers(void) { return 0; }
901 void reiserfs_xattr_unregister_handlers(void) {}
902 static int create_privroot(struct dentry *dentry) { return 0; }
903 #endif
904
905
906 const struct xattr_handler *reiserfs_xattr_handlers[] = {
907 #ifdef CONFIG_REISERFS_FS_XATTR
908 &reiserfs_xattr_user_handler,
909 &reiserfs_xattr_trusted_handler,
910 #endif
911 #ifdef CONFIG_REISERFS_FS_SECURITY
912 &reiserfs_xattr_security_handler,
913 #endif
914 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
915 &posix_acl_access_xattr_handler,
916 &posix_acl_default_xattr_handler,
917 #endif
918 NULL
919 };
920
921 static int xattr_mount_check(struct super_block *s)
922 {
923
924
925
926
927 if (old_format_only(s)) {
928 if (reiserfs_xattrs_optional(s)) {
929
930
931
932
933 reiserfs_warning(s, "jdm-2005",
934 "xattrs/ACLs not supported "
935 "on pre-v3.6 format filesystems. "
936 "Failing mount.");
937 return -EOPNOTSUPP;
938 }
939 }
940
941 return 0;
942 }
943
944 int reiserfs_permission(struct inode *inode, int mask)
945 {
946
947
948
949
950 if (IS_PRIVATE(inode))
951 return 0;
952
953 return generic_permission(inode, mask);
954 }
955
956 static int xattr_hide_revalidate(struct dentry *dentry, unsigned int flags)
957 {
958 return -EPERM;
959 }
960
961 static const struct dentry_operations xattr_lookup_poison_ops = {
962 .d_revalidate = xattr_hide_revalidate,
963 };
964
965 int reiserfs_lookup_privroot(struct super_block *s)
966 {
967 struct dentry *dentry;
968 int err = 0;
969
970
971 inode_lock(d_inode(s->s_root));
972 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
973 strlen(PRIVROOT_NAME));
974 if (!IS_ERR(dentry)) {
975 REISERFS_SB(s)->priv_root = dentry;
976 d_set_d_op(dentry, &xattr_lookup_poison_ops);
977 if (d_really_is_positive(dentry)) {
978 d_inode(dentry)->i_flags |= S_PRIVATE;
979 d_inode(dentry)->i_opflags &= ~IOP_XATTR;
980 }
981 } else
982 err = PTR_ERR(dentry);
983 inode_unlock(d_inode(s->s_root));
984
985 return err;
986 }
987
988
989
990
991
992
993 int reiserfs_xattr_init(struct super_block *s, int mount_flags)
994 {
995 int err = 0;
996 struct dentry *privroot = REISERFS_SB(s)->priv_root;
997
998 err = xattr_mount_check(s);
999 if (err)
1000 goto error;
1001
1002 if (d_really_is_negative(privroot) && !(mount_flags & SB_RDONLY)) {
1003 inode_lock(d_inode(s->s_root));
1004 err = create_privroot(REISERFS_SB(s)->priv_root);
1005 inode_unlock(d_inode(s->s_root));
1006 }
1007
1008 if (d_really_is_positive(privroot)) {
1009 inode_lock(d_inode(privroot));
1010 if (!REISERFS_SB(s)->xattr_root) {
1011 struct dentry *dentry;
1012
1013 dentry = lookup_one_len(XAROOT_NAME, privroot,
1014 strlen(XAROOT_NAME));
1015 if (!IS_ERR(dentry))
1016 REISERFS_SB(s)->xattr_root = dentry;
1017 else
1018 err = PTR_ERR(dentry);
1019 }
1020 inode_unlock(d_inode(privroot));
1021 }
1022
1023 error:
1024 if (err) {
1025 clear_bit(REISERFS_XATTRS_USER, &REISERFS_SB(s)->s_mount_opt);
1026 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt);
1027 }
1028
1029
1030 if (reiserfs_posixacl(s))
1031 s->s_flags |= SB_POSIXACL;
1032 else
1033 s->s_flags &= ~SB_POSIXACL;
1034
1035 return err;
1036 }