Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 617ba13b authored by Mingming Cao's avatar Mingming Cao Committed by Linus Torvalds
Browse files

[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: default avatarMingming Cao <cmm@us.ibm.com>
Signed-off-by: default avatarDave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent ac27a0ec

fs/ext4/Makefile

+6 −6
Original line number Diff line number Diff line 
#

# Makefile for the linux ext3-filesystem routines.

# Makefile for the linux ext4-filesystem routines.

#



obj-$(CONFIG_EXT3_FS) += ext3.o

obj-$(CONFIG_EXT4DEV_FS) += ext4dev.o



ext3-y	:= balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \

ext4dev-y	:= balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \

	   ioctl.o namei.o super.o symlink.o hash.o resize.o



ext3-$(CONFIG_EXT3_FS_XATTR)	 += xattr.o xattr_user.o xattr_trusted.o

ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o

ext3-$(CONFIG_EXT3_FS_SECURITY)	 += xattr_security.o
 
ext4dev-$(CONFIG_EXT4DEV_FS_XATTR)	+= xattr.o xattr_user.o xattr_trusted.o

ext4dev-$(CONFIG_EXT4DEV_FS_POSIX_ACL)	+= acl.o

ext4dev-$(CONFIG_EXT4DEV_FS_SECURITY)	+= xattr_security.o

fs/ext4/acl.c

+94 −94
Original line number Diff line number Diff line 
/*

 * 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 @@ ext3_acl_from_disk(const void *value, size_t size) 
 * 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 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size) 
}



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 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir) 
 * 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 @@ ext3_acl_chmod(struct inode *inode) 
 * 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 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value, 
}



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,

};

fs/ext4/acl.h

+29 −29
Original line number Diff line number Diff line 
/*

  File: fs/ext3/acl.h

  File: fs/ext4/acl.h



  (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>

*/



#include <linux/posix_acl_xattr.h>



#define EXT3_ACL_VERSION	0x0001

#define EXT4_ACL_VERSION	0x0001



typedef struct {

	__le16		e_tag;

	__le16		e_perm;

	__le32		e_id;

} ext3_acl_entry;

} ext4_acl_entry;



typedef struct {

	__le16		e_tag;

	__le16		e_perm;

} ext3_acl_entry_short;

} ext4_acl_entry_short;



typedef struct {

	__le32		a_version;

} ext3_acl_header;

} ext4_acl_header;



static inline size_t ext3_acl_size(int count)

static inline size_t ext4_acl_size(int count)

{

	if (count <= 4) {

		return sizeof(ext3_acl_header) +

		       count * sizeof(ext3_acl_entry_short);

		return sizeof(ext4_acl_header) +

		       count * sizeof(ext4_acl_entry_short);

	} else {

		return sizeof(ext3_acl_header) +

		       4 * sizeof(ext3_acl_entry_short) +

		       (count - 4) * sizeof(ext3_acl_entry);

		return sizeof(ext4_acl_header) +

		       4 * sizeof(ext4_acl_entry_short) +

		       (count - 4) * sizeof(ext4_acl_entry);

	}

}



static inline int ext3_acl_count(size_t size)

static inline int ext4_acl_count(size_t size)

{

	ssize_t s;

	size -= sizeof(ext3_acl_header);

	s = size - 4 * sizeof(ext3_acl_entry_short);

	size -= sizeof(ext4_acl_header);

	s = size - 4 * sizeof(ext4_acl_entry_short);

	if (s < 0) {

		if (size % sizeof(ext3_acl_entry_short))

		if (size % sizeof(ext4_acl_entry_short))

			return -1;

		return size / sizeof(ext3_acl_entry_short);

		return size / sizeof(ext4_acl_entry_short);

	} else {

		if (s % sizeof(ext3_acl_entry))

		if (s % sizeof(ext4_acl_entry))

			return -1;

		return s / sizeof(ext3_acl_entry) + 4;

		return s / sizeof(ext4_acl_entry) + 4;

	}

}



#ifdef CONFIG_EXT3_FS_POSIX_ACL

#ifdef CONFIG_EXT4DEV_FS_POSIX_ACL



/* Value for inode->u.ext3_i.i_acl and inode->u.ext3_i.i_default_acl

/* Value for inode->u.ext4_i.i_acl and inode->u.ext4_i.i_default_acl

   if the ACL has not been cached */

#define EXT3_ACL_NOT_CACHED ((void *)-1)

#define EXT4_ACL_NOT_CACHED ((void *)-1)



/* acl.c */

extern int ext3_permission (struct inode *, int, struct nameidata *);

extern int ext3_acl_chmod (struct inode *);

extern int ext3_init_acl (handle_t *, struct inode *, struct inode *);

extern int ext4_permission (struct inode *, int, struct nameidata *);

extern int ext4_acl_chmod (struct inode *);

extern int ext4_init_acl (handle_t *, struct inode *, struct inode *);



#else  /* CONFIG_EXT3_FS_POSIX_ACL */

#else  /* CONFIG_EXT4DEV_FS_POSIX_ACL */

#include <linux/sched.h>

#define ext3_permission NULL

#define ext4_permission NULL



static inline int

ext3_acl_chmod(struct inode *inode)

ext4_acl_chmod(struct inode *inode)

{

	return 0;

}



static inline 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)

{

	return 0;

}

#endif  /* CONFIG_EXT3_FS_POSIX_ACL */

#endif  /* CONFIG_EXT4DEV_FS_POSIX_ACL */

fs/ext4/balloc.c

+268 −268

File changed.

Preview size limit exceeded, changes collapsed.

fs/ext4/bitmap.c

+5 −5
Original line number Diff line number Diff line 
/*

 *  linux/fs/ext3/bitmap.c

 *  linux/fs/ext4/bitmap.c

 *

 * Copyright (C) 1992, 1993, 1994, 1995

 * Remy Card (card@masi.ibp.fr)
@@ -9,13 +9,13 @@ 


#include <linux/buffer_head.h>

#include <linux/jbd.h>

#include <linux/ext3_fs.h>

#include <linux/ext4_fs.h>



#ifdef EXT3FS_DEBUG

#ifdef EXT4FS_DEBUG



static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};



unsigned long ext3_count_free (struct buffer_head * map, unsigned int numchars)

unsigned long ext4_count_free (struct buffer_head * map, unsigned int numchars)

{

	unsigned int i;

	unsigned long sum = 0;
@@ -28,5 +28,5 @@ unsigned long ext3_count_free (struct buffer_head * map, unsigned int numchars) 
	return (sum);

}



#endif  /*  EXT3FS_DEBUG  */

#endif  /*  EXT4FS_DEBUG  */