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/stat.h>
50 #include <linux/quotaops.h>
52 #define PRIVROOT_NAME ".reiserfs_priv"
53 #define XAROOT_NAME "xattrs"
56 /* Helpers for inode ops. We do this so that we don't have all the VFS
57 * overhead and also for proper i_mutex annotation.
58 * dir->i_mutex must be held for all of them. */
59 #ifdef CONFIG_REISERFS_FS_XATTR
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);
68 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, int mode)
70 BUG_ON(!mutex_is_locked(&dir->i_mutex));
72 return dir->i_op->mkdir(dir, dentry, mode);
75 /* We use I_MUTEX_CHILD here to silence lockdep. It's safe because xattr
76 * mutation ops aren't called during rename or splace, which are the
77 * only other users of I_MUTEX_CHILD. It violates the ordering, but that's
78 * better than allocating another subclass just for this code. */
79 static int xattr_unlink(struct inode *dir, struct dentry *dentry)
82 BUG_ON(!mutex_is_locked(&dir->i_mutex));
85 reiserfs_mutex_lock_nested_safe(&dentry->d_inode->i_mutex,
86 I_MUTEX_CHILD, dir->i_sb);
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);
127 xaroot = ERR_PTR(-ENODATA);
128 else if (!xaroot->d_inode) {
130 if (xattr_may_create(flags))
131 err = xattr_mkdir(privroot->d_inode, xaroot, 0700);
134 xaroot = ERR_PTR(err);
138 mutex_unlock(&privroot->d_inode->i_mutex);
142 static struct dentry *open_xa_dir(const struct inode *inode, int flags)
144 struct dentry *xaroot, *xadir;
147 xaroot = open_xa_root(inode->i_sb, flags);
151 snprintf(namebuf, sizeof(namebuf), "%X.%X",
152 le32_to_cpu(INODE_PKEY(inode)->k_objectid),
153 inode->i_generation);
155 mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
157 xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
158 if (!IS_ERR(xadir) && !xadir->d_inode) {
160 if (xattr_may_create(flags))
161 err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
164 xadir = ERR_PTR(err);
168 mutex_unlock(&xaroot->d_inode->i_mutex);
173 /* The following are side effects of other operations that aren't explicitly
174 * modifying extended attributes. This includes operations such as permissions
175 * or ownership changes, object deletions, etc. */
176 struct reiserfs_dentry_buf {
177 struct dentry *xadir;
179 struct dentry *dentries[8];
183 fill_with_dentries(void *buf, const char *name, int namelen, loff_t offset,
184 u64 ino, unsigned int d_type)
186 struct reiserfs_dentry_buf *dbuf = buf;
187 struct dentry *dentry;
188 WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex));
190 if (dbuf->count == ARRAY_SIZE(dbuf->dentries))
193 if (name[0] == '.' && (name[1] == '\0' ||
194 (name[1] == '.' && name[2] == '\0')))
197 dentry = lookup_one_len(name, dbuf->xadir, namelen);
198 if (IS_ERR(dentry)) {
199 return PTR_ERR(dentry);
200 } else if (!dentry->d_inode) {
201 /* A directory entry exists, but no file? */
202 reiserfs_error(dentry->d_sb, "xattr-20003",
203 "Corrupted directory: xattr %s listed but "
204 "not found for file %s.\n",
205 dentry->d_name.name, dbuf->xadir->d_name.name);
210 dbuf->dentries[dbuf->count++] = dentry;
215 cleanup_dentry_buf(struct reiserfs_dentry_buf *buf)
218 for (i = 0; i < buf->count; i++)
219 if (buf->dentries[i])
220 dput(buf->dentries[i]);
223 static int reiserfs_for_each_xattr(struct inode *inode,
224 int (*action)(struct dentry *, void *),
230 struct reiserfs_dentry_buf buf = {
234 /* Skip out, an xattr has no xattrs associated with it */
235 if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1)
238 reiserfs_write_unlock(inode->i_sb);
239 dir = open_xa_dir(inode, XATTR_REPLACE);
242 reiserfs_write_lock(inode->i_sb);
244 } else if (!dir->d_inode) {
246 reiserfs_write_lock(inode->i_sb);
250 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR);
252 reiserfs_write_lock(inode->i_sb);
255 err = reiserfs_readdir_dentry(dir, &buf, fill_with_dentries, &pos);
256 while ((err == 0 || err == -ENOSPC) && buf.count) {
259 for (i = 0; i < buf.count && buf.dentries[i]; i++) {
261 struct dentry *dentry = buf.dentries[i];
263 if (err == 0 && !S_ISDIR(dentry->d_inode->i_mode))
264 lerr = action(dentry, data);
267 buf.dentries[i] = NULL;
272 err = reiserfs_readdir_dentry(dir, &buf,
273 fill_with_dentries, &pos);
275 mutex_unlock(&dir->d_inode->i_mutex);
277 /* Clean up after a failed readdir */
278 cleanup_dentry_buf(&buf);
281 /* We start a transaction here to avoid a ABBA situation
282 * between the xattr root's i_mutex and the journal lock.
283 * This doesn't incur much additional overhead since the
284 * new transaction will just nest inside the
285 * outer transaction. */
286 int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 +
287 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb);
288 struct reiserfs_transaction_handle th;
289 err = journal_begin(&th, inode->i_sb, blocks);
292 reiserfs_mutex_lock_nested_safe(
293 &dir->d_parent->d_inode->i_mutex,
294 I_MUTEX_XATTR, inode->i_sb);
295 err = action(dir, data);
296 jerror = journal_end(&th, inode->i_sb, blocks);
297 mutex_unlock(&dir->d_parent->d_inode->i_mutex);
304 /* -ENODATA isn't an error */
310 static int delete_one_xattr(struct dentry *dentry, void *data)
312 struct inode *dir = dentry->d_parent->d_inode;
314 /* This is the xattr dir, handle specially. */
315 if (S_ISDIR(dentry->d_inode->i_mode))
316 return xattr_rmdir(dir, dentry);
318 return xattr_unlink(dir, dentry);
321 static int chown_one_xattr(struct dentry *dentry, void *data)
323 struct iattr *attrs = data;
324 return reiserfs_setattr(dentry, attrs);
327 /* No i_mutex, but the inode is unconnected. */
328 int reiserfs_delete_xattrs(struct inode *inode)
330 int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL);
332 reiserfs_warning(inode->i_sb, "jdm-20004",
333 "Couldn't delete all xattrs (%d)\n", err);
337 /* inode->i_mutex: down */
338 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
340 int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs);
342 reiserfs_warning(inode->i_sb, "jdm-20007",
343 "Couldn't chown all xattrs (%d)\n", err);
347 #ifdef CONFIG_REISERFS_FS_XATTR
348 /* Returns a dentry corresponding to a specific extended attribute file
349 * for the inode. If flags allow, the file is created. Otherwise, a
350 * valid or negative dentry, or an error is returned. */
351 static struct dentry *xattr_lookup(struct inode *inode, const char *name,
354 struct dentry *xadir, *xafile;
357 xadir = open_xa_dir(inode, flags);
359 return ERR_CAST(xadir);
361 mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
362 xafile = lookup_one_len(name, xadir, strlen(name));
363 if (IS_ERR(xafile)) {
364 err = PTR_ERR(xafile);
368 if (xafile->d_inode && (flags & XATTR_CREATE))
371 if (!xafile->d_inode) {
373 if (xattr_may_create(flags))
374 err = xattr_create(xadir->d_inode, xafile,
381 mutex_unlock(&xadir->d_inode->i_mutex);
388 /* Internal operations on file data */
389 static inline void reiserfs_put_page(struct page *page)
392 page_cache_release(page);
395 static struct page *reiserfs_get_page(struct inode *dir, size_t n)
397 struct address_space *mapping = dir->i_mapping;
399 /* We can deadlock if we try to free dentries,
400 and an unlink/rmdir has just occured - GFP_NOFS avoids this */
401 mapping_set_gfp_mask(mapping, GFP_NOFS);
402 page = read_mapping_page(mapping, n >> PAGE_CACHE_SHIFT, NULL);
411 reiserfs_put_page(page);
412 return ERR_PTR(-EIO);
415 static inline __u32 xattr_hash(const char *msg, int len)
417 return csum_partial(msg, len, 0);
420 int reiserfs_commit_write(struct file *f, struct page *page,
421 unsigned from, unsigned to);
422 int reiserfs_prepare_write(struct file *f, struct page *page,
423 unsigned from, unsigned to);
425 static void update_ctime(struct inode *inode)
427 struct timespec now = current_fs_time(inode->i_sb);
428 if (hlist_unhashed(&inode->i_hash) || !inode->i_nlink ||
429 timespec_equal(&inode->i_ctime, &now))
432 inode->i_ctime = CURRENT_TIME_SEC;
433 mark_inode_dirty(inode);
436 static int lookup_and_delete_xattr(struct inode *inode, const char *name)
439 struct dentry *dentry, *xadir;
441 xadir = open_xa_dir(inode, XATTR_REPLACE);
443 return PTR_ERR(xadir);
445 mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR);
446 dentry = lookup_one_len(name, xadir, strlen(name));
447 if (IS_ERR(dentry)) {
448 err = PTR_ERR(dentry);
452 if (dentry->d_inode) {
453 err = xattr_unlink(xadir->d_inode, dentry);
459 mutex_unlock(&xadir->d_inode->i_mutex);
465 /* Generic extended attribute operations that can be used by xa plugins */
468 * inode->i_mutex: down
471 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th,
472 struct inode *inode, const char *name,
473 const void *buffer, size_t buffer_size, int flags)
476 struct dentry *dentry;
480 size_t buffer_pos = 0;
484 if (get_inode_sd_version(inode) == STAT_DATA_V1)
488 return lookup_and_delete_xattr(inode, name);
490 reiserfs_write_unlock(inode->i_sb);
491 dentry = xattr_lookup(inode, name, flags);
492 if (IS_ERR(dentry)) {
493 reiserfs_write_lock(inode->i_sb);
494 return PTR_ERR(dentry);
497 down_read(&REISERFS_I(inode)->i_xattr_sem);
499 reiserfs_write_lock(inode->i_sb);
501 xahash = xattr_hash(buffer, buffer_size);
502 while (buffer_pos < buffer_size || buffer_pos == 0) {
505 size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1));
506 if (buffer_size - buffer_pos > PAGE_CACHE_SIZE)
507 chunk = PAGE_CACHE_SIZE;
509 chunk = buffer_size - buffer_pos;
511 page = reiserfs_get_page(dentry->d_inode, file_pos);
518 data = page_address(page);
521 struct reiserfs_xattr_header *rxh;
522 skip = file_pos = sizeof(struct reiserfs_xattr_header);
523 if (chunk + skip > PAGE_CACHE_SIZE)
524 chunk = PAGE_CACHE_SIZE - skip;
525 rxh = (struct reiserfs_xattr_header *)data;
526 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
527 rxh->h_hash = cpu_to_le32(xahash);
530 err = reiserfs_prepare_write(NULL, page, page_offset,
531 page_offset + chunk + skip);
534 memcpy(data + skip, buffer + buffer_pos, chunk);
535 err = reiserfs_commit_write(NULL, page, page_offset,
536 page_offset + chunk +
540 reiserfs_put_page(page);
544 if (err || buffer_size == 0 || !buffer)
548 new_size = buffer_size + sizeof(struct reiserfs_xattr_header);
549 if (!err && new_size < i_size_read(dentry->d_inode)) {
550 struct iattr newattrs = {
551 .ia_ctime = current_fs_time(inode->i_sb),
552 .ia_size = buffer_size,
553 .ia_valid = ATTR_SIZE | ATTR_CTIME,
555 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR);
556 down_write(&dentry->d_inode->i_alloc_sem);
557 err = reiserfs_setattr(dentry, &newattrs);
558 up_write(&dentry->d_inode->i_alloc_sem);
559 mutex_unlock(&dentry->d_inode->i_mutex);
563 up_write(&REISERFS_I(inode)->i_xattr_sem);
568 /* We need to start a transaction to maintain lock ordering */
569 int reiserfs_xattr_set(struct inode *inode, const char *name,
570 const void *buffer, size_t buffer_size, int flags)
573 struct reiserfs_transaction_handle th;
575 size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size);
577 if (!(flags & XATTR_REPLACE))
578 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode);
580 reiserfs_write_lock(inode->i_sb);
581 error = journal_begin(&th, inode->i_sb, jbegin_count);
583 reiserfs_write_unlock(inode->i_sb);
587 error = reiserfs_xattr_set_handle(&th, inode, name,
588 buffer, buffer_size, flags);
590 error2 = journal_end(&th, inode->i_sb, jbegin_count);
593 reiserfs_write_unlock(inode->i_sb);
599 * inode->i_mutex: down
602 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
606 struct dentry *dentry;
609 size_t buffer_pos = 0;
616 /* We can't have xattrs attached to v1 items since they don't have
617 * generation numbers */
618 if (get_inode_sd_version(inode) == STAT_DATA_V1)
621 dentry = xattr_lookup(inode, name, XATTR_REPLACE);
622 if (IS_ERR(dentry)) {
623 err = PTR_ERR(dentry);
627 down_read(&REISERFS_I(inode)->i_xattr_sem);
629 isize = i_size_read(dentry->d_inode);
631 /* Just return the size needed */
632 if (buffer == NULL) {
633 err = isize - sizeof(struct reiserfs_xattr_header);
637 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
642 while (file_pos < isize) {
646 if (isize - file_pos > PAGE_CACHE_SIZE)
647 chunk = PAGE_CACHE_SIZE;
649 chunk = isize - file_pos;
651 page = reiserfs_get_page(dentry->d_inode, file_pos);
658 data = page_address(page);
660 struct reiserfs_xattr_header *rxh =
661 (struct reiserfs_xattr_header *)data;
662 skip = file_pos = sizeof(struct reiserfs_xattr_header);
664 /* Magic doesn't match up.. */
665 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
667 reiserfs_put_page(page);
668 reiserfs_warning(inode->i_sb, "jdm-20001",
669 "Invalid magic for xattr (%s) "
670 "associated with %k", name,
675 hash = le32_to_cpu(rxh->h_hash);
677 memcpy(buffer + buffer_pos, data + skip, chunk);
679 reiserfs_put_page(page);
684 err = isize - sizeof(struct reiserfs_xattr_header);
686 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
688 reiserfs_warning(inode->i_sb, "jdm-20002",
689 "Invalid hash for xattr (%s) associated "
690 "with %k", name, INODE_PKEY(inode));
695 up_read(&REISERFS_I(inode)->i_xattr_sem);
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 static int create_privroot(struct dentry *dentry)
889 struct inode *inode = dentry->d_parent->d_inode;
890 WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
892 err = xattr_mkdir(inode, dentry, 0700);
893 if (err || !dentry->d_inode) {
894 reiserfs_warning(dentry->d_sb, "jdm-20006",
895 "xattrs/ACLs enabled and couldn't "
896 "find/create .reiserfs_priv. "
901 dentry->d_inode->i_flags |= S_PRIVATE;
902 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr "
903 "storage.\n", PRIVROOT_NAME);
909 int __init reiserfs_xattr_register_handlers(void) { return 0; }
910 void reiserfs_xattr_unregister_handlers(void) {}
911 static int create_privroot(struct dentry *dentry) { return 0; }
914 /* Actual operations that are exported to VFS-land */
915 struct xattr_handler *reiserfs_xattr_handlers[] = {
916 #ifdef CONFIG_REISERFS_FS_XATTR
917 &reiserfs_xattr_user_handler,
918 &reiserfs_xattr_trusted_handler,
920 #ifdef CONFIG_REISERFS_FS_SECURITY
921 &reiserfs_xattr_security_handler,
923 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
924 &reiserfs_posix_acl_access_handler,
925 &reiserfs_posix_acl_default_handler,
930 static int xattr_mount_check(struct super_block *s)
932 /* We need generation numbers to ensure that the oid mapping is correct
933 * v3.5 filesystems don't have them. */
934 if (old_format_only(s)) {
935 if (reiserfs_xattrs_optional(s)) {
936 /* Old format filesystem, but optional xattrs have
937 * been enabled. Error out. */
938 reiserfs_warning(s, "jdm-2005",
939 "xattrs/ACLs not supported "
940 "on pre-v3.6 format filesystems. "
949 int reiserfs_permission(struct inode *inode, int mask)
952 * We don't do permission checks on the internal objects.
953 * Permissions are determined by the "owning" object.
955 if (IS_PRIVATE(inode))
958 #ifdef CONFIG_REISERFS_FS_XATTR
960 * Stat data v1 doesn't support ACLs.
962 if (get_inode_sd_version(inode) != STAT_DATA_V1)
963 return generic_permission(inode, mask, reiserfs_check_acl);
965 return generic_permission(inode, mask, NULL);
968 /* This will catch lookups from the fs root to .reiserfs_priv */
970 xattr_lookup_poison(struct dentry *dentry, struct qstr *q1, struct qstr *name)
972 struct dentry *priv_root = REISERFS_SB(dentry->d_sb)->priv_root;
973 if (container_of(q1, struct dentry, d_name) == priv_root)
975 if (q1->len == name->len &&
976 !memcmp(q1->name, name->name, name->len))
981 static const struct dentry_operations xattr_lookup_poison_ops = {
982 .d_compare = xattr_lookup_poison,
985 int reiserfs_lookup_privroot(struct super_block *s)
987 struct dentry *dentry;
990 /* If we don't have the privroot located yet - go find it */
991 reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
992 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
993 strlen(PRIVROOT_NAME));
994 if (!IS_ERR(dentry)) {
995 REISERFS_SB(s)->priv_root = dentry;
996 if (!reiserfs_expose_privroot(s))
997 s->s_root->d_op = &xattr_lookup_poison_ops;
999 dentry->d_inode->i_flags |= S_PRIVATE;
1001 err = PTR_ERR(dentry);
1002 mutex_unlock(&s->s_root->d_inode->i_mutex);
1007 /* We need to take a copy of the mount flags since things like
1008 * MS_RDONLY don't get set until *after* we're called.
1009 * mount_flags != mount_options */
1010 int reiserfs_xattr_init(struct super_block *s, int mount_flags)
1013 struct dentry *privroot = REISERFS_SB(s)->priv_root;
1015 err = xattr_mount_check(s);
1019 if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) {
1020 reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s);
1021 err = create_privroot(REISERFS_SB(s)->priv_root);
1022 mutex_unlock(&s->s_root->d_inode->i_mutex);
1025 if (privroot->d_inode) {
1026 s->s_xattr = reiserfs_xattr_handlers;
1027 reiserfs_mutex_lock_safe(&privroot->d_inode->i_mutex, s);
1028 if (!REISERFS_SB(s)->xattr_root) {
1029 struct dentry *dentry;
1030 dentry = lookup_one_len(XAROOT_NAME, privroot,
1031 strlen(XAROOT_NAME));
1032 if (!IS_ERR(dentry))
1033 REISERFS_SB(s)->xattr_root = dentry;
1035 err = PTR_ERR(dentry);
1037 mutex_unlock(&privroot->d_inode->i_mutex);
1042 clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt));
1043 clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt));
1046 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1047 if (reiserfs_posixacl(s))
1048 s->s_flags |= MS_POSIXACL;
1050 s->s_flags &= ~MS_POSIXACL;