1 files changed, 30 insertions, 98 deletions

diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index cc061bfd437b..ffb79c48c5bf 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -368,15 +368,13 @@ static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 if (d_reclen <= 32) {
                         local_buf = small_buf;
                 } else {
-                        local_buf =
-                            reiserfs_kmalloc(d_reclen, GFP_NOFS, inode->i_sb);
+                        local_buf = kmalloc(d_reclen, GFP_NOFS);
                         if (!local_buf) {
                                 pathrelse(&path_to_entry);
                                 return -ENOMEM;
                         }
                         if (item_moved(&tmp_ih, &path_to_entry)) {
-                                reiserfs_kfree(local_buf, d_reclen,
-                                               inode->i_sb);
+                                kfree(local_buf);
 
                                 /* sigh, must retry.  Do this same offset again */
                                 next_pos = d_off;
@@ -399,13 +397,12 @@ static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
                 if (filldir(dirent, local_buf, d_reclen, d_off, d_ino,
                             DT_UNKNOWN) < 0) {
                         if (local_buf != small_buf) {
-                                reiserfs_kfree(local_buf, d_reclen,
-                                               inode->i_sb);
+                                kfree(local_buf);
                         }
                         goto end;
                 }
                 if (local_buf != small_buf) {
-                        reiserfs_kfree(local_buf, d_reclen, inode->i_sb);
+                        kfree(local_buf);
                 }
         }                       /* while */
 
@@ -1322,109 +1319,44 @@ int reiserfs_xattr_init(struct super_block *s, int mount_flags)
         return err;
 }
 
-static int
-__reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd,
-                      int need_lock)
+static int reiserfs_check_acl(struct inode *inode, int mask)
 {
-        umode_t mode = inode->i_mode;
-
-        if (mask & MAY_WRITE) {
-                /*
-                 * Nobody gets write access to a read-only fs.
-                 */
-                if (IS_RDONLY(inode) &&
-                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
-                        return -EROFS;
+        struct posix_acl *acl;
+        int error = -EAGAIN; /* do regular unix permission checks by default */
 
-                /*
-                 * Nobody gets write access to an immutable file.
-                 */
-                if (IS_IMMUTABLE(inode))
-                        return -EACCES;
-        }
+        reiserfs_read_lock_xattr_i(inode);
+        reiserfs_read_lock_xattrs(inode->i_sb);
 
-        /* We don't do permission checks on the internal objects.
-         * Permissions are determined by the "owning" object. */
-        if (is_reiserfs_priv_object(inode))
-                return 0;
+        acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
 
-        if (current->fsuid == inode->i_uid) {
-                mode >>= 6;
-#ifdef CONFIG_REISERFS_FS_POSIX_ACL
-        } else if (reiserfs_posixacl(inode->i_sb) &&
-                   get_inode_sd_version(inode) != STAT_DATA_V1) {
-                struct posix_acl *acl;
-
-                /* ACL can't contain additional permissions if
-                   the ACL_MASK entry is 0 */
-                if (!(mode & S_IRWXG))
-                        goto check_groups;
-
-                if (need_lock) {
-                        reiserfs_read_lock_xattr_i(inode);
-                        reiserfs_read_lock_xattrs(inode->i_sb);
-                }
-                acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
-                if (need_lock) {
-                        reiserfs_read_unlock_xattrs(inode->i_sb);
-                        reiserfs_read_unlock_xattr_i(inode);
-                }
-                if (IS_ERR(acl)) {
-                        if (PTR_ERR(acl) == -ENODATA)
-                                goto check_groups;
-                        return PTR_ERR(acl);
-                }
+        reiserfs_read_unlock_xattrs(inode->i_sb);
+        reiserfs_read_unlock_xattr_i(inode);
 
-                if (acl) {
-                        int err = posix_acl_permission(inode, acl, mask);
+        if (acl) {
+                if (!IS_ERR(acl)) {
+                        error = posix_acl_permission(inode, acl, mask);
                         posix_acl_release(acl);
-                        if (err == -EACCES) {
-                                goto check_capabilities;
-                        }
-                        return err;
-                } else {
-                        goto check_groups;
-                }
-#endif
-        } else {
-              check_groups:
-                if (in_group_p(inode->i_gid))
-                        mode >>= 3;
+                } else if (PTR_ERR(acl) != -ENODATA)
+                        error = PTR_ERR(acl);
         }
 
-        /*
-         * If the DACs are ok we don't need any capability check.
-         */
-        if (((mode & mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) == mask))
-                return 0;
+        return error;
+}
 
-      check_capabilities:
+int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd)
+{
         /*
-         * Read/write DACs are always overridable.
-         * Executable DACs are overridable if at least one exec bit is set.
+         * We don't do permission checks on the internal objects.
+         * Permissions are determined by the "owning" object.
          */
-        if (!(mask & MAY_EXEC) ||
-            (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
-                if (capable(CAP_DAC_OVERRIDE))
-                        return 0;
+        if (is_reiserfs_priv_object(inode))
+                return 0;
 
         /*
-         * Searching includes executable on directories, else just read.
+         * Stat data v1 doesn't support ACLs.
          */
-        if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
-                if (capable(CAP_DAC_READ_SEARCH))
-                        return 0;
-
-        return -EACCES;
-}
-
-int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd)
-{
-        return __reiserfs_permission(inode, mask, nd, 1);
-}
-
-int
-reiserfs_permission_locked(struct inode *inode, int mask, struct nameidata *nd)
-{
-        return __reiserfs_permission(inode, mask, nd, 0);
+        if (get_inode_sd_version(inode) == STAT_DATA_V1)
+                return generic_permission(inode, mask, NULL);
+        else
+                return generic_permission(inode, mask, reiserfs_check_acl);
 }