Merge branch 'timers/range-hrtimers' into v28-range-hrtimers-for-linus-v2

[linux-2.6-omap-h63xx.git] / fs / ext4 / acl.c

diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index a8bae8cd1d5de707c9a8772464ca4ecaa93044ed..694ed6fadcc8c59e1936a49919c67a427ba670e5 100644 (file)
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -9,8 +9,8 @@
 #include <linux/slab.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/ext4_jbd2.h>
-#include <linux/ext4_fs.h>
+#include "ext4_jbd2.h"
+#include "ext4.h"
 #include "xattr.h"
 #include "acl.h"
 
@@ -37,37 +37,38 @@ ext4_acl_from_disk(const void *value, size_t size)
                return ERR_PTR(-EINVAL);
        if (count == 0)
                return NULL;
-       acl = posix_acl_alloc(count, GFP_KERNEL);
+       acl = posix_acl_alloc(count, GFP_NOFS);
        if (!acl)
                return ERR_PTR(-ENOMEM);
-       for (n=0; n < count; n++) {
+       for (n = 0; n < count; n++) {
                ext4_acl_entry *entry =
                        (ext4_acl_entry *)value;
                if ((char *)value + sizeof(ext4_acl_entry_short) > end)
                        goto fail;
                acl->a_entries[n].e_tag  = le16_to_cpu(entry->e_tag);
                acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
-               switch(acl->a_entries[n].e_tag) {
-                       case ACL_USER_OBJ:
-                       case ACL_GROUP_OBJ:
-                       case ACL_MASK:
-                       case ACL_OTHER:
-                               value = (char *)value +
-                                       sizeof(ext4_acl_entry_short);
-                               acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
-                               break;
-
-                       case ACL_USER:
-                       case ACL_GROUP:
-                               value = (char *)value + sizeof(ext4_acl_entry);
-                               if ((char *)value > end)
-                                       goto fail;
-                               acl->a_entries[n].e_id =
-                                       le32_to_cpu(entry->e_id);
-                               break;
-
-                       default:
+
+               switch (acl->a_entries[n].e_tag) {
+               case ACL_USER_OBJ:
+               case ACL_GROUP_OBJ:
+               case ACL_MASK:
+               case ACL_OTHER:
+                       value = (char *)value +
+                               sizeof(ext4_acl_entry_short);
+                       acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
+                       break;
+
+               case ACL_USER:
+               case ACL_GROUP:
+                       value = (char *)value + sizeof(ext4_acl_entry);
+                       if ((char *)value > end)
                                goto fail;
+                       acl->a_entries[n].e_id =
+                               le32_to_cpu(entry->e_id);
+                       break;
+
+               default:
+                       goto fail;
                }
        }
        if (value != end)
@@ -91,32 +92,31 @@ ext4_acl_to_disk(const struct posix_acl *acl, size_t *size)
 
        *size = ext4_acl_size(acl->a_count);
        ext_acl = kmalloc(sizeof(ext4_acl_header) + acl->a_count *
-                       sizeof(ext4_acl_entry), GFP_KERNEL);
+                       sizeof(ext4_acl_entry), GFP_NOFS);
        if (!ext_acl)
                return ERR_PTR(-ENOMEM);
        ext_acl->a_version = cpu_to_le32(EXT4_ACL_VERSION);
        e = (char *)ext_acl + sizeof(ext4_acl_header);
-       for (n=0; n < acl->a_count; n++) {
+       for (n = 0; n < acl->a_count; n++) {
                ext4_acl_entry *entry = (ext4_acl_entry *)e;
                entry->e_tag  = cpu_to_le16(acl->a_entries[n].e_tag);
                entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
-               switch(acl->a_entries[n].e_tag) {
-                       case ACL_USER:
-                       case ACL_GROUP:
-                               entry->e_id =
-                                       cpu_to_le32(acl->a_entries[n].e_id);
-                               e += sizeof(ext4_acl_entry);
-                               break;
-
-                       case ACL_USER_OBJ:
-                       case ACL_GROUP_OBJ:
-                       case ACL_MASK:
-                       case ACL_OTHER:
-                               e += sizeof(ext4_acl_entry_short);
-                               break;
-
-                       default:
-                               goto fail;
+               switch (acl->a_entries[n].e_tag) {
+               case ACL_USER:
+               case ACL_GROUP:
+                       entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
+                       e += sizeof(ext4_acl_entry);
+                       break;
+
+               case ACL_USER_OBJ:
+               case ACL_GROUP_OBJ:
+               case ACL_MASK:
+               case ACL_OTHER:
+                       e += sizeof(ext4_acl_entry_short);
+                       break;
+
+               default:
+                       goto fail;
                }
        }
        return (char *)ext_acl;
@@ -167,27 +167,27 @@ ext4_get_acl(struct inode *inode, int type)
        if (!test_opt(inode->i_sb, POSIX_ACL))
                return NULL;
 
-       switch(type) {
-               case ACL_TYPE_ACCESS:
-                       acl = ext4_iget_acl(inode, &ei->i_acl);
-                       if (acl != EXT4_ACL_NOT_CACHED)
-                               return acl;
-                       name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
-                       break;
-
-               case ACL_TYPE_DEFAULT:
-                       acl = ext4_iget_acl(inode, &ei->i_default_acl);
-                       if (acl != EXT4_ACL_NOT_CACHED)
-                               return acl;
-                       name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
-                       break;
-
-               default:
-                       return ERR_PTR(-EINVAL);
+       switch (type) {
+       case ACL_TYPE_ACCESS:
+               acl = ext4_iget_acl(inode, &ei->i_acl);
+               if (acl != EXT4_ACL_NOT_CACHED)
+                       return acl;
+               name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
+               break;
+
+       case ACL_TYPE_DEFAULT:
+               acl = ext4_iget_acl(inode, &ei->i_default_acl);
+               if (acl != EXT4_ACL_NOT_CACHED)
+                       return acl;
+               name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
+               break;
+
+       default:
+               return ERR_PTR(-EINVAL);
        }
        retval = ext4_xattr_get(inode, name_index, "", NULL, 0);
        if (retval > 0) {
-               value = kmalloc(retval, GFP_KERNEL);
+               value = kmalloc(retval, GFP_NOFS);
                if (!value)
                        return ERR_PTR(-ENOMEM);
                retval = ext4_xattr_get(inode, name_index, "", value, retval);
@@ -201,14 +201,14 @@ ext4_get_acl(struct inode *inode, int type)
        kfree(value);
 
        if (!IS_ERR(acl)) {
-               switch(type) {
-                       case ACL_TYPE_ACCESS:
-                               ext4_iset_acl(inode, &ei->i_acl, acl);
-                               break;
-
-                       case ACL_TYPE_DEFAULT:
-                               ext4_iset_acl(inode, &ei->i_default_acl, acl);
-                               break;
+               switch (type) {
+               case ACL_TYPE_ACCESS:
+                       ext4_iset_acl(inode, &ei->i_acl, acl);
+                       break;
+
+               case ACL_TYPE_DEFAULT:
+                       ext4_iset_acl(inode, &ei->i_default_acl, acl);
+                       break;
                }
        }
        return acl;
@@ -232,31 +232,31 @@ ext4_set_acl(handle_t *handle, struct inode *inode, int type,
        if (S_ISLNK(inode->i_mode))
                return -EOPNOTSUPP;
 
-       switch(type) {
-               case ACL_TYPE_ACCESS:
-                       name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
-                       if (acl) {
-                               mode_t mode = inode->i_mode;
-                               error = posix_acl_equiv_mode(acl, &mode);
-                               if (error < 0)
-                                       return error;
-                               else {
-                                       inode->i_mode = mode;
-                                       ext4_mark_inode_dirty(handle, inode);
-                                       if (error == 0)
-                                               acl = NULL;
-                               }
+       switch (type) {
+       case ACL_TYPE_ACCESS:
+               name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
+               if (acl) {
+                       mode_t mode = inode->i_mode;
+                       error = posix_acl_equiv_mode(acl, &mode);
+                       if (error < 0)
+                               return error;
+                       else {
+                               inode->i_mode = mode;
+                               ext4_mark_inode_dirty(handle, inode);
+                               if (error == 0)
+                                       acl = NULL;
                        }
-                       break;
+               }
+               break;
 
-               case ACL_TYPE_DEFAULT:
-                       name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
-                       if (!S_ISDIR(inode->i_mode))
-                               return acl ? -EACCES : 0;
-                       break;
+       case ACL_TYPE_DEFAULT:
+               name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
+               if (!S_ISDIR(inode->i_mode))
+                       return acl ? -EACCES : 0;
+               break;
 
-               default:
-                       return -EINVAL;
+       default:
+               return -EINVAL;
        }
        if (acl) {
                value = ext4_acl_to_disk(acl, &size);
@@ -269,14 +269,14 @@ ext4_set_acl(handle_t *handle, struct inode *inode, int type,
 
        kfree(value);
        if (!error) {
-               switch(type) {
-                       case ACL_TYPE_ACCESS:
-                               ext4_iset_acl(inode, &ei->i_acl, acl);
-                               break;
-
-                       case ACL_TYPE_DEFAULT:
-                               ext4_iset_acl(inode, &ei->i_default_acl, acl);
-                               break;
+               switch (type) {
+               case ACL_TYPE_ACCESS:
+                       ext4_iset_acl(inode, &ei->i_acl, acl);
+                       break;
+
+               case ACL_TYPE_DEFAULT:
+                       ext4_iset_acl(inode, &ei->i_default_acl, acl);
+                       break;
                }
        }
        return error;
@@ -299,7 +299,7 @@ ext4_check_acl(struct inode *inode, int mask)
 }
 
 int
-ext4_permission(struct inode *inode, int mask, struct nameidata *nd)
+ext4_permission(struct inode *inode, int mask)
 {
        return generic_permission(inode, mask, ext4_check_acl);
 }
@@ -335,7 +335,7 @@ ext4_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                        if (error)
                                goto cleanup;
                }
-               clone = posix_acl_clone(acl, GFP_KERNEL);
+               clone = posix_acl_clone(acl, GFP_NOFS);
                error = -ENOMEM;
                if (!clone)
                        goto cleanup;