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#include <linux/reiserfs_fs.h>
33#include <linux/capability.h>
34#include <linux/dcache.h>
35#include <linux/namei.h>
36#include <linux/errno.h>
37#include <linux/fs.h>
38#include <linux/file.h>
39#include <linux/pagemap.h>
40#include <linux/xattr.h>
41#include <linux/reiserfs_xattr.h>
42#include <linux/reiserfs_acl.h>
43#include <asm/uaccess.h>
44#include <net/checksum.h>
45#include <linux/smp_lock.h>
46#include <linux/stat.h>
47
48#define FL_READONLY 128
49#define FL_DIR_SEM_HELD 256
50#define PRIVROOT_NAME ".reiserfs_priv"
51#define XAROOT_NAME "xattrs"
52
53static struct reiserfs_xattr_handler *find_xattr_handler_prefix(const char
54 *prefix);
55
56
57
58
59
60
61static struct dentry *get_xa_root(struct super_block *sb, int flags)
62{
63 struct dentry *privroot = dget(REISERFS_SB(sb)->priv_root);
64 struct dentry *xaroot;
65
66
67 if (!privroot)
68 return ERR_PTR(-ENODATA);
69
70 mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
71 if (REISERFS_SB(sb)->xattr_root) {
72 xaroot = dget(REISERFS_SB(sb)->xattr_root);
73 goto out;
74 }
75
76 xaroot = lookup_one_len(XAROOT_NAME, privroot, strlen(XAROOT_NAME));
77 if (IS_ERR(xaroot)) {
78 goto out;
79 } else if (!xaroot->d_inode) {
80 int err = -ENODATA;
81 if (flags == 0 || flags & XATTR_CREATE)
82 err = privroot->d_inode->i_op->mkdir(privroot->d_inode,
83 xaroot, 0700);
84 if (err) {
85 dput(xaroot);
86 xaroot = ERR_PTR(err);
87 goto out;
88 }
89 }
90 REISERFS_SB(sb)->xattr_root = dget(xaroot);
91
92 out:
93 mutex_unlock(&privroot->d_inode->i_mutex);
94 dput(privroot);
95 return xaroot;
96}
97
98
99
100
101static struct dentry *open_xa_dir(const struct inode *inode, int flags)
102{
103 struct dentry *xaroot, *xadir;
104 char namebuf[17];
105
106 xaroot = get_xa_root(inode->i_sb, flags);
107 if (IS_ERR(xaroot))
108 return xaroot;
109
110
111 snprintf(namebuf, sizeof(namebuf), "%X.%X",
112 le32_to_cpu(INODE_PKEY(inode)->k_objectid),
113 inode->i_generation);
114 xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
115 if (IS_ERR(xadir)) {
116 dput(xaroot);
117 return xadir;
118 }
119
120 if (!xadir->d_inode) {
121 int err;
122 if (flags == 0 || flags & XATTR_CREATE) {
123
124
125
126 err =
127 xaroot->d_inode->i_op->mkdir(xaroot->d_inode, xadir,
128 0700);
129 if (err) {
130 dput(xaroot);
131 dput(xadir);
132 return ERR_PTR(err);
133 }
134 }
135 if (!xadir->d_inode) {
136 dput(xaroot);
137 dput(xadir);
138 return ERR_PTR(-ENODATA);
139 }
140 }
141
142 dput(xaroot);
143 return xadir;
144}
145
146
147
148
149static struct dentry *get_xa_file_dentry(const struct inode *inode,
150 const char *name, int flags)
151{
152 struct dentry *xadir, *xafile;
153 int err = 0;
154
155 xadir = open_xa_dir(inode, flags);
156 if (IS_ERR(xadir)) {
157 return ERR_CAST(xadir);
158 } else if (!xadir->d_inode) {
159 dput(xadir);
160 return ERR_PTR(-ENODATA);
161 }
162
163 xafile = lookup_one_len(name, xadir, strlen(name));
164 if (IS_ERR(xafile)) {
165 dput(xadir);
166 return ERR_CAST(xafile);
167 }
168
169 if (xafile->d_inode) {
170 if (flags & XATTR_CREATE) {
171 err = -EEXIST;
172 dput(xafile);
173 goto out;
174 }
175 } else if (flags & XATTR_REPLACE || flags & FL_READONLY) {
176 goto out;
177 } else {
178
179
180 err = xadir->d_inode->i_op->create(xadir->d_inode, xafile,
181 0700 | S_IFREG, NULL);
182
183 if (err) {
184 dput(xafile);
185 goto out;
186 }
187 }
188
189 out:
190 dput(xadir);
191 if (err)
192 xafile = ERR_PTR(err);
193 else if (!xafile->d_inode) {
194 dput(xafile);
195 xafile = ERR_PTR(-ENODATA);
196 }
197 return xafile;
198}
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213static int __xattr_readdir(struct inode *inode, void *dirent, filldir_t filldir)
214{
215 struct cpu_key pos_key;
216 INITIALIZE_PATH(path_to_entry);
217 struct buffer_head *bh;
218 int entry_num;
219 struct item_head *ih, tmp_ih;
220 int search_res;
221 char *local_buf;
222 loff_t next_pos;
223 char small_buf[32];
224 struct reiserfs_de_head *deh;
225 int d_reclen;
226 char *d_name;
227 off_t d_off;
228 ino_t d_ino;
229 struct reiserfs_dir_entry de;
230
231
232
233 next_pos = max_reiserfs_offset(inode);
234
235 while (1) {
236 research:
237 if (next_pos <= DOT_DOT_OFFSET)
238 break;
239 make_cpu_key(&pos_key, inode, next_pos, TYPE_DIRENTRY, 3);
240
241 search_res =
242 search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
243 &de);
244 if (search_res == IO_ERROR) {
245
246
247 pathrelse(&path_to_entry);
248 return -EIO;
249 }
250
251 if (search_res == NAME_NOT_FOUND)
252 de.de_entry_num--;
253
254 set_de_name_and_namelen(&de);
255 entry_num = de.de_entry_num;
256 deh = &(de.de_deh[entry_num]);
257
258 bh = de.de_bh;
259 ih = de.de_ih;
260
261 if (!is_direntry_le_ih(ih)) {
262 reiserfs_warning(inode->i_sb, "not direntry %h", ih);
263 break;
264 }
265 copy_item_head(&tmp_ih, ih);
266
267
268 RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
269 "vs-9000: found item %h does not match to dir we readdir %K",
270 ih, &pos_key);
271
272 if (deh_offset(deh) <= DOT_DOT_OFFSET) {
273 break;
274 }
275
276
277 next_pos = deh_offset(deh) - 1;
278
279 if (!de_visible(deh))
280
281 continue;
282
283 d_reclen = entry_length(bh, ih, entry_num);
284 d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
285 d_off = deh_offset(deh);
286 d_ino = deh_objectid(deh);
287
288 if (!d_name[d_reclen - 1])
289 d_reclen = strlen(d_name);
290
291 if (d_reclen > REISERFS_MAX_NAME(inode->i_sb->s_blocksize)) {
292
293 continue;
294 }
295
296
297 if (reiserfs_xattrs(inode->i_sb) &&
298 !old_format_only(inode->i_sb) &&
299 deh_objectid(deh) ==
300 le32_to_cpu(INODE_PKEY
301 (REISERFS_SB(inode->i_sb)->priv_root->d_inode)->
302 k_objectid))
303 continue;
304
305 if (d_reclen <= 32) {
306 local_buf = small_buf;
307 } else {
308 local_buf = kmalloc(d_reclen, GFP_NOFS);
309 if (!local_buf) {
310 pathrelse(&path_to_entry);
311 return -ENOMEM;
312 }
313 if (item_moved(&tmp_ih, &path_to_entry)) {
314 kfree(local_buf);
315
316
317 next_pos = d_off;
318 goto research;
319 }
320 }
321
322
323
324
325
326 memcpy(local_buf, d_name, d_reclen);
327
328
329
330
331
332 pathrelse(&path_to_entry);
333
334 if (filldir(dirent, local_buf, d_reclen, d_off, d_ino,
335 DT_UNKNOWN) < 0) {
336 if (local_buf != small_buf) {
337 kfree(local_buf);
338 }
339 goto end;
340 }
341 if (local_buf != small_buf) {
342 kfree(local_buf);
343 }
344 }
345
346 end:
347 pathrelse(&path_to_entry);
348 return 0;
349}
350
351
352
353
354
355
356
357static
358int xattr_readdir(struct inode *inode, filldir_t filler, void *buf)
359{
360 int res = -ENOENT;
361 mutex_lock_nested(&inode->i_mutex, I_MUTEX_XATTR);
362 if (!IS_DEADDIR(inode)) {
363 lock_kernel();
364 res = __xattr_readdir(inode, buf, filler);
365 unlock_kernel();
366 }
367 mutex_unlock(&inode->i_mutex);
368 return res;
369}
370
371
372static inline void reiserfs_put_page(struct page *page)
373{
374 kunmap(page);
375 page_cache_release(page);
376}
377
378static struct page *reiserfs_get_page(struct inode *dir, unsigned long n)
379{
380 struct address_space *mapping = dir->i_mapping;
381 struct page *page;
382
383
384 mapping_set_gfp_mask(mapping, GFP_NOFS);
385 page = read_mapping_page(mapping, n, NULL);
386 if (!IS_ERR(page)) {
387 kmap(page);
388 if (PageError(page))
389 goto fail;
390 }
391 return page;
392
393 fail:
394 reiserfs_put_page(page);
395 return ERR_PTR(-EIO);
396}
397
398static inline __u32 xattr_hash(const char *msg, int len)
399{
400 return csum_partial(msg, len, 0);
401}
402
403int reiserfs_commit_write(struct file *f, struct page *page,
404 unsigned from, unsigned to);
405int reiserfs_prepare_write(struct file *f, struct page *page,
406 unsigned from, unsigned to);
407
408
409
410
411
412
413
414int
415reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
416 size_t buffer_size, int flags)
417{
418 int err = 0;
419 struct dentry *dentry;
420 struct page *page;
421 char *data;
422 struct address_space *mapping;
423 size_t file_pos = 0;
424 size_t buffer_pos = 0;
425 struct inode *xinode;
426 struct iattr newattrs;
427 __u32 xahash = 0;
428
429 if (get_inode_sd_version(inode) == STAT_DATA_V1)
430 return -EOPNOTSUPP;
431
432
433 if (buffer && buffer_size)
434 xahash = xattr_hash(buffer, buffer_size);
435
436 open_file:
437 dentry = get_xa_file_dentry(inode, name, flags);
438 if (IS_ERR(dentry)) {
439 err = PTR_ERR(dentry);
440 goto out;
441 }
442
443 xinode = dentry->d_inode;
444 REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
445
446
447 if (xinode->i_nlink > 1) {
448 dput(dentry);
449 err = reiserfs_xattr_del(inode, name);
450 if (err < 0)
451 goto out;
452
453 if (flags & XATTR_REPLACE)
454 flags &= ~XATTR_REPLACE;
455 goto open_file;
456 }
457
458
459 newattrs.ia_size = buffer_size;
460 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
461 mutex_lock_nested(&xinode->i_mutex, I_MUTEX_XATTR);
462 err = notify_change(dentry, &newattrs);
463 if (err)
464 goto out_filp;
465
466 mapping = xinode->i_mapping;
467 while (buffer_pos < buffer_size || buffer_pos == 0) {
468 size_t chunk;
469 size_t skip = 0;
470 size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1));
471 if (buffer_size - buffer_pos > PAGE_CACHE_SIZE)
472 chunk = PAGE_CACHE_SIZE;
473 else
474 chunk = buffer_size - buffer_pos;
475
476 page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT);
477 if (IS_ERR(page)) {
478 err = PTR_ERR(page);
479 goto out_filp;
480 }
481
482 lock_page(page);
483 data = page_address(page);
484
485 if (file_pos == 0) {
486 struct reiserfs_xattr_header *rxh;
487 skip = file_pos = sizeof(struct reiserfs_xattr_header);
488 if (chunk + skip > PAGE_CACHE_SIZE)
489 chunk = PAGE_CACHE_SIZE - skip;
490 rxh = (struct reiserfs_xattr_header *)data;
491 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
492 rxh->h_hash = cpu_to_le32(xahash);
493 }
494
495 err = reiserfs_prepare_write(NULL, page, page_offset,
496 page_offset + chunk + skip);
497 if (!err) {
498 if (buffer)
499 memcpy(data + skip, buffer + buffer_pos, chunk);
500 err = reiserfs_commit_write(NULL, page, page_offset,
501 page_offset + chunk +
502 skip);
503 }
504 unlock_page(page);
505 reiserfs_put_page(page);
506 buffer_pos += chunk;
507 file_pos += chunk;
508 skip = 0;
509 if (err || buffer_size == 0 || !buffer)
510 break;
511 }
512
513
514
515
516
517 if (!hlist_unhashed(&inode->i_hash)) {
518 inode->i_ctime = CURRENT_TIME_SEC;
519 mark_inode_dirty(inode);
520 }
521
522 out_filp:
523 mutex_unlock(&xinode->i_mutex);
524 dput(dentry);
525
526 out:
527 return err;
528}
529
530
531
532
533int
534reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
535 size_t buffer_size)
536{
537 ssize_t err = 0;
538 struct dentry *dentry;
539 size_t isize;
540 size_t file_pos = 0;
541 size_t buffer_pos = 0;
542 struct page *page;
543 struct inode *xinode;
544 __u32 hash = 0;
545
546 if (name == NULL)
547 return -EINVAL;
548
549
550
551 if (get_inode_sd_version(inode) == STAT_DATA_V1)
552 return -EOPNOTSUPP;
553
554 dentry = get_xa_file_dentry(inode, name, FL_READONLY);
555 if (IS_ERR(dentry)) {
556 err = PTR_ERR(dentry);
557 goto out;
558 }
559
560 xinode = dentry->d_inode;
561 isize = xinode->i_size;
562 REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
563
564
565 if (buffer == NULL) {
566 err = isize - sizeof(struct reiserfs_xattr_header);
567 goto out_dput;
568 }
569
570 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
571 err = -ERANGE;
572 goto out_dput;
573 }
574
575 while (file_pos < isize) {
576 size_t chunk;
577 char *data;
578 size_t skip = 0;
579 if (isize - file_pos > PAGE_CACHE_SIZE)
580 chunk = PAGE_CACHE_SIZE;
581 else
582 chunk = isize - file_pos;
583
584 page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT);
585 if (IS_ERR(page)) {
586 err = PTR_ERR(page);
587 goto out_dput;
588 }
589
590 lock_page(page);
591 data = page_address(page);
592 if (file_pos == 0) {
593 struct reiserfs_xattr_header *rxh =
594 (struct reiserfs_xattr_header *)data;
595 skip = file_pos = sizeof(struct reiserfs_xattr_header);
596 chunk -= skip;
597
598 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
599 unlock_page(page);
600 reiserfs_put_page(page);
601 reiserfs_warning(inode->i_sb,
602 "Invalid magic for xattr (%s) "
603 "associated with %k", name,
604 INODE_PKEY(inode));
605 err = -EIO;
606 goto out_dput;
607 }
608 hash = le32_to_cpu(rxh->h_hash);
609 }
610 memcpy(buffer + buffer_pos, data + skip, chunk);
611 unlock_page(page);
612 reiserfs_put_page(page);
613 file_pos += chunk;
614 buffer_pos += chunk;
615 skip = 0;
616 }
617 err = isize - sizeof(struct reiserfs_xattr_header);
618
619 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
620 hash) {
621 reiserfs_warning(inode->i_sb,
622 "Invalid hash for xattr (%s) associated "
623 "with %k", name, INODE_PKEY(inode));
624 err = -EIO;
625 }
626
627 out_dput:
628 dput(dentry);
629
630 out:
631 return err;
632}
633
634static int
635__reiserfs_xattr_del(struct dentry *xadir, const char *name, int namelen)
636{
637 struct dentry *dentry;
638 struct inode *dir = xadir->d_inode;
639 int err = 0;
640
641 dentry = lookup_one_len(name, xadir, namelen);
642 if (IS_ERR(dentry)) {
643 err = PTR_ERR(dentry);
644 goto out;
645 } else if (!dentry->d_inode) {
646 err = -ENODATA;
647 goto out_file;
648 }
649
650
651 if (S_ISDIR(dentry->d_inode->i_mode))
652 goto out_file;
653
654 if (!is_reiserfs_priv_object(dentry->d_inode)) {
655 reiserfs_warning(dir->i_sb, "OID %08x [%.*s/%.*s] doesn't have "
656 "priv flag set [parent is %sset].",
657 le32_to_cpu(INODE_PKEY(dentry->d_inode)->
658 k_objectid), xadir->d_name.len,
659 xadir->d_name.name, namelen, name,
660 is_reiserfs_priv_object(xadir->
661 d_inode) ? "" :
662 "not ");
663 dput(dentry);
664 return -EIO;
665 }
666
667 err = dir->i_op->unlink(dir, dentry);
668 if (!err)
669 d_delete(dentry);
670
671 out_file:
672 dput(dentry);
673
674 out:
675 return err;
676}
677
678int reiserfs_xattr_del(struct inode *inode, const char *name)
679{
680 struct dentry *dir;
681 int err;
682
683 dir = open_xa_dir(inode, FL_READONLY);
684 if (IS_ERR(dir)) {
685 err = PTR_ERR(dir);
686 goto out;
687 }
688
689 err = __reiserfs_xattr_del(dir, name, strlen(name));
690 dput(dir);
691
692 if (!err) {
693 inode->i_ctime = CURRENT_TIME_SEC;
694 mark_inode_dirty(inode);
695 }
696
697 out:
698 return err;
699}
700
701
702
703
704
705static int
706reiserfs_delete_xattrs_filler(void *buf, const char *name, int namelen,
707 loff_t offset, u64 ino, unsigned int d_type)
708{
709 struct dentry *xadir = (struct dentry *)buf;
710
711 return __reiserfs_xattr_del(xadir, name, namelen);
712
713}
714
715
716int reiserfs_delete_xattrs(struct inode *inode)
717{
718 struct dentry *dir, *root;
719 int err = 0;
720
721
722 if (is_reiserfs_priv_object(inode) ||
723 get_inode_sd_version(inode) == STAT_DATA_V1 ||
724 !reiserfs_xattrs(inode->i_sb)) {
725 return 0;
726 }
727 reiserfs_read_lock_xattrs(inode->i_sb);
728 dir = open_xa_dir(inode, FL_READONLY);
729 reiserfs_read_unlock_xattrs(inode->i_sb);
730 if (IS_ERR(dir)) {
731 err = PTR_ERR(dir);
732 goto out;
733 } else if (!dir->d_inode) {
734 dput(dir);
735 return 0;
736 }
737
738 lock_kernel();
739 err = xattr_readdir(dir->d_inode, reiserfs_delete_xattrs_filler, dir);
740 if (err) {
741 unlock_kernel();
742 goto out_dir;
743 }
744
745
746 if (dir->d_inode->i_nlink <= 2) {
747 root = get_xa_root(inode->i_sb, XATTR_REPLACE);
748 reiserfs_write_lock_xattrs(inode->i_sb);
749 err = vfs_rmdir(root->d_inode, dir);
750 reiserfs_write_unlock_xattrs(inode->i_sb);
751 dput(root);
752 } else {
753 reiserfs_warning(inode->i_sb,
754 "Couldn't remove all entries in directory");
755 }
756 unlock_kernel();
757
758 out_dir:
759 dput(dir);
760
761 out:
762 if (!err)
763 REISERFS_I(inode)->i_flags =
764 REISERFS_I(inode)->i_flags & ~i_has_xattr_dir;
765 return err;
766}
767
768struct reiserfs_chown_buf {
769 struct inode *inode;
770 struct dentry *xadir;
771 struct iattr *attrs;
772};
773
774
775static int
776reiserfs_chown_xattrs_filler(void *buf, const char *name, int namelen,
777 loff_t offset, u64 ino, unsigned int d_type)
778{
779 struct reiserfs_chown_buf *chown_buf = (struct reiserfs_chown_buf *)buf;
780 struct dentry *xafile, *xadir = chown_buf->xadir;
781 struct iattr *attrs = chown_buf->attrs;
782 int err = 0;
783
784 xafile = lookup_one_len(name, xadir, namelen);
785 if (IS_ERR(xafile))
786 return PTR_ERR(xafile);
787 else if (!xafile->d_inode) {
788 dput(xafile);
789 return -ENODATA;
790 }
791
792 if (!S_ISDIR(xafile->d_inode->i_mode))
793 err = notify_change(xafile, attrs);
794 dput(xafile);
795
796 return err;
797}
798
799int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
800{
801 struct dentry *dir;
802 int err = 0;
803 struct reiserfs_chown_buf buf;
804 unsigned int ia_valid = attrs->ia_valid;
805
806
807 if (is_reiserfs_priv_object(inode) ||
808 get_inode_sd_version(inode) == STAT_DATA_V1 ||
809 !reiserfs_xattrs(inode->i_sb)) {
810 return 0;
811 }
812 reiserfs_read_lock_xattrs(inode->i_sb);
813 dir = open_xa_dir(inode, FL_READONLY);
814 reiserfs_read_unlock_xattrs(inode->i_sb);
815 if (IS_ERR(dir)) {
816 if (PTR_ERR(dir) != -ENODATA)
817 err = PTR_ERR(dir);
818 goto out;
819 } else if (!dir->d_inode) {
820 dput(dir);
821 goto out;
822 }
823
824 lock_kernel();
825
826 attrs->ia_valid &= (ATTR_UID | ATTR_GID | ATTR_CTIME);
827 buf.xadir = dir;
828 buf.attrs = attrs;
829 buf.inode = inode;
830
831 err = xattr_readdir(dir->d_inode, reiserfs_chown_xattrs_filler, &buf);
832 if (err) {
833 unlock_kernel();
834 goto out_dir;
835 }
836
837 err = notify_change(dir, attrs);
838 unlock_kernel();
839
840 out_dir:
841 dput(dir);
842
843 out:
844 attrs->ia_valid = ia_valid;
845 return err;
846}
847
848
849
850
851
852
853
854ssize_t
855reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
856 size_t size)
857{
858 struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
859 int err;
860
861 if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
862 get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
863 return -EOPNOTSUPP;
864
865 reiserfs_read_lock_xattr_i(dentry->d_inode);
866 reiserfs_read_lock_xattrs(dentry->d_sb);
867 err = xah->get(dentry->d_inode, name, buffer, size);
868 reiserfs_read_unlock_xattrs(dentry->d_sb);
869 reiserfs_read_unlock_xattr_i(dentry->d_inode);
870 return err;
871}
872
873
874
875
876
877
878int
879reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
880 size_t size, int flags)
881{
882 struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
883 int err;
884 int lock;
885
886 if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
887 get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
888 return -EOPNOTSUPP;
889
890 reiserfs_write_lock_xattr_i(dentry->d_inode);
891 lock = !has_xattr_dir(dentry->d_inode);
892 if (lock)
893 reiserfs_write_lock_xattrs(dentry->d_sb);
894 else
895 reiserfs_read_lock_xattrs(dentry->d_sb);
896 err = xah->set(dentry->d_inode, name, value, size, flags);
897 if (lock)
898 reiserfs_write_unlock_xattrs(dentry->d_sb);
899 else
900 reiserfs_read_unlock_xattrs(dentry->d_sb);
901 reiserfs_write_unlock_xattr_i(dentry->d_inode);
902 return err;
903}
904
905
906
907
908
909
910int reiserfs_removexattr(struct dentry *dentry, const char *name)
911{
912 int err;
913 struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
914
915 if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
916 get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
917 return -EOPNOTSUPP;
918
919 reiserfs_write_lock_xattr_i(dentry->d_inode);
920 reiserfs_read_lock_xattrs(dentry->d_sb);
921
922
923 if (xah->del) {
924 err = xah->del(dentry->d_inode, name);
925 if (err)
926 goto out;
927 }
928
929 err = reiserfs_xattr_del(dentry->d_inode, name);
930
931 dentry->d_inode->i_ctime = CURRENT_TIME_SEC;
932 mark_inode_dirty(dentry->d_inode);
933
934 out:
935 reiserfs_read_unlock_xattrs(dentry->d_sb);
936 reiserfs_write_unlock_xattr_i(dentry->d_inode);
937 return err;
938}
939
940
941
942
943
944
945struct reiserfs_listxattr_buf {
946 int r_pos;
947 int r_size;
948 char *r_buf;
949 struct inode *r_inode;
950};
951
952static int
953reiserfs_listxattr_filler(void *buf, const char *name, int namelen,
954 loff_t offset, u64 ino, unsigned int d_type)
955{
956 struct reiserfs_listxattr_buf *b = (struct reiserfs_listxattr_buf *)buf;
957 int len = 0;
958 if (name[0] != '.'
959 || (namelen != 1 && (name[1] != '.' || namelen != 2))) {
960 struct reiserfs_xattr_handler *xah =
961 find_xattr_handler_prefix(name);
962 if (!xah)
963 return 0;
964
965
966
967 len += xah->list(b->r_inode, name, namelen, NULL);
968
969 if (len) {
970 if (b->r_pos + len + 1 <= b->r_size) {
971 char *p = b->r_buf + b->r_pos;
972 p += xah->list(b->r_inode, name, namelen, p);
973 *p++ = '\0';
974 }
975 b->r_pos += len + 1;
976 }
977 }
978
979 return 0;
980}
981
982
983
984
985
986
987ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
988{
989 struct dentry *dir;
990 int err = 0;
991 struct reiserfs_listxattr_buf buf;
992
993 if (!dentry->d_inode)
994 return -EINVAL;
995
996 if (!reiserfs_xattrs(dentry->d_sb) ||
997 get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
998 return -EOPNOTSUPP;
999
1000 reiserfs_read_lock_xattr_i(dentry->d_inode);
1001 reiserfs_read_lock_xattrs(dentry->d_sb);
1002 dir = open_xa_dir(dentry->d_inode, FL_READONLY);
1003 reiserfs_read_unlock_xattrs(dentry->d_sb);
1004 if (IS_ERR(dir)) {
1005 err = PTR_ERR(dir);
1006 if (err == -ENODATA)
1007 err = 0;
1008 goto out;
1009 }
1010
1011 buf.r_buf = buffer;
1012 buf.r_size = buffer ? size : 0;
1013 buf.r_pos = 0;
1014 buf.r_inode = dentry->d_inode;
1015
1016 REISERFS_I(dentry->d_inode)->i_flags |= i_has_xattr_dir;
1017
1018 err = xattr_readdir(dir->d_inode, reiserfs_listxattr_filler, &buf);
1019 if (err)
1020 goto out_dir;
1021
1022 if (buf.r_pos > buf.r_size && buffer != NULL)
1023 err = -ERANGE;
1024 else
1025 err = buf.r_pos;
1026
1027 out_dir:
1028 dput(dir);
1029
1030 out:
1031 reiserfs_read_unlock_xattr_i(dentry->d_inode);
1032 return err;
1033}
1034
1035
1036static LIST_HEAD(xattr_handlers);
1037static DEFINE_RWLOCK(handler_lock);
1038
1039static struct reiserfs_xattr_handler *find_xattr_handler_prefix(const char
1040 *prefix)
1041{
1042 struct reiserfs_xattr_handler *xah = NULL;
1043 struct list_head *p;
1044
1045 read_lock(&handler_lock);
1046 list_for_each(p, &xattr_handlers) {
1047 xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1048 if (strncmp(xah->prefix, prefix, strlen(xah->prefix)) == 0)
1049 break;
1050 xah = NULL;
1051 }
1052
1053 read_unlock(&handler_lock);
1054 return xah;
1055}
1056
1057static void __unregister_handlers(void)
1058{
1059 struct reiserfs_xattr_handler *xah;
1060 struct list_head *p, *tmp;
1061
1062 list_for_each_safe(p, tmp, &xattr_handlers) {
1063 xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1064 if (xah->exit)
1065 xah->exit();
1066
1067 list_del_init(p);
1068 }
1069 INIT_LIST_HEAD(&xattr_handlers);
1070}
1071
1072int __init reiserfs_xattr_register_handlers(void)
1073{
1074 int err = 0;
1075 struct reiserfs_xattr_handler *xah;
1076 struct list_head *p;
1077
1078 write_lock(&handler_lock);
1079
1080
1081 if (!list_empty(&xattr_handlers)) {
1082 write_unlock(&handler_lock);
1083 return 0;
1084 }
1085
1086
1087 list_add_tail(&user_handler.handlers, &xattr_handlers);
1088 list_add_tail(&trusted_handler.handlers, &xattr_handlers);
1089#ifdef CONFIG_REISERFS_FS_SECURITY
1090 list_add_tail(&security_handler.handlers, &xattr_handlers);
1091#endif
1092#ifdef CONFIG_REISERFS_FS_POSIX_ACL
1093 list_add_tail(&posix_acl_access_handler.handlers, &xattr_handlers);
1094 list_add_tail(&posix_acl_default_handler.handlers, &xattr_handlers);
1095#endif
1096
1097
1098 list_for_each(p, &xattr_handlers) {
1099 xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1100 if (xah->init) {
1101 err = xah->init();
1102 if (err) {
1103 list_del_init(p);
1104 break;
1105 }
1106 }
1107 }
1108
1109
1110 if (err)
1111 __unregister_handlers();
1112
1113 write_unlock(&handler_lock);
1114 return err;
1115}
1116
1117void reiserfs_xattr_unregister_handlers(void)
1118{
1119 write_lock(&handler_lock);
1120 __unregister_handlers();
1121 write_unlock(&handler_lock);
1122}
1123
1124
1125static int
1126xattr_lookup_poison(struct dentry *dentry, struct qstr *q1, struct qstr *name)
1127{
1128 struct dentry *priv_root = REISERFS_SB(dentry->d_sb)->priv_root;
1129 if (name->len == priv_root->d_name.len &&
1130 name->hash == priv_root->d_name.hash &&
1131 !memcmp(name->name, priv_root->d_name.name, name->len)) {
1132 return -ENOENT;
1133 } else if (q1->len == name->len &&
1134 !memcmp(q1->name, name->name, name->len))
1135 return 0;
1136 return 1;
1137}
1138
1139static struct dentry_operations xattr_lookup_poison_ops = {
1140 .d_compare = xattr_lookup_poison,
1141};
1142
1143
1144
1145
1146int reiserfs_xattr_init(struct super_block *s, int mount_flags)
1147{
1148 int err = 0;
1149
1150
1151
1152 if (!old_format_only(s)) {
1153 set_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1154 } else if (reiserfs_xattrs_optional(s)) {
1155
1156
1157 reiserfs_warning(s, "xattrs/ACLs not supported on pre v3.6 "
1158 "format filesystem. Failing mount.");
1159 err = -EOPNOTSUPP;
1160 goto error;
1161 } else {
1162
1163
1164 clear_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1165 }
1166
1167
1168 if (reiserfs_xattrs(s) && !REISERFS_SB(s)->priv_root) {
1169 struct dentry *dentry;
1170 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
1171 strlen(PRIVROOT_NAME));
1172 if (!IS_ERR(dentry)) {
1173 if (!(mount_flags & MS_RDONLY) && !dentry->d_inode) {
1174 struct inode *inode = dentry->d_parent->d_inode;
1175 mutex_lock_nested(&inode->i_mutex,
1176 I_MUTEX_XATTR);
1177 err = inode->i_op->mkdir(inode, dentry, 0700);
1178 mutex_unlock(&inode->i_mutex);
1179 if (err) {
1180 dput(dentry);
1181 dentry = NULL;
1182 }
1183
1184 if (dentry && dentry->d_inode)
1185 reiserfs_warning(s,
1186 "Created %s on %s - reserved for "
1187 "xattr storage.",
1188 PRIVROOT_NAME,
1189 reiserfs_bdevname
1190 (inode->i_sb));
1191 } else if (!dentry->d_inode) {
1192 dput(dentry);
1193 dentry = NULL;
1194 }
1195 } else
1196 err = PTR_ERR(dentry);
1197
1198 if (!err && dentry) {
1199 s->s_root->d_op = &xattr_lookup_poison_ops;
1200 reiserfs_mark_inode_private(dentry->d_inode);
1201 REISERFS_SB(s)->priv_root = dentry;
1202 } else if (!(mount_flags & MS_RDONLY)) {
1203
1204
1205
1206 reiserfs_warning(s, "xattrs/ACLs enabled and couldn't "
1207 "find/create .reiserfs_priv. Failing mount.");
1208 err = -EOPNOTSUPP;
1209 }
1210 }
1211
1212 error:
1213
1214
1215 if (err) {
1216 clear_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1217 clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt));
1218 clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt));
1219 }
1220
1221
1222 s->s_flags = s->s_flags & ~MS_POSIXACL;
1223 if (reiserfs_posixacl(s))
1224 s->s_flags |= MS_POSIXACL;
1225
1226 return err;
1227}
1228
1229static int reiserfs_check_acl(struct inode *inode, int mask)
1230{
1231 struct posix_acl *acl;
1232 int error = -EAGAIN;
1233
1234 reiserfs_read_lock_xattr_i(inode);
1235 reiserfs_read_lock_xattrs(inode->i_sb);
1236
1237 acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
1238
1239 reiserfs_read_unlock_xattrs(inode->i_sb);
1240 reiserfs_read_unlock_xattr_i(inode);
1241
1242 if (acl) {
1243 if (!IS_ERR(acl)) {
1244 error = posix_acl_permission(inode, acl, mask);
1245 posix_acl_release(acl);
1246 } else if (PTR_ERR(acl) != -ENODATA)
1247 error = PTR_ERR(acl);
1248 }
1249
1250 return error;
1251}
1252
1253int reiserfs_permission(struct inode *inode, int mask)
1254{
1255
1256
1257
1258
1259 if (is_reiserfs_priv_object(inode))
1260 return 0;
1261
1262
1263
1264
1265 if (get_inode_sd_version(inode) == STAT_DATA_V1)
1266 return generic_permission(inode, mask, NULL);
1267 else
1268 return generic_permission(inode, mask, reiserfs_check_acl);
1269}