2 * linux/fs/reiserfs/xattr.c
4 * Copyright (c) 2002 by Jeff Mahoney, <jeffm@suse.com>
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.
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
23 * The file contents are the text of the EA. The size is known based on the
24 * stat data describing the file.
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.
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.
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>
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/smp_lock.h>
50 #include <linux/stat.h>
51 #include <linux/quotaops.h>
53 #define PRIVROOT_NAME ".reiserfs_priv"
54 #define XAROOT_NAME "xattrs"
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
)
63 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
65 return dir
->i_op
->create(dir
, dentry
, mode
, NULL
);
69 static int xattr_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
71 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
73 return dir
->i_op
->mkdir(dir
, dentry
, mode
);
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
)
83 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
86 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
87 error
= dir
->i_op
->unlink(dir
, dentry
);
88 mutex_unlock(&dentry
->d_inode
->i_mutex
);
95 static int xattr_rmdir(struct inode
*dir
, struct dentry
*dentry
)
98 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
101 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
102 dentry_unhash(dentry
);
103 error
= dir
->i_op
->rmdir(dir
, dentry
);
105 dentry
->d_inode
->i_flags
|= S_DEAD
;
106 mutex_unlock(&dentry
->d_inode
->i_mutex
);
114 #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE)
116 static struct dentry
*open_xa_root(struct super_block
*sb
, int flags
)
118 struct dentry
*privroot
= REISERFS_SB(sb
)->priv_root
;
119 struct dentry
*xaroot
;
120 if (!privroot
->d_inode
)
121 return ERR_PTR(-ENODATA
);
123 mutex_lock_nested(&privroot
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
125 xaroot
= dget(REISERFS_SB(sb
)->xattr_root
);
126 if (!xaroot
->d_inode
) {
128 if (xattr_may_create(flags
))
129 err
= xattr_mkdir(privroot
->d_inode
, xaroot
, 0700);
132 xaroot
= ERR_PTR(err
);
136 mutex_unlock(&privroot
->d_inode
->i_mutex
);
140 static struct dentry
*open_xa_dir(const struct inode
*inode
, int flags
)
142 struct dentry
*xaroot
, *xadir
;
145 xaroot
= open_xa_root(inode
->i_sb
, flags
);
149 snprintf(namebuf
, sizeof(namebuf
), "%X.%X",
150 le32_to_cpu(INODE_PKEY(inode
)->k_objectid
),
151 inode
->i_generation
);
153 mutex_lock_nested(&xaroot
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
155 xadir
= lookup_one_len(namebuf
, xaroot
, strlen(namebuf
));
156 if (!IS_ERR(xadir
) && !xadir
->d_inode
) {
158 if (xattr_may_create(flags
))
159 err
= xattr_mkdir(xaroot
->d_inode
, xadir
, 0700);
162 xadir
= ERR_PTR(err
);
166 mutex_unlock(&xaroot
->d_inode
->i_mutex
);
171 /* The following are side effects of other operations that aren't explicitly
172 * modifying extended attributes. This includes operations such as permissions
173 * or ownership changes, object deletions, etc. */
174 struct reiserfs_dentry_buf
{
175 struct dentry
*xadir
;
177 struct dentry
*dentries
[8];
181 fill_with_dentries(void *buf
, const char *name
, int namelen
, loff_t offset
,
182 u64 ino
, unsigned int d_type
)
184 struct reiserfs_dentry_buf
*dbuf
= buf
;
185 struct dentry
*dentry
;
186 WARN_ON_ONCE(!mutex_is_locked(&dbuf
->xadir
->d_inode
->i_mutex
));
188 if (dbuf
->count
== ARRAY_SIZE(dbuf
->dentries
))
191 if (name
[0] == '.' && (name
[1] == '\0' ||
192 (name
[1] == '.' && name
[2] == '\0')))
195 dentry
= lookup_one_len(name
, dbuf
->xadir
, namelen
);
196 if (IS_ERR(dentry
)) {
197 return PTR_ERR(dentry
);
198 } else if (!dentry
->d_inode
) {
199 /* A directory entry exists, but no file? */
200 reiserfs_error(dentry
->d_sb
, "xattr-20003",
201 "Corrupted directory: xattr %s listed but "
202 "not found for file %s.\n",
203 dentry
->d_name
.name
, dbuf
->xadir
->d_name
.name
);
208 dbuf
->dentries
[dbuf
->count
++] = dentry
;
213 cleanup_dentry_buf(struct reiserfs_dentry_buf
*buf
)
216 for (i
= 0; i
< buf
->count
; i
++)
217 if (buf
->dentries
[i
])
218 dput(buf
->dentries
[i
]);
221 static int reiserfs_for_each_xattr(struct inode
*inode
,
222 int (*action
)(struct dentry
*, void *),
228 struct reiserfs_dentry_buf buf
= {
232 /* Skip out, an xattr has no xattrs associated with it */
233 if (IS_PRIVATE(inode
) || get_inode_sd_version(inode
) == STAT_DATA_V1
)
236 dir
= open_xa_dir(inode
, XATTR_REPLACE
);
240 } else if (!dir
->d_inode
) {
245 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
247 err
= reiserfs_readdir_dentry(dir
, &buf
, fill_with_dentries
, &pos
);
248 while ((err
== 0 || err
== -ENOSPC
) && buf
.count
) {
251 for (i
= 0; i
< buf
.count
&& buf
.dentries
[i
]; i
++) {
253 struct dentry
*dentry
= buf
.dentries
[i
];
255 if (err
== 0 && !S_ISDIR(dentry
->d_inode
->i_mode
))
256 lerr
= action(dentry
, data
);
259 buf
.dentries
[i
] = NULL
;
264 err
= reiserfs_readdir_dentry(dir
, &buf
,
265 fill_with_dentries
, &pos
);
267 mutex_unlock(&dir
->d_inode
->i_mutex
);
269 /* Clean up after a failed readdir */
270 cleanup_dentry_buf(&buf
);
273 /* We start a transaction here to avoid a ABBA situation
274 * between the xattr root's i_mutex and the journal lock.
275 * This doesn't incur much additional overhead since the
276 * new transaction will just nest inside the
277 * outer transaction. */
278 int blocks
= JOURNAL_PER_BALANCE_CNT
* 2 + 2 +
279 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode
->i_sb
);
280 struct reiserfs_transaction_handle th
;
281 err
= journal_begin(&th
, inode
->i_sb
, blocks
);
284 mutex_lock_nested(&dir
->d_parent
->d_inode
->i_mutex
,
286 err
= action(dir
, data
);
287 jerror
= journal_end(&th
, inode
->i_sb
, blocks
);
288 mutex_unlock(&dir
->d_parent
->d_inode
->i_mutex
);
295 /* -ENODATA isn't an error */
301 static int delete_one_xattr(struct dentry
*dentry
, void *data
)
303 struct inode
*dir
= dentry
->d_parent
->d_inode
;
305 /* This is the xattr dir, handle specially. */
306 if (S_ISDIR(dentry
->d_inode
->i_mode
))
307 return xattr_rmdir(dir
, dentry
);
309 return xattr_unlink(dir
, dentry
);
312 static int chown_one_xattr(struct dentry
*dentry
, void *data
)
314 struct iattr
*attrs
= data
;
315 return reiserfs_setattr(dentry
, attrs
);
318 /* No i_mutex, but the inode is unconnected. */
319 int reiserfs_delete_xattrs(struct inode
*inode
)
321 int err
= reiserfs_for_each_xattr(inode
, delete_one_xattr
, NULL
);
323 reiserfs_warning(inode
->i_sb
, "jdm-20004",
324 "Couldn't delete all xattrs (%d)\n", err
);
328 /* inode->i_mutex: down */
329 int reiserfs_chown_xattrs(struct inode
*inode
, struct iattr
*attrs
)
331 int err
= reiserfs_for_each_xattr(inode
, chown_one_xattr
, attrs
);
333 reiserfs_warning(inode
->i_sb
, "jdm-20007",
334 "Couldn't chown all xattrs (%d)\n", err
);
338 #ifdef CONFIG_REISERFS_FS_XATTR
339 /* Returns a dentry corresponding to a specific extended attribute file
340 * for the inode. If flags allow, the file is created. Otherwise, a
341 * valid or negative dentry, or an error is returned. */
342 static struct dentry
*xattr_lookup(struct inode
*inode
, const char *name
,
345 struct dentry
*xadir
, *xafile
;
348 xadir
= open_xa_dir(inode
, flags
);
350 return ERR_CAST(xadir
);
352 mutex_lock_nested(&xadir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
353 xafile
= lookup_one_len(name
, xadir
, strlen(name
));
354 if (IS_ERR(xafile
)) {
355 err
= PTR_ERR(xafile
);
359 if (xafile
->d_inode
&& (flags
& XATTR_CREATE
))
362 if (!xafile
->d_inode
) {
364 if (xattr_may_create(flags
))
365 err
= xattr_create(xadir
->d_inode
, xafile
,
372 mutex_unlock(&xadir
->d_inode
->i_mutex
);
379 /* Internal operations on file data */
380 static inline void reiserfs_put_page(struct page
*page
)
383 page_cache_release(page
);
386 static struct page
*reiserfs_get_page(struct inode
*dir
, size_t n
)
388 struct address_space
*mapping
= dir
->i_mapping
;
390 /* We can deadlock if we try to free dentries,
391 and an unlink/rmdir has just occured - GFP_NOFS avoids this */
392 mapping_set_gfp_mask(mapping
, GFP_NOFS
);
393 page
= read_mapping_page(mapping
, n
>> PAGE_CACHE_SHIFT
, NULL
);
402 reiserfs_put_page(page
);
403 return ERR_PTR(-EIO
);
406 static inline __u32
xattr_hash(const char *msg
, int len
)
408 return csum_partial(msg
, len
, 0);
411 int reiserfs_commit_write(struct file
*f
, struct page
*page
,
412 unsigned from
, unsigned to
);
413 int reiserfs_prepare_write(struct file
*f
, struct page
*page
,
414 unsigned from
, unsigned to
);
416 static void update_ctime(struct inode
*inode
)
418 struct timespec now
= current_fs_time(inode
->i_sb
);
419 if (hlist_unhashed(&inode
->i_hash
) || !inode
->i_nlink
||
420 timespec_equal(&inode
->i_ctime
, &now
))
423 inode
->i_ctime
= CURRENT_TIME_SEC
;
424 mark_inode_dirty(inode
);
427 static int lookup_and_delete_xattr(struct inode
*inode
, const char *name
)
430 struct dentry
*dentry
, *xadir
;
432 xadir
= open_xa_dir(inode
, XATTR_REPLACE
);
434 return PTR_ERR(xadir
);
436 mutex_lock_nested(&xadir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
437 dentry
= lookup_one_len(name
, xadir
, strlen(name
));
438 if (IS_ERR(dentry
)) {
439 err
= PTR_ERR(dentry
);
443 if (dentry
->d_inode
) {
444 err
= xattr_unlink(xadir
->d_inode
, dentry
);
450 mutex_unlock(&xadir
->d_inode
->i_mutex
);
456 /* Generic extended attribute operations that can be used by xa plugins */
459 * inode->i_mutex: down
462 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle
*th
,
463 struct inode
*inode
, const char *name
,
464 const void *buffer
, size_t buffer_size
, int flags
)
467 struct dentry
*dentry
;
471 size_t buffer_pos
= 0;
475 if (get_inode_sd_version(inode
) == STAT_DATA_V1
)
479 return lookup_and_delete_xattr(inode
, name
);
481 dentry
= xattr_lookup(inode
, name
, flags
);
483 return PTR_ERR(dentry
);
485 down_write(&REISERFS_I(inode
)->i_xattr_sem
);
487 xahash
= xattr_hash(buffer
, buffer_size
);
488 while (buffer_pos
< buffer_size
|| buffer_pos
== 0) {
491 size_t page_offset
= (file_pos
& (PAGE_CACHE_SIZE
- 1));
492 if (buffer_size
- buffer_pos
> PAGE_CACHE_SIZE
)
493 chunk
= PAGE_CACHE_SIZE
;
495 chunk
= buffer_size
- buffer_pos
;
497 page
= reiserfs_get_page(dentry
->d_inode
, file_pos
);
504 data
= page_address(page
);
507 struct reiserfs_xattr_header
*rxh
;
508 skip
= file_pos
= sizeof(struct reiserfs_xattr_header
);
509 if (chunk
+ skip
> PAGE_CACHE_SIZE
)
510 chunk
= PAGE_CACHE_SIZE
- skip
;
511 rxh
= (struct reiserfs_xattr_header
*)data
;
512 rxh
->h_magic
= cpu_to_le32(REISERFS_XATTR_MAGIC
);
513 rxh
->h_hash
= cpu_to_le32(xahash
);
516 err
= reiserfs_prepare_write(NULL
, page
, page_offset
,
517 page_offset
+ chunk
+ skip
);
520 memcpy(data
+ skip
, buffer
+ buffer_pos
, chunk
);
521 err
= reiserfs_commit_write(NULL
, page
, page_offset
,
522 page_offset
+ chunk
+
526 reiserfs_put_page(page
);
530 if (err
|| buffer_size
== 0 || !buffer
)
534 new_size
= buffer_size
+ sizeof(struct reiserfs_xattr_header
);
535 if (!err
&& new_size
< i_size_read(dentry
->d_inode
)) {
536 struct iattr newattrs
= {
537 .ia_ctime
= current_fs_time(inode
->i_sb
),
538 .ia_size
= buffer_size
,
539 .ia_valid
= ATTR_SIZE
| ATTR_CTIME
,
541 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
542 down_write(&dentry
->d_inode
->i_alloc_sem
);
543 err
= reiserfs_setattr(dentry
, &newattrs
);
544 up_write(&dentry
->d_inode
->i_alloc_sem
);
545 mutex_unlock(&dentry
->d_inode
->i_mutex
);
549 up_write(&REISERFS_I(inode
)->i_xattr_sem
);
554 /* We need to start a transaction to maintain lock ordering */
555 int reiserfs_xattr_set(struct inode
*inode
, const char *name
,
556 const void *buffer
, size_t buffer_size
, int flags
)
559 struct reiserfs_transaction_handle th
;
561 size_t jbegin_count
= reiserfs_xattr_nblocks(inode
, buffer_size
);
563 if (!(flags
& XATTR_REPLACE
))
564 jbegin_count
+= reiserfs_xattr_jcreate_nblocks(inode
);
566 reiserfs_write_lock(inode
->i_sb
);
567 error
= journal_begin(&th
, inode
->i_sb
, jbegin_count
);
569 reiserfs_write_unlock(inode
->i_sb
);
573 error
= reiserfs_xattr_set_handle(&th
, inode
, name
,
574 buffer
, buffer_size
, flags
);
576 error2
= journal_end(&th
, inode
->i_sb
, jbegin_count
);
579 reiserfs_write_unlock(inode
->i_sb
);
585 * inode->i_mutex: down
588 reiserfs_xattr_get(struct inode
*inode
, const char *name
, void *buffer
,
592 struct dentry
*dentry
;
595 size_t buffer_pos
= 0;
602 /* We can't have xattrs attached to v1 items since they don't have
603 * generation numbers */
604 if (get_inode_sd_version(inode
) == STAT_DATA_V1
)
607 dentry
= xattr_lookup(inode
, name
, XATTR_REPLACE
);
608 if (IS_ERR(dentry
)) {
609 err
= PTR_ERR(dentry
);
613 down_read(&REISERFS_I(inode
)->i_xattr_sem
);
615 isize
= i_size_read(dentry
->d_inode
);
617 /* Just return the size needed */
618 if (buffer
== NULL
) {
619 err
= isize
- sizeof(struct reiserfs_xattr_header
);
623 if (buffer_size
< isize
- sizeof(struct reiserfs_xattr_header
)) {
628 while (file_pos
< isize
) {
632 if (isize
- file_pos
> PAGE_CACHE_SIZE
)
633 chunk
= PAGE_CACHE_SIZE
;
635 chunk
= isize
- file_pos
;
637 page
= reiserfs_get_page(dentry
->d_inode
, file_pos
);
644 data
= page_address(page
);
646 struct reiserfs_xattr_header
*rxh
=
647 (struct reiserfs_xattr_header
*)data
;
648 skip
= file_pos
= sizeof(struct reiserfs_xattr_header
);
650 /* Magic doesn't match up.. */
651 if (rxh
->h_magic
!= cpu_to_le32(REISERFS_XATTR_MAGIC
)) {
653 reiserfs_put_page(page
);
654 reiserfs_warning(inode
->i_sb
, "jdm-20001",
655 "Invalid magic for xattr (%s) "
656 "associated with %k", name
,
661 hash
= le32_to_cpu(rxh
->h_hash
);
663 memcpy(buffer
+ buffer_pos
, data
+ skip
, chunk
);
665 reiserfs_put_page(page
);
670 err
= isize
- sizeof(struct reiserfs_xattr_header
);
672 if (xattr_hash(buffer
, isize
- sizeof(struct reiserfs_xattr_header
)) !=
674 reiserfs_warning(inode
->i_sb
, "jdm-20002",
675 "Invalid hash for xattr (%s) associated "
676 "with %k", name
, INODE_PKEY(inode
));
681 up_read(&REISERFS_I(inode
)->i_xattr_sem
);
688 /* Actual operations that are exported to VFS-land */
689 struct xattr_handler
*reiserfs_xattr_handlers
[] = {
690 &reiserfs_xattr_user_handler
,
691 &reiserfs_xattr_trusted_handler
,
692 #ifdef CONFIG_REISERFS_FS_SECURITY
693 &reiserfs_xattr_security_handler
,
695 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
696 &reiserfs_posix_acl_access_handler
,
697 &reiserfs_posix_acl_default_handler
,
703 * In order to implement different sets of xattr operations for each xattr
704 * prefix with the generic xattr API, a filesystem should create a
705 * null-terminated array of struct xattr_handler (one for each prefix) and
706 * hang a pointer to it off of the s_xattr field of the superblock.
708 * The generic_fooxattr() functions will use this list to dispatch xattr
709 * operations to the correct xattr_handler.
711 #define for_each_xattr_handler(handlers, handler) \
712 for ((handler) = *(handlers)++; \
714 (handler) = *(handlers)++)
716 /* This is the implementation for the xattr plugin infrastructure */
717 static inline struct xattr_handler
*
718 find_xattr_handler_prefix(struct xattr_handler
**handlers
,
721 struct xattr_handler
*xah
;
726 for_each_xattr_handler(handlers
, xah
) {
727 if (strncmp(xah
->prefix
, name
, strlen(xah
->prefix
)) == 0)
736 * Inode operation getxattr()
739 reiserfs_getxattr(struct dentry
* dentry
, const char *name
, void *buffer
,
742 struct inode
*inode
= dentry
->d_inode
;
743 struct xattr_handler
*handler
;
745 handler
= find_xattr_handler_prefix(inode
->i_sb
->s_xattr
, name
);
747 if (!handler
|| get_inode_sd_version(inode
) == STAT_DATA_V1
)
750 return handler
->get(inode
, name
, buffer
, size
);
754 * Inode operation setxattr()
756 * dentry->d_inode->i_mutex down
759 reiserfs_setxattr(struct dentry
*dentry
, const char *name
, const void *value
,
760 size_t size
, int flags
)
762 struct inode
*inode
= dentry
->d_inode
;
763 struct xattr_handler
*handler
;
765 handler
= find_xattr_handler_prefix(inode
->i_sb
->s_xattr
, name
);
767 if (!handler
|| get_inode_sd_version(inode
) == STAT_DATA_V1
)
770 return handler
->set(inode
, name
, value
, size
, flags
);
774 * Inode operation removexattr()
776 * dentry->d_inode->i_mutex down
778 int reiserfs_removexattr(struct dentry
*dentry
, const char *name
)
780 struct inode
*inode
= dentry
->d_inode
;
781 struct xattr_handler
*handler
;
782 handler
= find_xattr_handler_prefix(inode
->i_sb
->s_xattr
, name
);
784 if (!handler
|| get_inode_sd_version(inode
) == STAT_DATA_V1
)
787 return handler
->set(inode
, name
, NULL
, 0, XATTR_REPLACE
);
790 struct listxattr_buf
{
797 static int listxattr_filler(void *buf
, const char *name
, int namelen
,
798 loff_t offset
, u64 ino
, unsigned int d_type
)
800 struct listxattr_buf
*b
= (struct listxattr_buf
*)buf
;
802 if (name
[0] != '.' ||
803 (namelen
!= 1 && (name
[1] != '.' || namelen
!= 2))) {
804 struct xattr_handler
*handler
;
805 handler
= find_xattr_handler_prefix(b
->inode
->i_sb
->s_xattr
,
807 if (!handler
) /* Unsupported xattr name */
810 size
= handler
->list(b
->inode
, b
->buf
+ b
->pos
,
811 b
->size
, name
, namelen
);
815 size
= handler
->list(b
->inode
, NULL
, 0, name
, namelen
);
824 * Inode operation listxattr()
826 * We totally ignore the generic listxattr here because it would be stupid
827 * not to. Since the xattrs are organized in a directory, we can just
828 * readdir to find them.
830 ssize_t
reiserfs_listxattr(struct dentry
* dentry
, char *buffer
, size_t size
)
835 struct listxattr_buf buf
= {
836 .inode
= dentry
->d_inode
,
838 .size
= buffer
? size
: 0,
841 if (!dentry
->d_inode
)
844 if (!dentry
->d_sb
->s_xattr
||
845 get_inode_sd_version(dentry
->d_inode
) == STAT_DATA_V1
)
848 dir
= open_xa_dir(dentry
->d_inode
, XATTR_REPLACE
);
852 err
= 0; /* Not an error if there aren't any xattrs */
856 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
857 err
= reiserfs_readdir_dentry(dir
, &buf
, listxattr_filler
, &pos
);
858 mutex_unlock(&dir
->d_inode
->i_mutex
);
868 static int reiserfs_check_acl(struct inode
*inode
, int mask
)
870 struct posix_acl
*acl
;
871 int error
= -EAGAIN
; /* do regular unix permission checks by default */
873 acl
= reiserfs_get_acl(inode
, ACL_TYPE_ACCESS
);
877 error
= posix_acl_permission(inode
, acl
, mask
);
878 posix_acl_release(acl
);
879 } else if (PTR_ERR(acl
) != -ENODATA
)
880 error
= PTR_ERR(acl
);
886 int reiserfs_permission(struct inode
*inode
, int mask
)
889 * We don't do permission checks on the internal objects.
890 * Permissions are determined by the "owning" object.
892 if (IS_PRIVATE(inode
))
895 * Stat data v1 doesn't support ACLs.
897 if (get_inode_sd_version(inode
) == STAT_DATA_V1
)
898 return generic_permission(inode
, mask
, NULL
);
900 return generic_permission(inode
, mask
, reiserfs_check_acl
);
903 static int create_privroot(struct dentry
*dentry
)
906 struct inode
*inode
= dentry
->d_parent
->d_inode
;
907 WARN_ON_ONCE(!mutex_is_locked(&inode
->i_mutex
));
909 err
= xattr_mkdir(inode
, dentry
, 0700);
910 if (err
|| !dentry
->d_inode
) {
911 reiserfs_warning(dentry
->d_sb
, "jdm-20006",
912 "xattrs/ACLs enabled and couldn't "
913 "find/create .reiserfs_priv. "
918 dentry
->d_inode
->i_flags
|= S_PRIVATE
;
919 reiserfs_info(dentry
->d_sb
, "Created %s - reserved for xattr "
920 "storage.\n", PRIVROOT_NAME
);
925 static int xattr_mount_check(struct super_block
*s
)
927 /* We need generation numbers to ensure that the oid mapping is correct
928 * v3.5 filesystems don't have them. */
929 if (old_format_only(s
)) {
930 if (reiserfs_xattrs_optional(s
)) {
931 /* Old format filesystem, but optional xattrs have
932 * been enabled. Error out. */
933 reiserfs_warning(s
, "jdm-2005",
934 "xattrs/ACLs not supported "
935 "on pre-v3.6 format filesystems. "
945 int __init
reiserfs_xattr_register_handlers(void) { return 0; }
946 void reiserfs_xattr_unregister_handlers(void) {}
949 /* This will catch lookups from the fs root to .reiserfs_priv */
951 xattr_lookup_poison(struct dentry
*dentry
, struct qstr
*q1
, struct qstr
*name
)
953 struct dentry
*priv_root
= REISERFS_SB(dentry
->d_sb
)->priv_root
;
954 if (container_of(q1
, struct dentry
, d_name
) == priv_root
)
956 if (q1
->len
== name
->len
&&
957 !memcmp(q1
->name
, name
->name
, name
->len
))
962 static const struct dentry_operations xattr_lookup_poison_ops
= {
963 .d_compare
= xattr_lookup_poison
,
966 int reiserfs_lookup_privroot(struct super_block
*s
)
968 struct dentry
*dentry
;
971 /* If we don't have the privroot located yet - go find it */
972 mutex_lock(&s
->s_root
->d_inode
->i_mutex
);
973 dentry
= lookup_one_len(PRIVROOT_NAME
, s
->s_root
,
974 strlen(PRIVROOT_NAME
));
975 if (!IS_ERR(dentry
)) {
976 REISERFS_SB(s
)->priv_root
= dentry
;
977 s
->s_root
->d_op
= &xattr_lookup_poison_ops
;
979 dentry
->d_inode
->i_flags
|= S_PRIVATE
;
981 err
= PTR_ERR(dentry
);
982 mutex_unlock(&s
->s_root
->d_inode
->i_mutex
);
987 /* We need to take a copy of the mount flags since things like
988 * MS_RDONLY don't get set until *after* we're called.
989 * mount_flags != mount_options */
990 int reiserfs_xattr_init(struct super_block
*s
, int mount_flags
)
993 struct dentry
*privroot
= REISERFS_SB(s
)->priv_root
;
995 #ifdef CONFIG_REISERFS_FS_XATTR
996 err
= xattr_mount_check(s
);
1000 if (!privroot
->d_inode
&& !(mount_flags
& MS_RDONLY
)) {
1001 mutex_lock(&s
->s_root
->d_inode
->i_mutex
);
1002 err
= create_privroot(REISERFS_SB(s
)->priv_root
);
1003 mutex_unlock(&s
->s_root
->d_inode
->i_mutex
);
1006 if (privroot
->d_inode
) {
1007 s
->s_xattr
= reiserfs_xattr_handlers
;
1008 mutex_lock(&privroot
->d_inode
->i_mutex
);
1009 if (!REISERFS_SB(s
)->xattr_root
) {
1010 struct dentry
*dentry
;
1011 dentry
= lookup_one_len(XAROOT_NAME
, privroot
,
1012 strlen(XAROOT_NAME
));
1013 if (!IS_ERR(dentry
))
1014 REISERFS_SB(s
)->xattr_root
= dentry
;
1016 err
= PTR_ERR(dentry
);
1018 mutex_unlock(&privroot
->d_inode
->i_mutex
);
1023 clear_bit(REISERFS_XATTRS_USER
, &(REISERFS_SB(s
)->s_mount_opt
));
1024 clear_bit(REISERFS_POSIXACL
, &(REISERFS_SB(s
)->s_mount_opt
));
1028 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1029 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1030 if (reiserfs_posixacl(s
))
1031 s
->s_flags
|= MS_POSIXACL
;
1034 s
->s_flags
&= ~MS_POSIXACL
;