Remove VFS extended attribute interface so that extN will build even if the

[fs/lustre-release.git] / lustre / extN / linux-2.4.18ea-0.8.26.diff

Linux Extended Attributes -- Kernel Patch
24 April 2002, 11:31:18


This patch is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This patch is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this patch; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


After extracting the linux-2.4.18.tar.gz package, apply this patch as follows:

        cd linux
        patch -p1 < ../linux-2.4.18ea-0.8.26.patch

diff -Nur linux-2.4.18/fs/ext3/ialloc.c linux-2.4.18ea/fs/ext3/ialloc.c
--- linux-2.4.18/fs/ext3/ialloc.c       Sun Feb 24 04:42:59 2002
+++ linux-2.4.18ea/fs/ext3/ialloc.c     Sun Feb 24 04:34:43 2002
@@ -17,6 +17,7 @@
 #include <linux/jbd.h>
 #include <linux/ext3_fs.h>
 #include <linux/ext3_jbd.h>
+#include <linux/ext3_xattr.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/locks.h>
@@ -216,6 +217,7 @@
         * as writing the quota to disk may need the lock as well.
         */
        DQUOT_INIT(inode);
+       ext3_xattr_drop_inode(handle, inode);
        DQUOT_FREE_INODE(inode);
        DQUOT_DROP(inode);
 
diff -Nur linux-2.4.18/fs/ext3/inode.c linux-2.4.18ea/fs/ext3/inode.c
--- linux-2.4.18/fs/ext3/inode.c        Sun Feb 24 04:42:59 2002
+++ linux-2.4.18ea/fs/ext3/inode.c      Thu Mar 14 21:51:59 2002
@@ -39,6 +39,18 @@
  */
 #undef SEARCH_FROM_ZERO
 
+/*
+ * Test whether an inode is a fast symlink.
+ */
+static inline int ext3_inode_is_fast_symlink(struct inode *inode)
+{
+       int ea_blocks = EXT3_I(inode)->i_file_acl ?
+               (inode->i_sb->s_blocksize >> 9) : 0;
+
+       return (S_ISLNK(inode->i_mode) &&
+               inode->i_blocks - ea_blocks == 0);
+}
+
 /* The ext3 forget function must perform a revoke if we are freeing data
  * which has been journaled.  Metadata (eg. indirect blocks) must be
  * revoked in all cases. 
@@ -48,7 +60,7 @@
  * still needs to be revoked.
  */
 
-static int ext3_forget(handle_t *handle, int is_metadata,
+int ext3_forget(handle_t *handle, int is_metadata,
                       struct inode *inode, struct buffer_head *bh,
                       int blocknr)
 {
@@ -164,9 +176,7 @@
 {
        handle_t *handle;
        
-       if (is_bad_inode(inode) ||
-           inode->i_ino == EXT3_ACL_IDX_INO ||
-           inode->i_ino == EXT3_ACL_DATA_INO)
+       if (is_bad_inode(inode))
                goto no_delete;
 
        lock_kernel();
@@ -1845,6 +1855,8 @@
        if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
            S_ISLNK(inode->i_mode)))
                return;
+       if (ext3_inode_is_fast_symlink(inode))
+               return;
        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
                return;
 
@@ -1992,8 +2004,6 @@
        struct ext3_group_desc * gdp;
                
        if ((inode->i_ino != EXT3_ROOT_INO &&
-               inode->i_ino != EXT3_ACL_IDX_INO &&
-               inode->i_ino != EXT3_ACL_DATA_INO &&
                inode->i_ino != EXT3_JOURNAL_INO &&
                inode->i_ino < EXT3_FIRST_INO(inode->i_sb)) ||
                inode->i_ino > le32_to_cpu(
@@ -2120,10 +2130,7 @@
 
        brelse (iloc.bh);
 
-       if (inode->i_ino == EXT3_ACL_IDX_INO ||
-           inode->i_ino == EXT3_ACL_DATA_INO)
-               /* Nothing to do */ ;
-       else if (S_ISREG(inode->i_mode)) {
+       if (S_ISREG(inode->i_mode)) {
                inode->i_op = &ext3_file_inode_operations;
                inode->i_fop = &ext3_file_operations;
                inode->i_mapping->a_ops = &ext3_aops;
@@ -2131,13 +2138,15 @@
                inode->i_op = &ext3_dir_inode_operations;
                inode->i_fop = &ext3_dir_operations;
        } else if (S_ISLNK(inode->i_mode)) {
-               if (!inode->i_blocks)
+               if (ext3_inode_is_fast_symlink(inode))
                        inode->i_op = &ext3_fast_symlink_inode_operations;
                else {
-                       inode->i_op = &page_symlink_inode_operations;
+                       inode->i_op = &ext3_symlink_inode_operations;
                        inode->i_mapping->a_ops = &ext3_aops;
                }
-       } else 
+       } else {
+               inode->i_op = &ext3_special_inode_operations;
                init_special_inode(inode, inode->i_mode,
                                   le32_to_cpu(iloc.raw_inode->i_block[0]));
+       }
        /* inode->i_attr_flags = 0;                             unused */
diff -Nur linux-2.4.18/fs/ext3/namei.c linux-2.4.18ea/fs/ext3/namei.c
--- linux-2.4.18/fs/ext3/namei.c        Fri Nov  9 23:25:04 2001
+++ linux-2.4.18ea/fs/ext3/namei.c      Mon Mar 11 03:27:00 2002
@@ -23,6 +23,7 @@
 #include <linux/sched.h>
 #include <linux/ext3_fs.h>
 #include <linux/ext3_jbd.h>
+#include <linux/ext3_xattr.h>
 #include <linux/fcntl.h>
 #include <linux/stat.h>
 #include <linux/string.h>
@@ -466,6 +467,8 @@
                inode->i_mapping->a_ops = &ext3_aops;
                ext3_mark_inode_dirty(handle, inode);
                err = ext3_add_nondir(handle, dentry, inode);
+               if (err)
+                       ext3_xattr_drop_inode(handle, inode);
        }
        ext3_journal_stop(handle, dir);
        return err;
@@ -491,6 +494,8 @@
                init_special_inode(inode, mode, rdev);
                ext3_mark_inode_dirty(handle, inode);
                err = ext3_add_nondir(handle, dentry, inode);
+               if (err)
+                       ext3_xattr_drop_inode(handle, inode);
        }
        ext3_journal_stop(handle, dir);
        return err;
@@ -514,7 +519,7 @@
        if (IS_SYNC(dir))
                handle->h_sync = 1;
 
-       inode = ext3_new_inode (handle, dir, S_IFDIR);
+       inode = ext3_new_inode (handle, dir, S_IFDIR | mode);
        err = PTR_ERR(inode);
        if (IS_ERR(inode))
                goto out_stop;
@@ -522,7 +527,6 @@
        inode->i_op = &ext3_dir_inode_operations;
        inode->i_fop = &ext3_dir_operations;
-       inode->i_size = inode->u.ext3_i.i_disksize = inode->i_sb->s_blocksize;
-       inode->i_blocks = 0;    
+       inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize;
        dir_block = ext3_bread (handle, inode, 0, 1, &err);
        if (!dir_block) {
                inode->i_nlink--; /* is this nlink == 0? */
@@ -549,9 +553,6 @@
        BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata");
        ext3_journal_dirty_metadata(handle, dir_block);
        brelse (dir_block);
-       inode->i_mode = S_IFDIR | mode;
-       if (dir->i_mode & S_ISGID)
-               inode->i_mode |= S_ISGID;
        ext3_mark_inode_dirty(handle, inode);
        err = ext3_add_entry (handle, dentry, inode);
        if (err)
@@ -565,6 +566,7 @@
        return err;
 
 out_no_entry:
+       ext3_xattr_drop_inode(handle, inode);
        inode->i_nlink = 0;
        ext3_mark_inode_dirty(handle, inode);
        iput (inode);
@@ -917,7 +919,7 @@
                goto out_stop;
 
-       if (l > sizeof (inode->u.ext3_i.i_data)) {
-               inode->i_op = &page_symlink_inode_operations;
+       if (l > sizeof(EXT3_I(inode)->i_data)) {
+               inode->i_op = &ext3_symlink_inode_operations;
                inode->i_mapping->a_ops = &ext3_aops;
                /*
                 * block_symlink() calls back into ext3_prepare/commit_write.
diff -Nur linux-2.4.18/fs/ext3/super.c linux-2.4.18ea/fs/ext3/super.c
--- linux-2.4.18/fs/ext3/super.c        Sun Feb 24 04:42:59 2002
+++ linux-2.4.18ea/fs/ext3/super.c      Thu Apr  4 21:41:05 2002
@@ -24,6 +24,7 @@
 #include <linux/jbd.h>
 #include <linux/ext3_fs.h>
 #include <linux/ext3_jbd.h>
+#include <linux/ext3_xattr.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/locks.h>
@@ -404,6 +405,7 @@
        kdev_t j_dev = sbi->s_journal->j_dev;
        int i;
 
+       ext3_xattr_put_super(sb);
        journal_destroy(sbi->s_journal);
        if (!(sb->s_flags & MS_RDONLY)) {
                EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
@@ -1734,14 +1772,25 @@
 
 static DECLARE_FSTYPE_DEV(ext3_fs_type, "ext3", ext3_read_super);
 
-static int __init init_ext3_fs(void)
+static void exit_ext3_fs(void)
 {
-        return register_filesystem(&ext3_fs_type);
+       unregister_filesystem(&ext3_fs_type);
+       exit_ext3_xattr_user();
+       exit_ext3_xattr();
 }
 
-static void __exit exit_ext3_fs(void)
+static int __init init_ext3_fs(void)
 {
-       unregister_filesystem(&ext3_fs_type);
+       int error = init_ext3_xattr();
+       if (!error)
+               error = init_ext3_xattr_user();
+       if (!error)
+               error = register_filesystem(&ext3_fs_type);
+       if (!error)
+               return 0;
+
+       exit_ext3_fs();
+       return error;
 }
 
 EXPORT_NO_SYMBOLS;
diff -Nur linux-2.4.18/fs/ext3/xattr.c linux-2.4.18ea/fs/ext3/xattr.c
--- linux-2.4.18/fs/ext3/xattr.c        Thu Jan  1 01:00:00 1970
+++ linux-2.4.18ea/fs/ext3/xattr.c      Wed Apr  3 13:19:05 2002
@@ -0,0 +1,1247 @@
+/*
+ * linux/fs/ext3/xattr.c
+ *
+ * Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
+ *
+ * Fix by Harrison Xing <harrison@mountainviewdata.com>.
+ * Ext3 code with a lot of help from Eric Jarman <ejarman@acm.org>.
+ * Extended attributes for symlinks and special files added per
+ *  suggestion of Luka Renko <luka.renko@hermes.si>.
+ */
+
+/*
+ * Extended attributes are stored on disk blocks allocated outside of
+ * any inode. The i_file_acl field is then made to point to this allocated
+ * block. If all extended attributes of an inode are identical, these
+ * inodes may share the same extended attribute block. Such situations
+ * are automatically detected by keeping a cache of recent attribute block
+ * numbers and hashes over the block's contents in memory.
+ *
+ *
+ * Extended attribute block layout:
+ *
+ *   +------------------+
+ *   | header           |
+ *   ¦ entry 1          | |
+ *   | entry 2          | | growing downwards
+ *   | entry 3          | v
+ *   | four null bytes  |
+ *   | . . .            |
+ *   | value 1          | ^
+ *   | value 3          | | growing upwards
+ *   | value 2          | |
+ *   +------------------+
+ *
+ * The block header is followed by multiple entry descriptors. These entry
+ * descriptors are variable in size, and alligned to EXT3_XATTR_PAD
+ * byte boundaries. The entry descriptors are sorted by attribute name,
+ * so that two extended attribute blocks can be compared efficiently.
+ *
+ * Attribute values are aligned to the end of the block, stored in
+ * no specific order. They are also padded to EXT3_XATTR_PAD byte
+ * boundaries. No additional gaps are left between them.
+ *
+ * Locking strategy
+ * ----------------
+ * The VFS already holds the BKL and the inode->i_sem semaphore when any of
+ * the xattr inode operations are called, so we are guaranteed that only one
+ * processes accesses extended attributes of an inode at any time.
+ *
+ * For writing we also grab the ext3_xattr_sem semaphore. This ensures that
+ * only a single process is modifying an extended attribute block, even
+ * if the block is shared among inodes.
+ *
+ * Note for porting to 2.5
+ * -----------------------
+ * The BKL will no longer be held in the xattr inode operations.
+ */
+
+#include <linux/fs.h>
+#include <linux/locks.h>
+#include <linux/slab.h>
+#include <linux/ext3_jbd.h>
+#include <linux/ext3_fs.h>
+#include <linux/ext3_xattr.h>
+#ifdef CONFIG_EXT3_FS_XATTR_SHARING
+#include <linux/mbcache.h>
+#endif
+#include <linux/quotaops.h>
+#include <asm/semaphore.h>
+#include <linux/compatmac.h>
+#include <linux/module.h>
+
+/* These symbols may be needed by a module. */
+EXPORT_SYMBOL(extN_xattr_register);
+EXPORT_SYMBOL(extN_xattr_unregister);
+EXPORT_SYMBOL(extN_xattr_get);
+EXPORT_SYMBOL(extN_xattr_list);
+EXPORT_SYMBOL(extN_xattr_set);
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
+# define mark_buffer_dirty(bh) mark_buffer_dirty(bh, 1)
+#endif
+
+#define HDR(bh) ((struct ext3_xattr_header *)((bh)->b_data))
+#define ENTRY(ptr) ((struct ext3_xattr_entry *)(ptr))
+#define FIRST_ENTRY(bh) ENTRY(HDR(bh)+1)
+#define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
+
+#ifdef EXT3_XATTR_DEBUG
+# define ea_idebug(inode, f...) do { \
+               printk(KERN_DEBUG "inode %s:%ld: ", \
+                       kdevname(inode->i_dev), inode->i_ino); \
+               printk(f); \
+               printk("\n"); \
+       } while (0)
+# define ea_bdebug(bh, f...) do { \
+               printk(KERN_DEBUG "block %s:%ld: ", \
+                       kdevname(bh->b_dev), bh->b_blocknr); \
+               printk(f); \
+               printk("\n"); \
+       } while (0)
+#else
+# define ea_idebug(f...)
+# define ea_bdebug(f...)
+#endif
+
+static int ext3_xattr_set2(handle_t *, struct inode *, struct buffer_head *,
+                          struct ext3_xattr_header *);
+
+#ifdef CONFIG_EXT3_FS_XATTR_SHARING
+
+static int ext3_xattr_cache_insert(struct buffer_head *);
+static struct buffer_head *ext3_xattr_cache_find(struct inode *,
+                                                struct ext3_xattr_header *);
+static void ext3_xattr_cache_remove(struct buffer_head *);
+static void ext3_xattr_rehash(struct ext3_xattr_header *,
+                             struct ext3_xattr_entry *);
+
+static struct mb_cache *ext3_xattr_cache;
+
+#else
+# define ext3_xattr_cache_insert(bh) 0
+# define ext3_xattr_cache_find(inode, header) NULL
+# define ext3_xattr_cache_remove(bh) do {} while(0)
+# define ext3_xattr_rehash(header, entry) do {} while(0)
+#endif
+
+/*
+ * If a file system does not share extended attributes among inodes,
+ * we should not need the ext3_xattr_sem semaphore. However, the
+ * filesystem may still contain shared blocks, so we always take
+ * the lock.
+ */
+
+DECLARE_MUTEX(ext3_xattr_sem);
+
+static inline void
+ext3_xattr_lock(void)
+{
+       down(&ext3_xattr_sem);
+}
+
+static inline void
+ext3_xattr_unlock(void)
+{
+       up(&ext3_xattr_sem);
+}
+
+static inline int
+ext3_xattr_new_block(handle_t *handle, struct inode *inode,
+                    int * errp, int force)
+{
+       struct super_block *sb = inode->i_sb;
+       int goal = le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block) +
+               EXT3_I(inode)->i_block_group * EXT3_BLOCKS_PER_GROUP(sb);
+
+       /* How can we enforce the allocation? */
+       int block = ext3_new_block(handle, inode, goal, 0, 0, errp);
+#ifdef OLD_QUOTAS
+       if (!*errp)
+               inode->i_blocks += inode->i_sb->s_blocksize >> 9;
+#endif
+       return block;
+}
+
+static inline int
+ext3_xattr_quota_alloc(struct inode *inode, int force)
+{
+       /* How can we enforce the allocation? */
+#ifdef OLD_QUOTAS
+       int error = DQUOT_ALLOC_BLOCK(inode->i_sb, inode, 1);
+       if (!error)
+               inode->i_blocks += inode->i_sb->s_blocksize >> 9;
+#else
+       int error = DQUOT_ALLOC_BLOCK(inode, 1);
+#endif
+       return error;
+}
+
+#ifdef OLD_QUOTAS
+
+static inline void
+ext3_xattr_quota_free(struct inode *inode)
+{
+       DQUOT_FREE_BLOCK(inode->i_sb, inode, 1);
+       inode->i_blocks -= inode->i_sb->s_blocksize >> 9;
+}
+
+static inline void
+ext3_xattr_free_block(handle_t *handle, struct inode * inode,
+                     unsigned long block)
+{
+       ext3_free_blocks(handle, inode, block, 1);
+       inode->i_blocks -= inode->i_sb->s_blocksize >> 9;
+}
+
+#else
+# define ext3_xattr_quota_free(inode) \
+       DQUOT_FREE_BLOCK(inode, 1)
+# define ext3_xattr_free_block(handle, inode, block) \
+       ext3_free_blocks(handle, inode, block, 1)
+#endif
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)
+
+static inline struct buffer_head *
+sb_bread(struct super_block *sb, int block)
+{
+       return bread(sb->s_dev, block, sb->s_blocksize);
+}
+
+static inline struct buffer_head *
+sb_getblk(struct super_block *sb, int block)
+{
+       return getblk(sb->s_dev, block, sb->s_blocksize);
+}
+
+#endif
+
+struct ext3_xattr_handler *ext3_xattr_handlers[EXT3_XATTR_INDEX_MAX];
+rwlock_t ext3_handler_lock = RW_LOCK_UNLOCKED;
+
+int
+ext3_xattr_register(int name_index, struct ext3_xattr_handler *handler)
+{
+       int error = -EINVAL;
+
+       if (name_index > 0 && name_index <= EXT3_XATTR_INDEX_MAX) {
+               write_lock(&ext3_handler_lock);
+               if (!ext3_xattr_handlers[name_index-1]) {
+                       ext3_xattr_handlers[name_index-1] = handler;
+                       error = 0;
+               }
+               write_unlock(&ext3_handler_lock);
+       }
+       return error;
+}
+
+void
+ext3_xattr_unregister(int name_index, struct ext3_xattr_handler *handler)
+{
+       if (name_index > 0 || name_index <= EXT3_XATTR_INDEX_MAX) {
+               write_lock(&ext3_handler_lock);
+               ext3_xattr_handlers[name_index-1] = NULL;
+               write_unlock(&ext3_handler_lock);
+       }
+}
+
+static inline const char *
+strcmp_prefix(const char *a, const char *a_prefix)
+{
+       while (*a_prefix && *a == *a_prefix) {
+               a++;
+               a_prefix++;
+       }
+       return *a_prefix ? NULL : a;
+}
+
+/*
+ * Decode the extended attribute name, and translate it into
+ * the name_index and name suffix.
+ */
+static inline struct ext3_xattr_handler *
+ext3_xattr_resolve_name(const char **name)
+{
+       struct ext3_xattr_handler *handler = NULL;
+       int i;
+
+       if (!*name)
+               return NULL;
+       read_lock(&ext3_handler_lock);
+       for (i=0; i<EXT3_XATTR_INDEX_MAX; i++) {
+               if (ext3_xattr_handlers[i]) {
+                       const char *n = strcmp_prefix(*name,
+                               ext3_xattr_handlers[i]->prefix);
+                       if (n) {
+                               handler = ext3_xattr_handlers[i];
+                               *name = n;
+                               break;
+                       }
+               }
+       }
+       read_unlock(&ext3_handler_lock);
+       return handler;
+}
+
+static inline struct ext3_xattr_handler *
+ext3_xattr_handler(int name_index)
+{
+       struct ext3_xattr_handler *handler = NULL;
+       if (name_index > 0 && name_index <= EXT3_XATTR_INDEX_MAX) {
+               read_lock(&ext3_handler_lock);
+               handler = ext3_xattr_handlers[name_index-1];
+               read_unlock(&ext3_handler_lock);
+       }
+       return handler;
+}
+
+/*
+ * Inode operation getxattr()
+ *
+ * dentry->d_inode->i_sem down
+ * BKL held [before 2.5.x]
+ */
+ssize_t
+ext3_getxattr(struct dentry *dentry, const char *name,
+             void *buffer, size_t size)
+{
+       struct ext3_xattr_handler *handler;
+       struct inode *inode = dentry->d_inode;
+
+       handler = ext3_xattr_resolve_name(&name);
+       if (!handler)
+               return -ENOTSUP;
+       return handler->get(inode, name, buffer, size);
+}
+
+/*
+ * Inode operation listxattr()
+ *
+ * dentry->d_inode->i_sem down
+ * BKL held [before 2.5.x]
+ */
+ssize_t
+ext3_listxattr(struct dentry *dentry, char *buffer, size_t size)
+{
+       return ext3_xattr_list(dentry->d_inode, buffer, size);
+}
+
+/*
+ * Inode operation setxattr()
+ *
+ * dentry->d_inode->i_sem down
+ * BKL held [before 2.5.x]
+ */
+int
+ext3_setxattr(struct dentry *dentry, const char *name,
+             void *value, size_t size, int flags)
+{
+       struct ext3_xattr_handler *handler;
+       struct inode *inode = dentry->d_inode;
+
+       if (size == 0)
+               value = "";  /* empty EA, do not remove */
+       handler = ext3_xattr_resolve_name(&name);
+       if (!handler)
+               return -ENOTSUP;
+       return handler->set(inode, name, value, size, flags);
+}
+
+/*
+ * Inode operation removexattr()
+ *
+ * dentry->d_inode->i_sem down
+ * BKL held [before 2.5.x]
+ */
+int
+ext3_removexattr(struct dentry *dentry, const char *name)
+{
+       struct ext3_xattr_handler *handler;
+       struct inode *inode = dentry->d_inode;
+
+       handler = ext3_xattr_resolve_name(&name);
+       if (!handler)
+               return -ENOTSUP;
+       return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
+}
+
+/*
+ * ext3_xattr_get()
+ *
+ * Copy an extended attribute into the buffer
+ * provided, or compute the buffer size required.
+ * Buffer is NULL to compute the size of the buffer required.
+ *
+ * Returns a negative error number on failure, or the number of bytes
+ * used / required on success.
+ */
+int
+ext3_xattr_get(struct inode *inode, int name_index, const char *name,
+              void *buffer, size_t buffer_size)
+{
+       struct buffer_head *bh = NULL;
+       struct ext3_xattr_entry *entry;
+       unsigned int block, size;
+       char *end;
+       int name_len, error;
+
+       ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
+                 name_index, name, buffer, (long)buffer_size);
+
+       if (name == NULL)
+               return -EINVAL;
+       if (!EXT3_I(inode)->i_file_acl)
+               return -ENOATTR;
+       block = EXT3_I(inode)->i_file_acl;
+       ea_idebug(inode, "reading block %d", block);
+       bh = sb_bread(inode->i_sb, block);
+       if (!bh)
+               return -EIO;
+       ea_bdebug(bh, "b_count=%d, refcount=%d",
+               atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
+       end = bh->b_data + bh->b_size;
+       if (HDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
+           HDR(bh)->h_blocks != cpu_to_le32(1)) {
+bad_block:     ext3_error(inode->i_sb, "ext3_xattr_get",
+                       "inode %ld: bad block %d", inode->i_ino, block);
+               error = -EIO;
+               goto cleanup;
+       }
+       /* find named attribute */
+       name_len = strlen(name);
+
+       error = -ERANGE;
+       if (name_len > 255)
+               goto cleanup;
+       entry = FIRST_ENTRY(bh);
+       while (!IS_LAST_ENTRY(entry)) {
+               struct ext3_xattr_entry *next =
+                       EXT3_XATTR_NEXT(entry);
+               if ((char *)next >= end)
+                       goto bad_block;
+               if (name_index == entry->e_name_index &&
+                   name_len == entry->e_name_len &&
+                   memcmp(name, entry->e_name, name_len) == 0)
+                       goto found;
+               entry = next;
+       }
+       /* Check the remaining name entries */
+       while (!IS_LAST_ENTRY(entry)) {
+               struct ext3_xattr_entry *next =
+                       EXT3_XATTR_NEXT(entry);
+               if ((char *)next >= end)
+                       goto bad_block;
+               entry = next;
+       }
+       if (ext3_xattr_cache_insert(bh))
+               ea_idebug(inode, "cache insert failed");
+       error = -ENOATTR;
+       goto cleanup;
+found:
+       /* check the buffer size */
+       if (entry->e_value_block != 0)
+               goto bad_block;
+       size = le32_to_cpu(entry->e_value_size);
+       if (size > inode->i_sb->s_blocksize ||
+           le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
+               goto bad_block;
+
+       if (ext3_xattr_cache_insert(bh))
+               ea_idebug(inode, "cache insert failed");
+       if (buffer) {
+               error = -ERANGE;
+               if (size > buffer_size)
+                       goto cleanup;
+               /* return value of attribute */
+               memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
+                       size);
+       }
+       error = size;
+
+cleanup:
+       brelse(bh);
+
+       return error;
+}
+
+/*
+ * ext3_xattr_list()
+ *
+ * Copy a list of attribute names into the buffer
+ * provided, or compute the buffer size required.
+ * Buffer is NULL to compute the size of the buffer required.
+ *
+ * Returns a negative error number on failure, or the number of bytes
+ * used / required on success.
+ */
+int
+ext3_xattr_list(struct inode *inode, char *buffer, size_t buffer_size)
+{
+       struct buffer_head *bh = NULL;
+       struct ext3_xattr_entry *entry;
+       unsigned int block, size = 0;
+       char *buf, *end;
+       int error;
+
+       ea_idebug(inode, "buffer=%p, buffer_size=%ld",
+                 buffer, (long)buffer_size);
+
+       if (!EXT3_I(inode)->i_file_acl)
+               return 0;
+       block = EXT3_I(inode)->i_file_acl;
+       ea_idebug(inode, "reading block %d", block);
+       bh = sb_bread(inode->i_sb, block);
+       if (!bh)
+               return -EIO;
+       ea_bdebug(bh, "b_count=%d, refcount=%d",
+               atomic_read(&(bh->b_count)), le32_to_cpu(HDR(bh)->h_refcount));
+       end = bh->b_data + bh->b_size;
+       if (HDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
+           HDR(bh)->h_blocks != cpu_to_le32(1)) {
+bad_block:     ext3_error(inode->i_sb, "ext3_xattr_list",
+                       "inode %ld: bad block %d", inode->i_ino, block);
+               error = -EIO;
+               goto cleanup;
+       }
+       /* compute the size required for the list of attribute names */
+       for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
+            entry = EXT3_XATTR_NEXT(entry)) {
+               struct ext3_xattr_handler *handler;
+               struct ext3_xattr_entry *next =
+                       EXT3_XATTR_NEXT(entry);
+               if ((char *)next >= end)
+                       goto bad_block;
+
+               handler = ext3_xattr_handler(entry->e_name_index);
+               if (handler) {
+                       size += handler->list(NULL, inode, entry->e_name,
+                                             entry->e_name_len) + 1;
+               }
+       }
+
+       if (ext3_xattr_cache_insert(bh))
+               ea_idebug(inode, "cache insert failed");
+       if (!buffer) {
+               error = size;
+               goto cleanup;
+       } else {
+               error = -ERANGE;
+               if (size > buffer_size)
+                       goto cleanup;
+       }
+
+       /* list the attribute names */
+       buf = buffer;
+       for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
+            entry = EXT3_XATTR_NEXT(entry)) {
+               struct ext3_xattr_handler *handler;
+
+               handler = ext3_xattr_handler(entry->e_name_index);
+               if (handler) {
+                       buf += handler->list(buf, inode, entry->e_name,
+                                            entry->e_name_len);
+                       *buf++ = '\0';
+               }
+       }
+       error = size;
+
+cleanup:
+       brelse(bh);
+
+       return error;
+}
+
+/*
+ * If the EXT3_FEATURE_COMPAT_EXT_ATTR feature of this file system is
+ * not set, set it.
+ */
+static void ext3_xattr_update_super_block(handle_t *handle,
+                                         struct super_block *sb)
+{
+       if (EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_EXT_ATTR))
+               return;
+
+       lock_super(sb);
+       ext3_journal_get_write_access(handle, EXT3_SB(sb)->s_sbh);
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)
+       EXT3_SB(sb)->s_feature_compat |= EXT3_FEATURE_COMPAT_EXT_ATTR;
+#endif
+       EXT3_SB(sb)->s_es->s_feature_compat |=
+               cpu_to_le32(EXT3_FEATURE_COMPAT_EXT_ATTR);
+       sb->s_dirt = 1;
+       ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
+       unlock_super(sb);
+}
+
+/*
+ * ext3_xattr_set()
+ *
+ * Create, replace or remove an extended attribute for this inode. Buffer
+ * is NULL to remove an existing extended attribute, and non-NULL to
+ * either replace an existing extended attribute, or create a new extended
+ * attribute. The flags XATTR_REPLACE and XATTR_CREATE
+ * specify that an extended attribute must exist and must not exist
+ * previous to the call, respectively.
+ *
+ * Returns 0, or a negative error number on failure.
+ */
+int
+ext3_xattr_set(handle_t *handle, struct inode *inode, int name_index,
+              const char *name, void *value, size_t value_len, int flags)
+{
+       struct super_block *sb = inode->i_sb;
+       struct buffer_head *bh = NULL;
+       struct ext3_xattr_header *header = NULL;
+       struct ext3_xattr_entry *here, *last;
+       unsigned int name_len;
+       int min_offs = sb->s_blocksize, not_found = 1, free, error;
+       char *end;
+       
+       /*
+        * header -- Points either into bh, or to a temporarily
+        *           allocated buffer.
+        * here -- The named entry found, or the place for inserting, within
+        *         the block pointed to by header.
+        * last -- Points right after the last named entry within the block
+        *         pointed to by header.
+        * min_offs -- The offset of the first value (values are aligned
+        *             towards the end of the block).
+        * end -- Points right after the block pointed to by header.
+        */
+       
+       ea_idebug(inode, "name=%d.%s, value=%p, value_len=%ld",
+                 name_index, name, value, (long)value_len);
+
+       if (IS_RDONLY(inode))
+               return -EROFS;
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               return -EPERM;
+       if (value == NULL)
+               value_len = 0;
+       if (name == NULL)
+               return -EINVAL;
+       name_len = strlen(name);
+       if (name_len > 255 || value_len > sb->s_blocksize)
+               return -ERANGE;
+       ext3_xattr_lock();
+
+       if (EXT3_I(inode)->i_file_acl) {
+               /* The inode already has an extended attribute block. */
+               int block = EXT3_I(inode)->i_file_acl;
+
+               bh = sb_bread(sb, block);
+               error = -EIO;
+               if (!bh)
+                       goto cleanup;
+               ea_bdebug(bh, "b_count=%d, refcount=%d",
+                       atomic_read(&(bh->b_count)),
+                       le32_to_cpu(HDR(bh)->h_refcount));
+               header = HDR(bh);
+               end = bh->b_data + bh->b_size;
+               if (header->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
+                   header->h_blocks != cpu_to_le32(1)) {
+bad_block:             ext3_error(sb, "ext3_xattr_set",
+                               "inode %ld: bad block %d", inode->i_ino, block);
+                       error = -EIO;
+                       goto cleanup;
+               }
+               /* Find the named attribute. */
+               here = FIRST_ENTRY(bh);
+               while (!IS_LAST_ENTRY(here)) {
+                       struct ext3_xattr_entry *next = EXT3_XATTR_NEXT(here);
+                       if ((char *)next >= end)
+                               goto bad_block;
+                       if (!here->e_value_block && here->e_value_size) {
+                               int offs = le16_to_cpu(here->e_value_offs);
+                               if (offs < min_offs)
+                                       min_offs = offs;
+                       }
+                       not_found = name_index - here->e_name_index;
+                       if (!not_found)
+                               not_found = name_len - here->e_name_len;
+                       if (!not_found)
+                               not_found = memcmp(name, here->e_name,name_len);
+                       if (not_found <= 0)
+                               break;
+                       here = next;
+               }
+               last = here;
+               /* We still need to compute min_offs and last. */
+               while (!IS_LAST_ENTRY(last)) {
+                       struct ext3_xattr_entry *next = EXT3_XATTR_NEXT(last);
+                       if ((char *)next >= end)
+                               goto bad_block;
+                       if (!last->e_value_block && last->e_value_size) {
+                               int offs = le16_to_cpu(last->e_value_offs);
+                               if (offs < min_offs)
+                                       min_offs = offs;
+                       }
+                       last = next;
+               }
+
+               /* Check whether we have enough space left. */
+               free = min_offs - ((char*)last - (char*)header) - sizeof(__u32);
+       } else {
+               /* We will use a new extended attribute block. */
+               free = sb->s_blocksize -
+                       sizeof(struct ext3_xattr_header) - sizeof(__u32);
+               here = last = NULL;  /* avoid gcc uninitialized warning. */
+       }
+
+       if (not_found) {
+               /* Request to remove a nonexistent attribute? */
+               error = -ENOATTR;
+               if (flags & XATTR_REPLACE)
+                       goto cleanup;
+               error = 0;
+               if (value == NULL)
+                       goto cleanup;
+               else
+                       free -= EXT3_XATTR_LEN(name_len);
+       } else {
+               /* Request to create an existing attribute? */
+               error = -EEXIST;
+               if (flags & XATTR_CREATE)
+                       goto cleanup;
+               if (!here->e_value_block && here->e_value_size) {
+                       unsigned int size = le32_to_cpu(here->e_value_size);
+
+                       if (le16_to_cpu(here->e_value_offs) + size > 
+                           sb->s_blocksize || size > sb->s_blocksize)
+                               goto bad_block;
+                       free += EXT3_XATTR_SIZE(size);
+               }
+       }
+       free -= EXT3_XATTR_SIZE(value_len);
+       error = -ENOSPC;
+       if (free < 0)
+               goto cleanup;
+
+       /* Here we know that we can set the new attribute. */
+
+       if (header) {
+               if (header->h_refcount == cpu_to_le32(1)) {
+                       ea_bdebug(bh, "modifying in-place");
+                       ext3_xattr_cache_remove(bh);
+                       error = ext3_journal_get_write_access(handle, bh);
+                       if (error)
+                               goto cleanup;
+               } else {
+                       int offset;
+
+                       ea_bdebug(bh, "cloning");
+                       header = kmalloc(bh->b_size, GFP_KERNEL);
+                       error = -ENOMEM;
+                       if (header == NULL)
+                               goto cleanup;
+                       memcpy(header, HDR(bh), bh->b_size);
+                       header->h_refcount = cpu_to_le32(1);
+                       offset = (char *)header - bh->b_data;
+                       here = ENTRY((char *)here + offset);
+                       last = ENTRY((char *)last + offset);
+               }
+       } else {
+               /* Allocate a buffer where we construct the new block. */
+               header = kmalloc(sb->s_blocksize, GFP_KERNEL);
+               error = -ENOMEM;
+               if (header == NULL)
+                       goto cleanup;
+               memset(header, 0, sb->s_blocksize);
+               end = (char *)header + sb->s_blocksize;
+               header->h_magic = cpu_to_le32(EXT3_XATTR_MAGIC);
+               header->h_blocks = header->h_refcount = cpu_to_le32(1);
+               last = here = ENTRY(header+1);
+       }
+
+       if (not_found) {
+               /* Insert the new name. */
+               int size = EXT3_XATTR_LEN(name_len);
+               int rest = (char *)last - (char *)here;
+               memmove((char *)here + size, here, rest);
+               memset(here, 0, size);
+               here->e_name_index = name_index;
+               here->e_name_len = name_len;
+               memcpy(here->e_name, name, name_len);
+       } else {
+               /* Remove the old value. */
+               if (!here->e_value_block && here->e_value_size) {
+                       char *first_val = (char *)header + min_offs;
+                       int offs = le16_to_cpu(here->e_value_offs);
+                       char *val = (char *)header + offs;
+                       size_t size = EXT3_XATTR_SIZE(
+                               le32_to_cpu(here->e_value_size));
+                       memmove(first_val + size, first_val, val - first_val);
+                       memset(first_val, 0, size);
+                       here->e_value_offs = 0;
+                       min_offs += size;
+
+                       /* Adjust all value offsets. */
+                       last = ENTRY(header+1);
+                       while (!IS_LAST_ENTRY(last)) {
+                               int o = le16_to_cpu(last->e_value_offs);
+                               if (!last->e_value_block && o < offs)
+                                       last->e_value_offs =
+                                               cpu_to_le16(o + size);
+                               last = EXT3_XATTR_NEXT(last);
+                       }
+               }
+               if (value == NULL) {
+                       /* Remove this attribute. */
+                       if (EXT3_XATTR_NEXT(ENTRY(header+1)) == last) {
+                               /* This block is now empty. */
+                               error = ext3_xattr_set2(handle, inode, bh,NULL);
+                               goto cleanup;
+                       } else {
+                               /* Remove the old name. */
+                               int size = EXT3_XATTR_LEN(name_len);
+                               last = ENTRY((char *)last - size);
+                               memmove(here, (char*)here + size,
+                                       (char*)last - (char*)here);
+                               memset(last, 0, size);
+                       }
+               }
+       }
+
+       if (value != NULL) {
+               /* Insert the new value. */
+               here->e_value_size = cpu_to_le32(value_len);
+               if (value_len) {
+                       size_t size = EXT3_XATTR_SIZE(value_len);
+                       char *val = (char *)header + min_offs - size;
+                       here->e_value_offs =
+                               cpu_to_le16((char *)val - (char *)header);
+                       memset(val + size - EXT3_XATTR_PAD, 0,
+                              EXT3_XATTR_PAD); /* Clear the pad bytes. */
+                       memcpy(val, value, value_len);
+               }
+       }
+       ext3_xattr_rehash(header, here);
+
+       error = ext3_xattr_set2(handle, inode, bh, header);
+
+cleanup:
+       brelse(bh);
+       if (!(bh && header == HDR(bh)))
+               kfree(header);
+       ext3_xattr_unlock();
+
+       return error;
+}
+
+/*
+ * Second half of ext3_xattr_set(): Update the file system.
+ */
+static int
+ext3_xattr_set2(handle_t *handle, struct inode *inode,
+               struct buffer_head *old_bh, struct ext3_xattr_header *header)
+{
+       struct super_block *sb = inode->i_sb;
+       struct buffer_head *new_bh = NULL;
+       int error;
+
+       if (header) {
+               new_bh = ext3_xattr_cache_find(inode, header);
+               if (new_bh) {
+                       /*
+                        * We found an identical block in the cache.
+                        * The old block will be released after updating
+                        * the inode.
+                        */
+                       ea_bdebug(old_bh, "reusing block %ld",
+                               new_bh->b_blocknr);
+                       
+                       error = -EDQUOT;
+                       if (ext3_xattr_quota_alloc(inode, 1))
+                               goto cleanup;
+                       
+                       error = ext3_journal_get_write_access(handle, new_bh);
+                       if (error)
+                               goto cleanup;
+                       HDR(new_bh)->h_refcount = cpu_to_le32(
+                               le32_to_cpu(HDR(new_bh)->h_refcount) + 1);
+                       ea_bdebug(new_bh, "refcount now=%d",
+                               le32_to_cpu(HDR(new_bh)->h_refcount));
+               } else if (old_bh && header == HDR(old_bh)) {
+                       /* Keep this block. */
+                       new_bh = old_bh;
+                       (void)ext3_xattr_cache_insert(new_bh);
+               } else {
+                       /* We need to allocate a new block */
+                       int force = EXT3_I(inode)->i_file_acl != 0;
+                       int block = ext3_xattr_new_block(handle, inode,
+                                                        &error, force);
+                       if (error)
+                               goto cleanup;
+                       ea_idebug(inode, "creating block %d", block);
+
+                       new_bh = sb_getblk(sb, block);
+                       if (!new_bh) {
+getblk_failed:                 ext3_xattr_free_block(handle, inode, block);
+                               error = -EIO;
+                               goto cleanup;
+                       }
+                       lock_buffer(new_bh);
+                       error = ext3_journal_get_create_access(handle, new_bh);
+                       if (error) {
+                               unlock_buffer(new_bh);
+                               goto getblk_failed;
+                       }
+                       memcpy(new_bh->b_data, header, new_bh->b_size);
+                       mark_buffer_uptodate(new_bh, 1);
+                       unlock_buffer(new_bh);
+                       (void)ext3_xattr_cache_insert(new_bh);
+                       ext3_xattr_update_super_block(handle, sb);
+               }
+               error = ext3_journal_dirty_metadata(handle, new_bh);
+               if (error)
+                       goto cleanup;
+       }
+
+       /* Update the inode. */
+       EXT3_I(inode)->i_file_acl = new_bh ? new_bh->b_blocknr : 0;
+       inode->i_ctime = CURRENT_TIME;
+       ext3_mark_inode_dirty(handle, inode);
+       if (IS_SYNC(inode))
+               handle->h_sync = 1;
+
+       error = 0;
+       if (old_bh && old_bh != new_bh) {
+               /*
+                * If there was an old block, and we are not still using it,
+                * we now release the old block.
+               */
+               unsigned int refcount = le32_to_cpu(HDR(old_bh)->h_refcount);
+
+               error = ext3_journal_get_write_access(handle, old_bh);
+               if (error)
+                       goto cleanup;
+               if (refcount == 1) {
+                       /* Free the old block. */
+                       ea_bdebug(old_bh, "freeing");
+                       ext3_xattr_free_block(handle, inode, old_bh->b_blocknr);
+
+                       /* ext3_forget() calls bforget() for us, but we
+                          let our caller release old_bh, so we need to
+                          duplicate the handle before. */
+                       get_bh(old_bh);
+                       ext3_forget(handle, 1, inode, old_bh,old_bh->b_blocknr);
+               } else {
+                       /* Decrement the refcount only. */
+                       refcount--;
+                       HDR(old_bh)->h_refcount = cpu_to_le32(refcount);
+                       ext3_xattr_quota_free(inode);
+                       ext3_journal_dirty_metadata(handle, old_bh);
+                       ea_bdebug(old_bh, "refcount now=%d", refcount);
+               }
+       }
+
+cleanup:
+       if (old_bh != new_bh)
+               brelse(new_bh);
+
+       return error;
+}
+
+/*
+ * ext3_xattr_drop_inode()
+ *
+ * Free extended attribute resources associated with this inode. This
+ * is called immediately before an inode is freed.
+ */
+void
+ext3_xattr_drop_inode(handle_t *handle, struct inode *inode)
+{
+       struct buffer_head *bh;
+       unsigned int block = EXT3_I(inode)->i_file_acl;
+
+       if (!block)
+               return;
+       ext3_xattr_lock();
+
+       bh = sb_bread(inode->i_sb, block);
+       if (!bh) {
+               ext3_error(inode->i_sb, "ext3_xattr_drop_inode",
+                       "inode %ld: block %d read error", inode->i_ino, block);
+               goto cleanup;
+       }
+       ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
+       if (HDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
+           HDR(bh)->h_blocks != cpu_to_le32(1)) {
+               ext3_error(inode->i_sb, "ext3_xattr_drop_inode",
+                       "inode %ld: bad block %d", inode->i_ino, block);
+               goto cleanup;
+       }
+       ext3_journal_get_write_access(handle, bh);
+       ea_bdebug(bh, "refcount now=%d", le32_to_cpu(HDR(bh)->h_refcount) - 1);
+       if (HDR(bh)->h_refcount == cpu_to_le32(1)) {
+               ext3_xattr_cache_remove(bh);
+               ext3_xattr_free_block(handle, inode, block);
+               ext3_forget(handle, 1, inode, bh, block);
+               bh = NULL;
+       } else {
+               HDR(bh)->h_refcount = cpu_to_le32(
+                       le32_to_cpu(HDR(bh)->h_refcount) - 1);
+               ext3_journal_dirty_metadata(handle, bh);
+               if (IS_SYNC(inode))
+                       handle->h_sync = 1;
+               ext3_xattr_quota_free(inode);
+       }
+       EXT3_I(inode)->i_file_acl = 0;
+
+cleanup:
+       brelse(bh);
+       ext3_xattr_unlock();
+}
+
+/*
+ * ext3_xattr_put_super()
+ *
+ * This is called when a file system is unmounted.
+ */
+void
+ext3_xattr_put_super(struct super_block *sb)
+{
+#ifdef CONFIG_EXT3_FS_XATTR_SHARING
+       mb_cache_shrink(ext3_xattr_cache, sb->s_dev);
+#endif
+}
+
+#ifdef CONFIG_EXT3_FS_XATTR_SHARING
+
+/*
+ * ext3_xattr_cache_insert()
+ *
+ * Create a new entry in the extended attribute cache, and insert
+ * it unless such an entry is already in the cache.
+ *
+ * Returns 0, or a negative error number on failure.
+ */
+static int
+ext3_xattr_cache_insert(struct buffer_head *bh)
+{
+       __u32 hash = le32_to_cpu(HDR(bh)->h_hash);
+       struct mb_cache_entry *ce;
+       int error;
+
+       ce = mb_cache_entry_alloc(ext3_xattr_cache);
+       if (!ce)
+               return -ENOMEM;
+       error = mb_cache_entry_insert(ce, bh->b_dev, bh->b_blocknr, &hash);
+       if (error) {
+               mb_cache_entry_free(ce);
+               if (error == -EBUSY) {
+                       ea_bdebug(bh, "already in cache (%d cache entries)",
+                               atomic_read(&ext3_xattr_cache->c_entry_count));
+                       error = 0;
+               }
+       } else {
+               ea_bdebug(bh, "inserting [%x] (%d cache entries)", (int)hash,
+                         atomic_read(&ext3_xattr_cache->c_entry_count));
+               mb_cache_entry_release(ce);
+       }
+       return error;
+}
+
+/*
+ * ext3_xattr_cmp()
+ *
+ * Compare two extended attribute blocks for equality.
+ *
+ * Returns 0 if the blocks are equal, 1 if they differ, and
+ * a negative error number on errors.
+ */
+static int
+ext3_xattr_cmp(struct ext3_xattr_header *header1,
+              struct ext3_xattr_header *header2)
+{
+       struct ext3_xattr_entry *entry1, *entry2;
+
+       entry1 = ENTRY(header1+1);
+       entry2 = ENTRY(header2+1);
+       while (!IS_LAST_ENTRY(entry1)) {
+               if (IS_LAST_ENTRY(entry2))
+                       return 1;
+               if (entry1->e_hash != entry2->e_hash ||
+                   entry1->e_name_len != entry2->e_name_len ||
+                   entry1->e_value_size != entry2->e_value_size ||
+                   memcmp(entry1->e_name, entry2->e_name, entry1->e_name_len))
+                       return 1;
+               if (entry1->e_value_block != 0 || entry2->e_value_block != 0)
+                       return -EIO;
+               if (memcmp((char *)header1 + le16_to_cpu(entry1->e_value_offs),
+                          (char *)header2 + le16_to_cpu(entry2->e_value_offs),
+                          le32_to_cpu(entry1->e_value_size)))
+                       return 1;
+
+               entry1 = EXT3_XATTR_NEXT(entry1);
+               entry2 = EXT3_XATTR_NEXT(entry2);
+       }
+       if (!IS_LAST_ENTRY(entry2))
+               return 1;
+       return 0;
+}
+
+/*
+ * ext3_xattr_cache_find()
+ *
+ * Find an identical extended attribute block.
+ *
+ * Returns a pointer to the block found, or NULL if such a block was
+ * not found or an error occurred.
+ */
+static struct buffer_head *
+ext3_xattr_cache_find(struct inode *inode, struct ext3_xattr_header *header)
+{
+       __u32 hash = le32_to_cpu(header->h_hash);
+       struct mb_cache_entry *ce;
+
+       if (!header->h_hash)
+               return NULL;  /* never share */
+       ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
+       ce = mb_cache_entry_find_first(ext3_xattr_cache, 0, inode->i_dev, hash);
+       while (ce) {
+               struct buffer_head *bh = sb_bread(inode->i_sb, ce->e_block);
+
+               if (!bh) {
+                       ext3_error(inode->i_sb, "ext3_xattr_cache_find",
+                               "inode %ld: block %ld read error",
+                               inode->i_ino, ce->e_block);
+               } else if (le32_to_cpu(HDR(bh)->h_refcount) >
+                          EXT3_XATTR_REFCOUNT_MAX) {
+                       ea_idebug(inode, "block %ld refcount %d>%d",ce->e_block,
+                               le32_to_cpu(HDR(bh)->h_refcount),
+                               EXT3_XATTR_REFCOUNT_MAX);
+               } else if (!ext3_xattr_cmp(header, HDR(bh))) {
+                       ea_bdebug(bh, "b_count=%d",atomic_read(&(bh->b_count)));
+                       mb_cache_entry_release(ce);
+                       return bh;
+               }
+               brelse(bh);
+               ce = mb_cache_entry_find_next(ce, 0, inode->i_dev, hash);
+       }
+       return NULL;
+}
+
+/*
+ * ext3_xattr_cache_remove()
+ *
+ * Remove the cache entry of a block from the cache. Called when a
+ * block becomes invalid.
+ */
+static void
+ext3_xattr_cache_remove(struct buffer_head *bh)
+{
+       struct mb_cache_entry *ce;
+
+       ce = mb_cache_entry_get(ext3_xattr_cache, bh->b_dev, bh->b_blocknr);
+       if (ce) {
+               ea_bdebug(bh, "removing (%d cache entries remaining)",
+                         atomic_read(&ext3_xattr_cache->c_entry_count)-1);
+               mb_cache_entry_free(ce);
+       } else 
+               ea_bdebug(bh, "no cache entry");
+}
+
+#define NAME_HASH_SHIFT 5
+#define VALUE_HASH_SHIFT 16
+
+/*
+ * ext3_xattr_hash_entry()
+ *
+ * Compute the hash of an extended attribute.
+ */
+static inline void ext3_xattr_hash_entry(struct ext3_xattr_header *header,
+                                        struct ext3_xattr_entry *entry)
+{
+       __u32 hash = 0;
+       char *name = entry->e_name;
+       int n;
+
+       for (n=0; n < entry->e_name_len; n++) {
+               hash = (hash << NAME_HASH_SHIFT) ^
+                      (hash >> (8*sizeof(hash) - NAME_HASH_SHIFT)) ^
+                      *name++;
+       }
+
+       if (entry->e_value_block == 0 && entry->e_value_size != 0) {
+               __u32 *value = (__u32 *)((char *)header +
+                       le16_to_cpu(entry->e_value_offs));
+               for (n = (le32_to_cpu(entry->e_value_size) +
+                    EXT3_XATTR_ROUND) >> EXT3_XATTR_PAD_BITS; n; n--) {
+                       hash = (hash << VALUE_HASH_SHIFT) ^
+                              (hash >> (8*sizeof(hash) - VALUE_HASH_SHIFT)) ^
+                              le32_to_cpu(*value++);
+               }
+       }
+       entry->e_hash = cpu_to_le32(hash);
+}
+
+#undef NAME_HASH_SHIFT
+#undef VALUE_HASH_SHIFT
+
+#define BLOCK_HASH_SHIFT 16
+
+/*
+ * ext3_xattr_rehash()
+ *
+ * Re-compute the extended attribute hash value after an entry has changed.
+ */
+static void ext3_xattr_rehash(struct ext3_xattr_header *header,
+                             struct ext3_xattr_entry *entry)
+{
+       struct ext3_xattr_entry *here;
+       __u32 hash = 0;
+       
+       ext3_xattr_hash_entry(header, entry);
+       here = ENTRY(header+1);
+       while (!IS_LAST_ENTRY(here)) {
+               if (!here->e_hash) {
+                       /* Block is not shared if an entry's hash value == 0 */
+                       hash = 0;
+                       break;
+               }
+               hash = (hash << BLOCK_HASH_SHIFT) ^
+                      (hash >> (8*sizeof(hash) - BLOCK_HASH_SHIFT)) ^
+                      le32_to_cpu(here->e_hash);
+               here = EXT3_XATTR_NEXT(here);
+       }
+       header->h_hash = cpu_to_le32(hash);
+}
+
+#undef BLOCK_HASH_SHIFT
+
+int __init
+init_ext3_xattr(void)
+{
+       ext3_xattr_cache = mb_cache_create("ext3_xattr", NULL,
+               sizeof(struct mb_cache_entry) +
+               sizeof(struct mb_cache_entry_index), 1, 61);
+       if (!ext3_xattr_cache)
+               return -ENOMEM;
+
+       return 0;
+}
+
+void
+exit_ext3_xattr(void)
+{
+       if (ext3_xattr_cache)
+               mb_cache_destroy(ext3_xattr_cache);
+       ext3_xattr_cache = NULL;
+}
+
+#else  /* CONFIG_EXT3_FS_XATTR_SHARING */
+
+int __init
+init_ext3_xattr(void)
+{
+       return 0;
+}
+
+void
+exit_ext3_xattr(void)
+{
+}
+
+#endif  /* CONFIG_EXT3_FS_XATTR_SHARING */
diff -Nur linux-2.4.18/include/linux/ext3_fs.h linux-2.4.18ea/include/linux/ext3_fs.h
--- linux-2.4.18/include/linux/ext3_fs.h        Sun Feb 24 04:42:59 2002
+++ linux-2.4.18ea/include/linux/ext3_fs.h      Mon Mar 11 03:27:00 2002
@@ -58,8 +58,6 @@
  */
 #define        EXT3_BAD_INO             1      /* Bad blocks inode */
 #define EXT3_ROOT_INO           2      /* Root inode */
-#define EXT3_ACL_IDX_INO        3      /* ACL inode */
-#define EXT3_ACL_DATA_INO       4      /* ACL inode */
 #define EXT3_BOOT_LOADER_INO    5      /* Boot loader inode */
 #define EXT3_UNDEL_DIR_INO      6      /* Undelete directory inode */
 #define EXT3_RESIZE_INO                 7      /* Reserved group descriptors inode */
@@ -89,7 +87,6 @@
 #else
 # define EXT3_BLOCK_SIZE(s)            (EXT3_MIN_BLOCK_SIZE << (s)->s_log_block_size)
 #endif
-#define EXT3_ACLE_PER_BLOCK(s)         (EXT3_BLOCK_SIZE(s) / sizeof (struct ext3_acl_entry))
 #define        EXT3_ADDR_PER_BLOCK(s)          (EXT3_BLOCK_SIZE(s) / sizeof (__u32))
 #ifdef __KERNEL__
 # define EXT3_BLOCK_SIZE_BITS(s)       ((s)->s_blocksize_bits)
@@ -124,28 +121,6 @@
 #endif
 
 /*
- * ACL structures
- */
-struct ext3_acl_header /* Header of Access Control Lists */
-{
-       __u32   aclh_size;
-       __u32   aclh_file_count;
-       __u32   aclh_acle_count;
-       __u32   aclh_first_acle;
-};
-
-struct ext3_acl_entry  /* Access Control List Entry */
-{
-       __u32   acle_size;
-       __u16   acle_perms;     /* Access permissions */
-       __u16   acle_type;      /* Type of entry */
-       __u16   acle_tag;       /* User or group identity */
-       __u16   acle_pad1;
-       __u32   acle_next;      /* Pointer on next entry for the */
-                                       /* same inode or on next free entry */
-};
-
-/*
  * Structure of a blocks group descriptor
  */
 struct ext3_group_desc
@@ -512,7 +487,7 @@
 #define EXT3_FEATURE_INCOMPAT_RECOVER          0x0004 /* Needs recovery */
 #define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV      0x0008 /* Journal device */
 
-#define EXT3_FEATURE_COMPAT_SUPP       0
+#define EXT3_FEATURE_COMPAT_SUPP       EXT3_FEATURE_COMPAT_EXT_ATTR
 #define EXT3_FEATURE_INCOMPAT_SUPP     (EXT3_FEATURE_INCOMPAT_FILETYPE| \
                                         EXT3_FEATURE_INCOMPAT_RECOVER)
 #define EXT3_FEATURE_RO_COMPAT_SUPP    (EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER| \
@@ -603,4 +578,22 @@
 */
 
+/* Defined for extended attributes */
+#define CONFIG_EXT3_FS_XATTR y
+#ifndef ENOATTR
+#define ENOATTR ENODATA                /* No such attribute */
+#endif
+#ifndef ENOTSUP
+#define ENOTSUP EOPNOTSUPP     /* Operation not supported */
+#endif
+#ifndef XATTR_NAME_MAX
+#define XATTR_NAME_MAX   255   /* # chars in an extended attribute name */
+#define XATTR_SIZE_MAX 65536   /* size of an extended attribute value (64k) */
+#define XATTR_LIST_MAX 65536   /* size of extended attribute namelist (64k) */
+#endif
+#ifndef XATTR_CREATE
+#define XATTR_CREATE   1       /* set value, fail if attr already exists */
+#define XATTR_REPLACE  2       /* set value, fail if attr does not exist */
+#endif
+
 /*
  * Ok, these declarations are also in <linux/kernel.h> but none of the
@@ -628,6 +603,7 @@
 extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
 
 /* inode.c */
+extern int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int);
 extern struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
 extern struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
 
@@ -694,8 +670,10 @@
 
 /* namei.c */
 extern struct inode_operations ext3_dir_inode_operations;
+extern struct inode_operations ext3_special_inode_operations;
 
 /* symlink.c */
+extern struct inode_operations ext3_symlink_inode_operations;
 extern struct inode_operations ext3_fast_symlink_inode_operations;
 
 
diff -Nur linux-2.4.18/include/linux/ext3_jbd.h linux-2.4.18ea/include/linux/ext3_jbd.h
--- linux-2.4.18/include/linux/ext3_jbd.h       Fri Dec 21 18:42:03 2001
+++ linux-2.4.18ea/include/linux/ext3_jbd.h     Mon Mar 25 00:11:36 2002
@@ -30,13 +30,19 @@
 
 #define EXT3_SINGLEDATA_TRANS_BLOCKS   8
 
+/* Extended attributes may touch two data buffers, two bitmap buffers,
+ * and two group and summaries. */
+
+#define EXT3_XATTR_TRANS_BLOCKS                8
+
 /* Define the minimum size for a transaction which modifies data.  This
  * needs to take into account the fact that we may end up modifying two
  * quota files too (one for the group, one for the user quota).  The
  * superblock only gets updated once, of course, so don't bother
  * counting that again for the quota updates. */
 
-#define EXT3_DATA_TRANS_BLOCKS         (3 * EXT3_SINGLEDATA_TRANS_BLOCKS - 2)
+#define EXT3_DATA_TRANS_BLOCKS         (3 * EXT3_SINGLEDATA_TRANS_BLOCKS + \
+                                        EXT3_XATTR_TRANS_BLOCKS - 2)
 
 extern int ext3_writepage_trans_blocks(struct inode *inode);
 
diff -Nur linux-2.4.18/include/linux/ext3_xattr.h linux-2.4.18ea/include/linux/ext3_xattr.h
--- linux-2.4.18/include/linux/ext3_xattr.h     Thu Jan  1 01:00:00 1970
+++ linux-2.4.18ea/include/linux/ext3_xattr.h   Fri Apr  5 10:08:01 2002
@@ -0,0 +1,155 @@
+/*
+  File: linux/ext3_xattr.h
+
+  On-disk format of extended attributes for the ext3 filesystem.
+
+  (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
+*/
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/xattr.h>
+
+/* Magic value in attribute blocks */
+#define EXT3_XATTR_MAGIC               0xEA020000
+
+/* Maximum number of references to one attribute block */
+#define EXT3_XATTR_REFCOUNT_MAX                1024
+
+/* Name indexes */
+#define EXT3_XATTR_INDEX_MAX                   10
+#define EXT3_XATTR_INDEX_USER                  1
+
+struct ext3_xattr_header {
+       __u32   h_magic;        /* magic number for identification */
+       __u32   h_refcount;     /* reference count */
+       __u32   h_blocks;       /* number of disk blocks used */
+       __u32   h_hash;         /* hash value of all attributes */
+       __u32   h_reserved[4];  /* zero right now */
+};
+
+struct ext3_xattr_entry {
+       __u8    e_name_len;     /* length of name */
+       __u8    e_name_index;   /* attribute name index */
+       __u16   e_value_offs;   /* offset in disk block of value */
+       __u32   e_value_block;  /* disk block attribute is stored on (n/i) */
+       __u32   e_value_size;   /* size of attribute value */
+       __u32   e_hash;         /* hash value of name and value */
+       char    e_name[0];      /* attribute name */
+};
+
+#define EXT3_XATTR_PAD_BITS            2
+#define EXT3_XATTR_PAD         (1<<EXT3_XATTR_PAD_BITS)
+#define EXT3_XATTR_ROUND               (EXT3_XATTR_PAD-1)
+#define EXT3_XATTR_LEN(name_len) \
+       (((name_len) + EXT3_XATTR_ROUND + \
+       sizeof(struct ext3_xattr_entry)) & ~EXT3_XATTR_ROUND)
+#define EXT3_XATTR_NEXT(entry) \
+       ( (struct ext3_xattr_entry *)( \
+         (char *)(entry) + EXT3_XATTR_LEN((entry)->e_name_len)) )
+#define EXT3_XATTR_SIZE(size) \
+       (((size) + EXT3_XATTR_ROUND) & ~EXT3_XATTR_ROUND)
+
+#ifdef __KERNEL__
+
+# ifdef CONFIG_EXT3_FS_XATTR
+
+struct ext3_xattr_handler {
+       char *prefix;
+       size_t (*list)(char *list, struct inode *inode, const char *name,
+                      int name_len);
+       int (*get)(struct inode *inode, const char *name, void *buffer,
+                  size_t size);
+       int (*set)(struct inode *inode, const char *name, void *buffer,
+                  size_t size, int flags);
+};
+
+extern int ext3_xattr_register(int, struct ext3_xattr_handler *);
+extern void ext3_xattr_unregister(int, struct ext3_xattr_handler *);
+
+extern int ext3_setxattr(struct dentry *, const char *, void *, size_t, int);
+extern ssize_t ext3_getxattr(struct dentry *, const char *, void *, size_t);
+extern ssize_t ext3_listxattr(struct dentry *, char *, size_t);
+extern int ext3_removexattr(struct dentry *, const char *);
+
+extern int ext3_xattr_get(struct inode *, int, const char *, void *, size_t);
+extern int ext3_xattr_list(struct inode *, char *, size_t);
+extern int ext3_xattr_set(handle_t *handle, struct inode *, int, const char *, void *, size_t, int);
+
+extern void ext3_xattr_drop_inode(handle_t *, struct inode *);
+extern void ext3_xattr_put_super(struct super_block *);
+
+extern int init_ext3_xattr(void) __init;
+extern void exit_ext3_xattr(void);
+
+# else  /* CONFIG_EXT3_FS_XATTR */
+#  define ext3_setxattr                NULL
+#  define ext3_getxattr                NULL
+#  define ext3_listxattr       NULL
+#  define ext3_removexattr     NULL
+
+static inline int
+ext3_xattr_get(struct inode *inode, int name_index, const char *name,
+              void *buffer, size_t size, int flags)
+{
+       return -ENOTSUP;
+}
+
+static inline int
+ext3_xattr_list(struct inode *inode, void *buffer, size_t size, int flags)
+{
+       return -ENOTSUP;
+}
+
+static inline int
+ext3_xattr_set(handle_t *handle, struct inode *inode, int name_index,
+              const char *name, void *value, size_t size, int flags)
+{
+       return -ENOTSUP;
+}
+
+static inline void
+ext3_xattr_drop_inode(handle_t *handle, struct inode *inode)
+{
+}
+
+static inline void
+ext3_xattr_put_super(struct super_block *sb)
+{
+}
+
+static inline int
+init_ext3_xattr(void)
+{
+       return 0;
+}
+
+static inline void
+exit_ext3_xattr(void)
+{
+}
+
+# endif  /* CONFIG_EXT3_FS_XATTR */
+
+# ifdef CONFIG_EXT3_FS_XATTR_USER
+
+extern int init_ext3_xattr_user(void) __init;
+extern void exit_ext3_xattr_user(void);
+
+# else  /* CONFIG_EXT3_FS_XATTR_USER */
+
+static inline int
+init_ext3_xattr_user(void)
+{
+       return 0;
+}
+
+static inline void
+exit_ext3_xattr_user(void)
+{
+}
+
+#endif  /* CONFIG_EXT3_FS_XATTR_USER */
+
+#endif  /* __KERNEL__ */
+
diff -Nur linux-2.4.18/include/linux/xattr.h linux-2.4.18ea/include/linux/xattr.h
--- linux-2.4.18/include/linux/xattr.h  Thu Jan  1 01:00:00 1970
+++ linux-2.4.18ea/include/linux/xattr.h        Sun Mar 24 23:42:21 2002
@@ -0,0 +1,15 @@
+/*
+  File: linux/xattr.h
+
+  Extended attributes handling.
+
+  Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
+  Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
+*/
+#ifndef _LINUX_XATTR_H
+#define _LINUX_XATTR_H
+
+#define XATTR_CREATE   1       /* set value, fail if attr already exists */
+#define XATTR_REPLACE  2       /* set value, fail if attr does not exist */
+
+#endif /* _LINUX_XATTR_H */