From 617ba13b31fbf505cc21799826639ef24ed94af0 Mon Sep 17 00:00:00 2001 From: Mingming Cao Date: Wed, 11 Oct 2006 01:20:53 -0700 Subject: [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 Signed-off-by: Dave Kleikamp Signed-off-by: Andrew Morton Signed-off-by: Linus Torvalds --- fs/ext4/acl.c | 188 +++++++++++++++++++++++++++++----------------------------- 1 file changed, 94 insertions(+), 94 deletions(-) (limited to 'fs/ext4/acl.c') 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, */ @@ -9,8 +9,8 @@ #include #include #include -#include -#include +#include +#include #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, }; -- cgit v1.2.3-59-g8ed1b