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 static int xattr_create(struct inode
*dir
, struct dentry
*dentry
, int mode
)
62 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
64 return dir
->i_op
->create(dir
, dentry
, mode
, NULL
);
67 static int xattr_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
69 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
71 return dir
->i_op
->mkdir(dir
, dentry
, mode
);
74 /* We use I_MUTEX_CHILD here to silence lockdep. It's safe because xattr
75 * mutation ops aren't called during rename or splace, which are the
76 * only other users of I_MUTEX_CHILD. It violates the ordering, but that's
77 * better than allocating another subclass just for this code. */
78 static int xattr_unlink(struct inode
*dir
, struct dentry
*dentry
)
81 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
84 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
85 error
= dir
->i_op
->unlink(dir
, dentry
);
86 mutex_unlock(&dentry
->d_inode
->i_mutex
);
93 static int xattr_rmdir(struct inode
*dir
, struct dentry
*dentry
)
96 BUG_ON(!mutex_is_locked(&dir
->i_mutex
));
99 mutex_lock_nested(&dentry
->d_inode
->i_mutex
, I_MUTEX_CHILD
);
100 dentry_unhash(dentry
);
101 error
= dir
->i_op
->rmdir(dir
, dentry
);
103 dentry
->d_inode
->i_flags
|= S_DEAD
;
104 mutex_unlock(&dentry
->d_inode
->i_mutex
);
112 #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE)
114 /* Returns and possibly creates the xattr dir. */
115 static struct dentry
*lookup_or_create_dir(struct dentry
*parent
,
116 const char *name
, int flags
)
118 struct dentry
*dentry
;
121 dentry
= lookup_one_len(name
, parent
, strlen(name
));
124 else if (!dentry
->d_inode
) {
127 if (xattr_may_create(flags
)) {
128 mutex_lock_nested(&parent
->d_inode
->i_mutex
,
130 err
= xattr_mkdir(parent
->d_inode
, dentry
, 0700);
131 mutex_unlock(&parent
->d_inode
->i_mutex
);
136 dentry
= ERR_PTR(err
);
143 static struct dentry
*open_xa_root(struct super_block
*sb
, int flags
)
145 struct dentry
*privroot
= REISERFS_SB(sb
)->priv_root
;
147 return ERR_PTR(-ENODATA
);
148 return lookup_or_create_dir(privroot
, XAROOT_NAME
, flags
);
151 static struct dentry
*open_xa_dir(const struct inode
*inode
, int flags
)
153 struct dentry
*xaroot
, *xadir
;
156 xaroot
= open_xa_root(inode
->i_sb
, flags
);
160 snprintf(namebuf
, sizeof(namebuf
), "%X.%X",
161 le32_to_cpu(INODE_PKEY(inode
)->k_objectid
),
162 inode
->i_generation
);
164 xadir
= lookup_or_create_dir(xaroot
, namebuf
, flags
);
170 /* The following are side effects of other operations that aren't explicitly
171 * modifying extended attributes. This includes operations such as permissions
172 * or ownership changes, object deletions, etc. */
173 struct reiserfs_dentry_buf
{
174 struct dentry
*xadir
;
176 struct dentry
*dentries
[8];
180 fill_with_dentries(void *buf
, const char *name
, int namelen
, loff_t offset
,
181 u64 ino
, unsigned int d_type
)
183 struct reiserfs_dentry_buf
*dbuf
= buf
;
184 struct dentry
*dentry
;
186 if (dbuf
->count
== ARRAY_SIZE(dbuf
->dentries
))
189 if (name
[0] == '.' && (name
[1] == '\0' ||
190 (name
[1] == '.' && name
[2] == '\0')))
193 dentry
= lookup_one_len(name
, dbuf
->xadir
, namelen
);
194 if (IS_ERR(dentry
)) {
195 return PTR_ERR(dentry
);
196 } else if (!dentry
->d_inode
) {
197 /* A directory entry exists, but no file? */
198 reiserfs_error(dentry
->d_sb
, "xattr-20003",
199 "Corrupted directory: xattr %s listed but "
200 "not found for file %s.\n",
201 dentry
->d_name
.name
, dbuf
->xadir
->d_name
.name
);
206 dbuf
->dentries
[dbuf
->count
++] = dentry
;
211 cleanup_dentry_buf(struct reiserfs_dentry_buf
*buf
)
214 for (i
= 0; i
< buf
->count
; i
++)
215 if (buf
->dentries
[i
])
216 dput(buf
->dentries
[i
]);
219 static int reiserfs_for_each_xattr(struct inode
*inode
,
220 int (*action
)(struct dentry
*, void *),
226 struct reiserfs_dentry_buf buf
= {
230 /* Skip out, an xattr has no xattrs associated with it */
231 if (IS_PRIVATE(inode
) || get_inode_sd_version(inode
) == STAT_DATA_V1
)
234 dir
= open_xa_dir(inode
, XATTR_REPLACE
);
238 } else if (!dir
->d_inode
) {
243 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
245 err
= reiserfs_readdir_dentry(dir
, &buf
, fill_with_dentries
, &pos
);
246 while ((err
== 0 || err
== -ENOSPC
) && buf
.count
) {
249 for (i
= 0; i
< buf
.count
&& buf
.dentries
[i
]; i
++) {
251 struct dentry
*dentry
= buf
.dentries
[i
];
253 if (err
== 0 && !S_ISDIR(dentry
->d_inode
->i_mode
))
254 lerr
= action(dentry
, data
);
257 buf
.dentries
[i
] = NULL
;
262 err
= reiserfs_readdir_dentry(dir
, &buf
,
263 fill_with_dentries
, &pos
);
265 mutex_unlock(&dir
->d_inode
->i_mutex
);
267 /* Clean up after a failed readdir */
268 cleanup_dentry_buf(&buf
);
271 /* We start a transaction here to avoid a ABBA situation
272 * between the xattr root's i_mutex and the journal lock.
273 * This doesn't incur much additional overhead since the
274 * new transaction will just nest inside the
275 * outer transaction. */
276 int blocks
= JOURNAL_PER_BALANCE_CNT
* 2 + 2 +
277 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode
->i_sb
);
278 struct reiserfs_transaction_handle th
;
279 err
= journal_begin(&th
, inode
->i_sb
, blocks
);
282 mutex_lock_nested(&dir
->d_parent
->d_inode
->i_mutex
,
284 err
= action(dir
, data
);
285 jerror
= journal_end(&th
, inode
->i_sb
, blocks
);
286 mutex_unlock(&dir
->d_parent
->d_inode
->i_mutex
);
293 /* -ENODATA isn't an error */
299 static int delete_one_xattr(struct dentry
*dentry
, void *data
)
301 struct inode
*dir
= dentry
->d_parent
->d_inode
;
303 /* This is the xattr dir, handle specially. */
304 if (S_ISDIR(dentry
->d_inode
->i_mode
))
305 return xattr_rmdir(dir
, dentry
);
307 return xattr_unlink(dir
, dentry
);
310 static int chown_one_xattr(struct dentry
*dentry
, void *data
)
312 struct iattr
*attrs
= data
;
313 return reiserfs_setattr(dentry
, attrs
);
316 /* No i_mutex, but the inode is unconnected. */
317 int reiserfs_delete_xattrs(struct inode
*inode
)
319 int err
= reiserfs_for_each_xattr(inode
, delete_one_xattr
, NULL
);
321 reiserfs_warning(inode
->i_sb
, "jdm-20004",
322 "Couldn't delete all xattrs (%d)\n", err
);
326 /* inode->i_mutex: down */
327 int reiserfs_chown_xattrs(struct inode
*inode
, struct iattr
*attrs
)
329 int err
= reiserfs_for_each_xattr(inode
, chown_one_xattr
, attrs
);
331 reiserfs_warning(inode
->i_sb
, "jdm-20007",
332 "Couldn't chown all xattrs (%d)\n", err
);
336 #ifdef CONFIG_REISERFS_FS_XATTR
337 /* Returns a dentry corresponding to a specific extended attribute file
338 * for the inode. If flags allow, the file is created. Otherwise, a
339 * valid or negative dentry, or an error is returned. */
340 static struct dentry
*xattr_lookup(struct inode
*inode
, const char *name
,
343 struct dentry
*xadir
, *xafile
;
346 xadir
= open_xa_dir(inode
, flags
);
348 return ERR_CAST(xadir
);
350 xafile
= lookup_one_len(name
, xadir
, strlen(name
));
351 if (IS_ERR(xafile
)) {
352 err
= PTR_ERR(xafile
);
356 if (xafile
->d_inode
&& (flags
& XATTR_CREATE
))
359 if (!xafile
->d_inode
) {
361 if (xattr_may_create(flags
)) {
362 mutex_lock_nested(&xadir
->d_inode
->i_mutex
,
364 err
= xattr_create(xadir
->d_inode
, xafile
,
366 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 dentry
= lookup_one_len(name
, xadir
, strlen(name
));
437 if (IS_ERR(dentry
)) {
438 err
= PTR_ERR(dentry
);
442 if (dentry
->d_inode
) {
443 mutex_lock_nested(&xadir
->d_inode
->i_mutex
, I_MUTEX_XATTR
);
444 err
= xattr_unlink(xadir
->d_inode
, dentry
);
445 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 (!reiserfs_xattrs(dentry
->d_sb
) ||
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 mutex_lock_nested(&inode
->i_mutex
, I_MUTEX_XATTR
);
908 err
= xattr_mkdir(inode
, dentry
, 0700);
909 mutex_unlock(&inode
->i_mutex
);
915 if (dentry
&& dentry
->d_inode
)
916 reiserfs_info(dentry
->d_sb
, "Created %s - reserved for xattr "
917 "storage.\n", PRIVROOT_NAME
);
922 static int xattr_mount_check(struct super_block
*s
)
924 /* We need generation numbers to ensure that the oid mapping is correct
925 * v3.5 filesystems don't have them. */
926 if (old_format_only(s
)) {
927 if (reiserfs_xattrs_optional(s
)) {
928 /* Old format filesystem, but optional xattrs have
929 * been enabled. Error out. */
930 reiserfs_warning(s
, "jdm-2005",
931 "xattrs/ACLs not supported "
932 "on pre-v3.6 format filesystems. "
942 int __init
reiserfs_xattr_register_handlers(void) { return 0; }
943 void reiserfs_xattr_unregister_handlers(void) {}
946 /* This will catch lookups from the fs root to .reiserfs_priv */
948 xattr_lookup_poison(struct dentry
*dentry
, struct qstr
*q1
, struct qstr
*name
)
950 struct dentry
*priv_root
= REISERFS_SB(dentry
->d_sb
)->priv_root
;
951 if (name
->len
== priv_root
->d_name
.len
&&
952 name
->hash
== priv_root
->d_name
.hash
&&
953 !memcmp(name
->name
, priv_root
->d_name
.name
, name
->len
)) {
955 } else if (q1
->len
== name
->len
&&
956 !memcmp(q1
->name
, name
->name
, name
->len
))
961 static const struct dentry_operations xattr_lookup_poison_ops
= {
962 .d_compare
= xattr_lookup_poison
,
965 /* We need to take a copy of the mount flags since things like
966 * MS_RDONLY don't get set until *after* we're called.
967 * mount_flags != mount_options */
968 int reiserfs_xattr_init(struct super_block
*s
, int mount_flags
)
972 #ifdef CONFIG_REISERFS_FS_XATTR
973 err
= xattr_mount_check(s
);
978 /* If we don't have the privroot located yet - go find it */
979 if (!REISERFS_SB(s
)->priv_root
) {
980 struct dentry
*dentry
;
981 dentry
= lookup_one_len(PRIVROOT_NAME
, s
->s_root
,
982 strlen(PRIVROOT_NAME
));
983 if (!IS_ERR(dentry
)) {
984 #ifdef CONFIG_REISERFS_FS_XATTR
985 if (!(mount_flags
& MS_RDONLY
) && !dentry
->d_inode
)
986 err
= create_privroot(dentry
);
988 if (!dentry
->d_inode
) {
993 err
= PTR_ERR(dentry
);
995 if (!err
&& dentry
) {
996 s
->s_root
->d_op
= &xattr_lookup_poison_ops
;
997 dentry
->d_inode
->i_flags
|= S_PRIVATE
;
998 REISERFS_SB(s
)->priv_root
= dentry
;
999 #ifdef CONFIG_REISERFS_FS_XATTR
1000 /* xattrs are unavailable */
1001 } else if (!(mount_flags
& MS_RDONLY
)) {
1002 /* If we're read-only it just means that the dir
1003 * hasn't been created. Not an error -- just no
1004 * xattrs on the fs. We'll check again if we
1006 reiserfs_warning(s
, "jdm-20006",
1007 "xattrs/ACLs enabled and couldn't "
1008 "find/create .reiserfs_priv. "
1015 #ifdef CONFIG_REISERFS_FS_XATTR
1017 s
->s_xattr
= reiserfs_xattr_handlers
;
1021 clear_bit(REISERFS_XATTRS_USER
, &(REISERFS_SB(s
)->s_mount_opt
));
1022 clear_bit(REISERFS_POSIXACL
, &(REISERFS_SB(s
)->s_mount_opt
));
1026 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1027 s
->s_flags
= s
->s_flags
& ~MS_POSIXACL
;
1028 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1029 if (reiserfs_posixacl(s
))
1030 s
->s_flags
|= MS_POSIXACL
;