[PATCH] ext4: rename ext4 symbols to avoid duplication of ext3 symbols

Mingming Cao originally did this work, and Shaggy reproduced it using some
scripts from her.

Signed-off-by: Mingming Cao <cmm@us.ibm.com>
Signed-off-by: Dave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 94 insertions, 94 deletions

diff --git a/fs/ext4/acl.c b/fs/ext4/acl.c
index 1e5038d9a01b..d143489aeb4c 100644
--- a/fs/ext4/acl.c
+++ b/fs/ext4/acl.c
@@ -1,5 +1,5 @@
 /*
- * linux/fs/ext3/acl.c
+ * linux/fs/ext4/acl.c
  *
  * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
  */
@@ -9,8 +9,8 @@
 #include <linux/slab.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/ext3_jbd.h>
-#include <linux/ext3_fs.h>
+#include <linux/ext4_jbd.h>
+#include <linux/ext4_fs.h>
 #include "xattr.h"
 #include "acl.h"
 
@@ -18,7 +18,7 @@
  * Convert from filesystem to in-memory representation.
  */
 static struct posix_acl *
-ext3_acl_from_disk(const void *value, size_t size)
+ext4_acl_from_disk(const void *value, size_t size)
 {
         const char *end = (char *)value + size;
         int n, count;
@@ -26,13 +26,13 @@ ext3_acl_from_disk(const void *value, size_t size)
 
         if (!value)
                 return NULL;
-        if (size < sizeof(ext3_acl_header))
+        if (size < sizeof(ext4_acl_header))
                  return ERR_PTR(-EINVAL);
-        if (((ext3_acl_header *)value)->a_version !=
-            cpu_to_le32(EXT3_ACL_VERSION))
+        if (((ext4_acl_header *)value)->a_version !=
+            cpu_to_le32(EXT4_ACL_VERSION))
                 return ERR_PTR(-EINVAL);
-        value = (char *)value + sizeof(ext3_acl_header);
-        count = ext3_acl_count(size);
+        value = (char *)value + sizeof(ext4_acl_header);
+        count = ext4_acl_count(size);
         if (count < 0)
                 return ERR_PTR(-EINVAL);
         if (count == 0)
@@ -41,9 +41,9 @@ ext3_acl_from_disk(const void *value, size_t size)
         if (!acl)
                 return ERR_PTR(-ENOMEM);
         for (n=0; n < count; n++) {
-                ext3_acl_entry *entry =
-                        (ext3_acl_entry *)value;
-                if ((char *)value + sizeof(ext3_acl_entry_short) > end)
+                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);
@@ -53,13 +53,13 @@ ext3_acl_from_disk(const void *value, size_t size)
                         case ACL_MASK:
                         case ACL_OTHER:
                                 value = (char *)value +
-                                        sizeof(ext3_acl_entry_short);
+                                        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(ext3_acl_entry);
+                                value = (char *)value + sizeof(ext4_acl_entry);
                                 if ((char *)value > end)
                                         goto fail;
                                 acl->a_entries[n].e_id =
@@ -83,21 +83,21 @@ fail:
  * Convert from in-memory to filesystem representation.
  */
 static void *
-ext3_acl_to_disk(const struct posix_acl *acl, size_t *size)
+ext4_acl_to_disk(const struct posix_acl *acl, size_t *size)
 {
-        ext3_acl_header *ext_acl;
+        ext4_acl_header *ext_acl;
         char *e;
         size_t n;
 
-        *size = ext3_acl_size(acl->a_count);
-        ext_acl = kmalloc(sizeof(ext3_acl_header) + acl->a_count *
-                        sizeof(ext3_acl_entry), GFP_KERNEL);
+        *size = ext4_acl_size(acl->a_count);
+        ext_acl = kmalloc(sizeof(ext4_acl_header) + acl->a_count *
+                        sizeof(ext4_acl_entry), GFP_KERNEL);
         if (!ext_acl)
                 return ERR_PTR(-ENOMEM);
-        ext_acl->a_version = cpu_to_le32(EXT3_ACL_VERSION);
-        e = (char *)ext_acl + sizeof(ext3_acl_header);
+        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++) {
-                ext3_acl_entry *entry = (ext3_acl_entry *)e;
+                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) {
@@ -105,14 +105,14 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size)
                         case ACL_GROUP:
                                 entry->e_id =
                                         cpu_to_le32(acl->a_entries[n].e_id);
-                                e += sizeof(ext3_acl_entry);
+                                e += sizeof(ext4_acl_entry);
                                 break;
 
                         case ACL_USER_OBJ:
                         case ACL_GROUP_OBJ:
                         case ACL_MASK:
                         case ACL_OTHER:
-                                e += sizeof(ext3_acl_entry_short);
+                                e += sizeof(ext4_acl_entry_short);
                                 break;
 
                         default:
@@ -127,12 +127,12 @@ fail:
 }
 
 static inline struct posix_acl *
-ext3_iget_acl(struct inode *inode, struct posix_acl **i_acl)
+ext4_iget_acl(struct inode *inode, struct posix_acl **i_acl)
 {
-        struct posix_acl *acl = EXT3_ACL_NOT_CACHED;
+        struct posix_acl *acl = EXT4_ACL_NOT_CACHED;
 
         spin_lock(&inode->i_lock);
-        if (*i_acl != EXT3_ACL_NOT_CACHED)
+        if (*i_acl != EXT4_ACL_NOT_CACHED)
                 acl = posix_acl_dup(*i_acl);
         spin_unlock(&inode->i_lock);
 
@@ -140,11 +140,11 @@ ext3_iget_acl(struct inode *inode, struct posix_acl **i_acl)
 }
 
 static inline void
-ext3_iset_acl(struct inode *inode, struct posix_acl **i_acl,
+ext4_iset_acl(struct inode *inode, struct posix_acl **i_acl,
                   struct posix_acl *acl)
 {
         spin_lock(&inode->i_lock);
-        if (*i_acl != EXT3_ACL_NOT_CACHED)
+        if (*i_acl != EXT4_ACL_NOT_CACHED)
                 posix_acl_release(*i_acl);
         *i_acl = posix_acl_dup(acl);
         spin_unlock(&inode->i_lock);
@@ -156,9 +156,9 @@ ext3_iset_acl(struct inode *inode, struct posix_acl **i_acl,
  * inode->i_mutex: don't care
  */
 static struct posix_acl *
-ext3_get_acl(struct inode *inode, int type)
+ext4_get_acl(struct inode *inode, int type)
 {
-        struct ext3_inode_info *ei = EXT3_I(inode);
+        struct ext4_inode_info *ei = EXT4_I(inode);
         int name_index;
         char *value = NULL;
         struct posix_acl *acl;
@@ -169,31 +169,31 @@ ext3_get_acl(struct inode *inode, int type)
 
         switch(type) {
                 case ACL_TYPE_ACCESS:
-                        acl = ext3_iget_acl(inode, &ei->i_acl);
-                        if (acl != EXT3_ACL_NOT_CACHED)
+                        acl = ext4_iget_acl(inode, &ei->i_acl);
+                        if (acl != EXT4_ACL_NOT_CACHED)
                                 return acl;
-                        name_index = EXT3_XATTR_INDEX_POSIX_ACL_ACCESS;
+                        name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
                         break;
 
                 case ACL_TYPE_DEFAULT:
-                        acl = ext3_iget_acl(inode, &ei->i_default_acl);
-                        if (acl != EXT3_ACL_NOT_CACHED)
+                        acl = ext4_iget_acl(inode, &ei->i_default_acl);
+                        if (acl != EXT4_ACL_NOT_CACHED)
                                 return acl;
-                        name_index = EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT;
+                        name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
                         break;
 
                 default:
                         return ERR_PTR(-EINVAL);
         }
-        retval = ext3_xattr_get(inode, name_index, "", NULL, 0);
+        retval = ext4_xattr_get(inode, name_index, "", NULL, 0);
         if (retval > 0) {
                 value = kmalloc(retval, GFP_KERNEL);
                 if (!value)
                         return ERR_PTR(-ENOMEM);
-                retval = ext3_xattr_get(inode, name_index, "", value, retval);
+                retval = ext4_xattr_get(inode, name_index, "", value, retval);
         }
         if (retval > 0)
-                acl = ext3_acl_from_disk(value, retval);
+                acl = ext4_acl_from_disk(value, retval);
         else if (retval == -ENODATA || retval == -ENOSYS)
                 acl = NULL;
         else
@@ -203,11 +203,11 @@ ext3_get_acl(struct inode *inode, int type)
         if (!IS_ERR(acl)) {
                 switch(type) {
                         case ACL_TYPE_ACCESS:
-                                ext3_iset_acl(inode, &ei->i_acl, acl);
+                                ext4_iset_acl(inode, &ei->i_acl, acl);
                                 break;
 
                         case ACL_TYPE_DEFAULT:
-                                ext3_iset_acl(inode, &ei->i_default_acl, acl);
+                                ext4_iset_acl(inode, &ei->i_default_acl, acl);
                                 break;
                 }
         }
@@ -217,13 +217,13 @@ ext3_get_acl(struct inode *inode, int type)
 /*
  * Set the access or default ACL of an inode.
  *
- * inode->i_mutex: down unless called from ext3_new_inode
+ * inode->i_mutex: down unless called from ext4_new_inode
  */
 static int
-ext3_set_acl(handle_t *handle, struct inode *inode, int type,
+ext4_set_acl(handle_t *handle, struct inode *inode, int type,
              struct posix_acl *acl)
 {
-        struct ext3_inode_info *ei = EXT3_I(inode);
+        struct ext4_inode_info *ei = EXT4_I(inode);
         int name_index;
         void *value = NULL;
         size_t size = 0;
@@ -234,7 +234,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
 
         switch(type) {
                 case ACL_TYPE_ACCESS:
-                        name_index = EXT3_XATTR_INDEX_POSIX_ACL_ACCESS;
+                        name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
                         if (acl) {
                                 mode_t mode = inode->i_mode;
                                 error = posix_acl_equiv_mode(acl, &mode);
@@ -242,7 +242,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
                                         return error;
                                 else {
                                         inode->i_mode = mode;
-                                        ext3_mark_inode_dirty(handle, inode);
+                                        ext4_mark_inode_dirty(handle, inode);
                                         if (error == 0)
                                                 acl = NULL;
                                 }
@@ -250,7 +250,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
                         break;
 
                 case ACL_TYPE_DEFAULT:
-                        name_index = EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT;
+                        name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
                         if (!S_ISDIR(inode->i_mode))
                                 return acl ? -EACCES : 0;
                         break;
@@ -259,23 +259,23 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
                         return -EINVAL;
         }
         if (acl) {
-                value = ext3_acl_to_disk(acl, &size);
+                value = ext4_acl_to_disk(acl, &size);
                 if (IS_ERR(value))
                         return (int)PTR_ERR(value);
         }
 
-        error = ext3_xattr_set_handle(handle, inode, name_index, "",
+        error = ext4_xattr_set_handle(handle, inode, name_index, "",
                                       value, size, 0);
 
         kfree(value);
         if (!error) {
                 switch(type) {
                         case ACL_TYPE_ACCESS:
-                                ext3_iset_acl(inode, &ei->i_acl, acl);
+                                ext4_iset_acl(inode, &ei->i_acl, acl);
                                 break;
 
                         case ACL_TYPE_DEFAULT:
-                                ext3_iset_acl(inode, &ei->i_default_acl, acl);
+                                ext4_iset_acl(inode, &ei->i_default_acl, acl);
                                 break;
                 }
         }
@@ -283,9 +283,9 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
 }
 
 static int
-ext3_check_acl(struct inode *inode, int mask)
+ext4_check_acl(struct inode *inode, int mask)
 {
-        struct posix_acl *acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
+        struct posix_acl *acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
 
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
@@ -299,26 +299,26 @@ ext3_check_acl(struct inode *inode, int mask)
 }
 
 int
-ext3_permission(struct inode *inode, int mask, struct nameidata *nd)
+ext4_permission(struct inode *inode, int mask, struct nameidata *nd)
 {
-        return generic_permission(inode, mask, ext3_check_acl);
+        return generic_permission(inode, mask, ext4_check_acl);
 }
 
 /*
- * Initialize the ACLs of a new inode. Called from ext3_new_inode.
+ * Initialize the ACLs of a new inode. Called from ext4_new_inode.
  *
  * dir->i_mutex: down
  * inode->i_mutex: up (access to inode is still exclusive)
  */
 int
-ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
+ext4_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
 {
         struct posix_acl *acl = NULL;
         int error = 0;
 
         if (!S_ISLNK(inode->i_mode)) {
                 if (test_opt(dir->i_sb, POSIX_ACL)) {
-                        acl = ext3_get_acl(dir, ACL_TYPE_DEFAULT);
+                        acl = ext4_get_acl(dir, ACL_TYPE_DEFAULT);
                         if (IS_ERR(acl))
                                 return PTR_ERR(acl);
                 }
@@ -330,7 +330,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                 mode_t mode;
 
                 if (S_ISDIR(inode->i_mode)) {
-                        error = ext3_set_acl(handle, inode,
+                        error = ext4_set_acl(handle, inode,
                                              ACL_TYPE_DEFAULT, acl);
                         if (error)
                                 goto cleanup;
@@ -346,7 +346,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                         inode->i_mode = mode;
                         if (error > 0) {
                                 /* This is an extended ACL */
-                                error = ext3_set_acl(handle, inode,
+                                error = ext4_set_acl(handle, inode,
                                                      ACL_TYPE_ACCESS, clone);
                         }
                 }
@@ -372,7 +372,7 @@ cleanup:
  * inode->i_mutex: down
  */
 int
-ext3_acl_chmod(struct inode *inode)
+ext4_acl_chmod(struct inode *inode)
 {
         struct posix_acl *acl, *clone;
         int error;
@@ -381,7 +381,7 @@ ext3_acl_chmod(struct inode *inode)
                 return -EOPNOTSUPP;
         if (!test_opt(inode->i_sb, POSIX_ACL))
                 return 0;
-        acl = ext3_get_acl(inode, ACL_TYPE_ACCESS);
+        acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
         if (IS_ERR(acl) || !acl)
                 return PTR_ERR(acl);
         clone = posix_acl_clone(acl, GFP_KERNEL);
@@ -394,17 +394,17 @@ ext3_acl_chmod(struct inode *inode)
                 int retries = 0;
 
         retry:
-                handle = ext3_journal_start(inode,
-                                EXT3_DATA_TRANS_BLOCKS(inode->i_sb));
+                handle = ext4_journal_start(inode,
+                                EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
                 if (IS_ERR(handle)) {
                         error = PTR_ERR(handle);
-                        ext3_std_error(inode->i_sb, error);
+                        ext4_std_error(inode->i_sb, error);
                         goto out;
                 }
-                error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
-                ext3_journal_stop(handle);
+                error = ext4_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
+                ext4_journal_stop(handle);
                 if (error == -ENOSPC &&
-                    ext3_should_retry_alloc(inode->i_sb, &retries))
+                    ext4_should_retry_alloc(inode->i_sb, &retries))
                         goto retry;
         }
 out:
@@ -416,7 +416,7 @@ out:
  * Extended attribute handlers
  */
 static size_t
-ext3_xattr_list_acl_access(struct inode *inode, char *list, size_t list_len,
+ext4_xattr_list_acl_access(struct inode *inode, char *list, size_t list_len,
                            const char *name, size_t name_len)
 {
         const size_t size = sizeof(POSIX_ACL_XATTR_ACCESS);
@@ -429,7 +429,7 @@ ext3_xattr_list_acl_access(struct inode *inode, char *list, size_t list_len,
 }
 
 static size_t
-ext3_xattr_list_acl_default(struct inode *inode, char *list, size_t list_len,
+ext4_xattr_list_acl_default(struct inode *inode, char *list, size_t list_len,
                             const char *name, size_t name_len)
 {
         const size_t size = sizeof(POSIX_ACL_XATTR_DEFAULT);
@@ -442,7 +442,7 @@ ext3_xattr_list_acl_default(struct inode *inode, char *list, size_t list_len,
 }
 
 static int
-ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
+ext4_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
 {
         struct posix_acl *acl;
         int error;
@@ -450,7 +450,7 @@ ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
         if (!test_opt(inode->i_sb, POSIX_ACL))
                 return -EOPNOTSUPP;
 
-        acl = ext3_get_acl(inode, type);
+        acl = ext4_get_acl(inode, type);
         if (IS_ERR(acl))
                 return PTR_ERR(acl);
         if (acl == NULL)
@@ -462,25 +462,25 @@ ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
 }
 
 static int
-ext3_xattr_get_acl_access(struct inode *inode, const char *name,
+ext4_xattr_get_acl_access(struct inode *inode, const char *name,
                           void *buffer, size_t size)
 {
         if (strcmp(name, "") != 0)
                 return -EINVAL;
-        return ext3_xattr_get_acl(inode, ACL_TYPE_ACCESS, buffer, size);
+        return ext4_xattr_get_acl(inode, ACL_TYPE_ACCESS, buffer, size);
 }
 
 static int
-ext3_xattr_get_acl_default(struct inode *inode, const char *name,
+ext4_xattr_get_acl_default(struct inode *inode, const char *name,
                            void *buffer, size_t size)
 {
         if (strcmp(name, "") != 0)
                 return -EINVAL;
-        return ext3_xattr_get_acl(inode, ACL_TYPE_DEFAULT, buffer, size);
+        return ext4_xattr_get_acl(inode, ACL_TYPE_DEFAULT, buffer, size);
 }
 
 static int
-ext3_xattr_set_acl(struct inode *inode, int type, const void *value,
+ext4_xattr_set_acl(struct inode *inode, int type, const void *value,
                    size_t size)
 {
         handle_t *handle;
@@ -505,12 +505,12 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value,
                 acl = NULL;
 
 retry:
-        handle = ext3_journal_start(inode, EXT3_DATA_TRANS_BLOCKS(inode->i_sb));
+        handle = ext4_journal_start(inode, EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
-        error = ext3_set_acl(handle, inode, type, acl);
-        ext3_journal_stop(handle);
-        if (error == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
+        error = ext4_set_acl(handle, inode, type, acl);
+        ext4_journal_stop(handle);
+        if (error == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
                 goto retry;
 
 release_and_out:
@@ -519,33 +519,33 @@ release_and_out:
 }
 
 static int
-ext3_xattr_set_acl_access(struct inode *inode, const char *name,
+ext4_xattr_set_acl_access(struct inode *inode, const char *name,
                           const void *value, size_t size, int flags)
 {
         if (strcmp(name, "") != 0)
                 return -EINVAL;
-        return ext3_xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size);
+        return ext4_xattr_set_acl(inode, ACL_TYPE_ACCESS, value, size);
 }
 
 static int
-ext3_xattr_set_acl_default(struct inode *inode, const char *name,
+ext4_xattr_set_acl_default(struct inode *inode, const char *name,
                            const void *value, size_t size, int flags)
 {
         if (strcmp(name, "") != 0)
                 return -EINVAL;
-        return ext3_xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
+        return ext4_xattr_set_acl(inode, ACL_TYPE_DEFAULT, value, size);
 }
 
-struct xattr_handler ext3_xattr_acl_access_handler = {
+struct xattr_handler ext4_xattr_acl_access_handler = {
         .prefix = POSIX_ACL_XATTR_ACCESS,
-        .list   = ext3_xattr_list_acl_access,
-        .get    = ext3_xattr_get_acl_access,
-        .set    = ext3_xattr_set_acl_access,
+        .list   = ext4_xattr_list_acl_access,
+        .get    = ext4_xattr_get_acl_access,
+        .set    = ext4_xattr_set_acl_access,
 };
 
-struct xattr_handler ext3_xattr_acl_default_handler = {
+struct xattr_handler ext4_xattr_acl_default_handler = {
         .prefix = POSIX_ACL_XATTR_DEFAULT,
-        .list   = ext3_xattr_list_acl_default,
-        .get    = ext3_xattr_get_acl_default,
-        .set    = ext3_xattr_set_acl_default,
+        .list   = ext4_xattr_list_acl_default,
+        .get    = ext4_xattr_get_acl_default,
+        .set    = ext4_xattr_set_acl_default,
 };