Skip to content

cloud-kernel
cloud-kernel

openanolis / cloud-kernel
大约 2 年 前同步成功

通知 173
Star 36
Fork 7
cloud-kernel
cloud-kernel
提交 617ba13b 编写于 作者: M Mingming Cao 提交者： Linus Torvalds
浏览文件
操作

[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: NMingming Cao <cmm@us.ibm.com>
Signed-off-by: NDave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: NAndrew Morton <akpm@osdl.org>
Signed-off-by: NLinus Torvalds <torvalds@osdl.org>
上级 ac27a0ec
展开全部 隐藏空白更改
内联 并排
Showing with 3227 addition and 3227 deletion
fs/ext4/Makefile
浏览文件 @ 617ba13b
# #
# 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 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 ext4dev-$(CONFIG_EXT4DEV_FS_XATTR) += xattr.o xattr_user.o xattr_trusted.o
ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o ext4dev-$(CONFIG_EXT4DEV_FS_POSIX_ACL) += acl.o
ext3-$(CONFIG_EXT3_FS_SECURITY) += xattr_security.o ext4dev-$(CONFIG_EXT4DEV_FS_SECURITY) += xattr_security.o
fs/ext4/acl.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/acl.c * linux/fs/ext4/acl.c
* *
* Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de> * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
*/ */
...@@ -9,8 +9,8 @@ ...@@ -9,8 +9,8 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
...@@ -18,7 +18,7 @@ ...@@ -18,7 +18,7 @@
* Convert from filesystem to in-memory representation. * Convert from filesystem to in-memory representation.
*/ */
static struct posix_acl * 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; const char *end = (char *)value + size;
int n, count; int n, count;
...@@ -26,13 +26,13 @@ ext3_acl_from_disk(const void *value, size_t size) ...@@ -26,13 +26,13 @@ ext3_acl_from_disk(const void *value, size_t size)
if (!value) if (!value)
return NULL; return NULL;
if (size < sizeof(ext3_acl_header)) if (size < sizeof(ext4_acl_header))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
if (((ext3_acl_header *)value)->a_version != if (((ext4_acl_header *)value)->a_version !=
cpu_to_le32(EXT3_ACL_VERSION)) cpu_to_le32(EXT4_ACL_VERSION))
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
value = (char *)value + sizeof(ext3_acl_header); value = (char *)value + sizeof(ext4_acl_header);
count = ext3_acl_count(size); count = ext4_acl_count(size);
if (count < 0) if (count < 0)
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
if (count == 0) if (count == 0)
...@@ -41,9 +41,9 @@ ext3_acl_from_disk(const void *value, size_t size) ...@@ -41,9 +41,9 @@ ext3_acl_from_disk(const void *value, size_t size)
if (!acl) if (!acl)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
for (n=0; n < count; n++) { for (n=0; n < count; n++) {
ext3_acl_entry *entry = ext4_acl_entry *entry =
(ext3_acl_entry *)value; (ext4_acl_entry *)value;
if ((char *)value + sizeof(ext3_acl_entry_short) > end) if ((char *)value + sizeof(ext4_acl_entry_short) > end)
goto fail; goto fail;
acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag); acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm); 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) ...@@ -53,13 +53,13 @@ ext3_acl_from_disk(const void *value, size_t size)
case ACL_MASK: case ACL_MASK:
case ACL_OTHER: case ACL_OTHER:
value = (char *)value + value = (char *)value +
sizeof(ext3_acl_entry_short); sizeof(ext4_acl_entry_short);
acl->a_entries[n].e_id = ACL_UNDEFINED_ID; acl->a_entries[n].e_id = ACL_UNDEFINED_ID;
break; break;
case ACL_USER: case ACL_USER:
case ACL_GROUP: case ACL_GROUP:
value = (char *)value + sizeof(ext3_acl_entry); value = (char *)value + sizeof(ext4_acl_entry);
if ((char *)value > end) if ((char *)value > end)
goto fail; goto fail;
acl->a_entries[n].e_id = acl->a_entries[n].e_id =
...@@ -83,21 +83,21 @@ ext3_acl_from_disk(const void *value, size_t size) ...@@ -83,21 +83,21 @@ ext3_acl_from_disk(const void *value, size_t size)
* Convert from in-memory to filesystem representation. * Convert from in-memory to filesystem representation.
*/ */
static void * 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; char *e;
size_t n; size_t n;
*size = ext3_acl_size(acl->a_count); *size = ext4_acl_size(acl->a_count);
ext_acl = kmalloc(sizeof(ext3_acl_header) + acl->a_count * ext_acl = kmalloc(sizeof(ext4_acl_header) + acl->a_count *
sizeof(ext3_acl_entry), GFP_KERNEL); sizeof(ext4_acl_entry), GFP_KERNEL);
if (!ext_acl) if (!ext_acl)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
ext_acl->a_version = cpu_to_le32(EXT3_ACL_VERSION); ext_acl->a_version = cpu_to_le32(EXT4_ACL_VERSION);
e = (char *)ext_acl + sizeof(ext3_acl_header); e = (char *)ext_acl + sizeof(ext4_acl_header);
for (n=0; n < acl->a_count; n++) { 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_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm); entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
switch(acl->a_entries[n].e_tag) { switch(acl->a_entries[n].e_tag) {
...@@ -105,14 +105,14 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size) ...@@ -105,14 +105,14 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size)
case ACL_GROUP: case ACL_GROUP:
entry->e_id = entry->e_id =
cpu_to_le32(acl->a_entries[n].e_id); cpu_to_le32(acl->a_entries[n].e_id);
e += sizeof(ext3_acl_entry); e += sizeof(ext4_acl_entry);
break; break;
case ACL_USER_OBJ: case ACL_USER_OBJ:
case ACL_GROUP_OBJ: case ACL_GROUP_OBJ:
case ACL_MASK: case ACL_MASK:
case ACL_OTHER: case ACL_OTHER:
e += sizeof(ext3_acl_entry_short); e += sizeof(ext4_acl_entry_short);
break; break;
default: default:
...@@ -127,12 +127,12 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size) ...@@ -127,12 +127,12 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size)
} }
static inline struct posix_acl * 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); 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); acl = posix_acl_dup(*i_acl);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
...@@ -140,11 +140,11 @@ ext3_iget_acl(struct inode *inode, struct posix_acl **i_acl) ...@@ -140,11 +140,11 @@ ext3_iget_acl(struct inode *inode, struct posix_acl **i_acl)
} }
static inline void 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) struct posix_acl *acl)
{ {
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (*i_acl != EXT3_ACL_NOT_CACHED) if (*i_acl != EXT4_ACL_NOT_CACHED)
posix_acl_release(*i_acl); posix_acl_release(*i_acl);
*i_acl = posix_acl_dup(acl); *i_acl = posix_acl_dup(acl);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
...@@ -156,9 +156,9 @@ ext3_iset_acl(struct inode *inode, struct posix_acl **i_acl, ...@@ -156,9 +156,9 @@ ext3_iset_acl(struct inode *inode, struct posix_acl **i_acl,
* inode->i_mutex: don't care * inode->i_mutex: don't care
*/ */
static struct posix_acl * 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; int name_index;
char *value = NULL; char *value = NULL;
struct posix_acl *acl; struct posix_acl *acl;
...@@ -169,31 +169,31 @@ ext3_get_acl(struct inode *inode, int type) ...@@ -169,31 +169,31 @@ ext3_get_acl(struct inode *inode, int type)
switch(type) { switch(type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
acl = ext3_iget_acl(inode, &ei->i_acl); acl = ext4_iget_acl(inode, &ei->i_acl);
if (acl != EXT3_ACL_NOT_CACHED) if (acl != EXT4_ACL_NOT_CACHED)
return acl; return acl;
name_index = EXT3_XATTR_INDEX_POSIX_ACL_ACCESS; name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
break; break;
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
acl = ext3_iget_acl(inode, &ei->i_default_acl); acl = ext4_iget_acl(inode, &ei->i_default_acl);
if (acl != EXT3_ACL_NOT_CACHED) if (acl != EXT4_ACL_NOT_CACHED)
return acl; return acl;
name_index = EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT; name_index = EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT;
break; break;
default: default:
return ERR_PTR(-EINVAL); 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) { if (retval > 0) {
value = kmalloc(retval, GFP_KERNEL); value = kmalloc(retval, GFP_KERNEL);
if (!value) if (!value)
return ERR_PTR(-ENOMEM); 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) if (retval > 0)
acl = ext3_acl_from_disk(value, retval); acl = ext4_acl_from_disk(value, retval);
else if (retval == -ENODATA || retval == -ENOSYS) else if (retval == -ENODATA || retval == -ENOSYS)
acl = NULL; acl = NULL;
else else
...@@ -203,11 +203,11 @@ ext3_get_acl(struct inode *inode, int type) ...@@ -203,11 +203,11 @@ ext3_get_acl(struct inode *inode, int type)
if (!IS_ERR(acl)) { if (!IS_ERR(acl)) {
switch(type) { switch(type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
ext3_iset_acl(inode, &ei->i_acl, acl); ext4_iset_acl(inode, &ei->i_acl, acl);
break; break;
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
ext3_iset_acl(inode, &ei->i_default_acl, acl); ext4_iset_acl(inode, &ei->i_default_acl, acl);
break; break;
} }
} }
...@@ -217,13 +217,13 @@ ext3_get_acl(struct inode *inode, int type) ...@@ -217,13 +217,13 @@ ext3_get_acl(struct inode *inode, int type)
/* /*
* Set the access or default ACL of an inode. * 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 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 posix_acl *acl)
{ {
struct ext3_inode_info *ei = EXT3_I(inode); struct ext4_inode_info *ei = EXT4_I(inode);
int name_index; int name_index;
void *value = NULL; void *value = NULL;
size_t size = 0; size_t size = 0;
...@@ -234,7 +234,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type, ...@@ -234,7 +234,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
switch(type) { switch(type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
name_index = EXT3_XATTR_INDEX_POSIX_ACL_ACCESS; name_index = EXT4_XATTR_INDEX_POSIX_ACL_ACCESS;
if (acl) { if (acl) {
mode_t mode = inode->i_mode; mode_t mode = inode->i_mode;
error = posix_acl_equiv_mode(acl, &mode); error = posix_acl_equiv_mode(acl, &mode);
...@@ -242,7 +242,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type, ...@@ -242,7 +242,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
return error; return error;
else { else {
inode->i_mode = mode; inode->i_mode = mode;
ext3_mark_inode_dirty(handle, inode); ext4_mark_inode_dirty(handle, inode);
if (error == 0) if (error == 0)
acl = NULL; acl = NULL;
} }
...@@ -250,7 +250,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type, ...@@ -250,7 +250,7 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
break; break;
case ACL_TYPE_DEFAULT: 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)) if (!S_ISDIR(inode->i_mode))
return acl ? -EACCES : 0; return acl ? -EACCES : 0;
break; break;
...@@ -259,23 +259,23 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type, ...@@ -259,23 +259,23 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
return -EINVAL; return -EINVAL;
} }
if (acl) { if (acl) {
value = ext3_acl_to_disk(acl, &size); value = ext4_acl_to_disk(acl, &size);
if (IS_ERR(value)) if (IS_ERR(value))
return (int)PTR_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); value, size, 0);
kfree(value); kfree(value);
if (!error) { if (!error) {
switch(type) { switch(type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
ext3_iset_acl(inode, &ei->i_acl, acl); ext4_iset_acl(inode, &ei->i_acl, acl);
break; break;
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
ext3_iset_acl(inode, &ei->i_default_acl, acl); ext4_iset_acl(inode, &ei->i_default_acl, acl);
break; break;
} }
} }
...@@ -283,9 +283,9 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type, ...@@ -283,9 +283,9 @@ ext3_set_acl(handle_t *handle, struct inode *inode, int type,
} }
static int 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)) if (IS_ERR(acl))
return PTR_ERR(acl); return PTR_ERR(acl);
...@@ -299,26 +299,26 @@ ext3_check_acl(struct inode *inode, int mask) ...@@ -299,26 +299,26 @@ ext3_check_acl(struct inode *inode, int mask)
} }
int 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 * dir->i_mutex: down
* inode->i_mutex: up (access to inode is still exclusive) * inode->i_mutex: up (access to inode is still exclusive)
*/ */
int 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; struct posix_acl *acl = NULL;
int error = 0; int error = 0;
if (!S_ISLNK(inode->i_mode)) { if (!S_ISLNK(inode->i_mode)) {
if (test_opt(dir->i_sb, POSIX_ACL)) { 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)) if (IS_ERR(acl))
return PTR_ERR(acl); return PTR_ERR(acl);
} }
...@@ -330,7 +330,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir) ...@@ -330,7 +330,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
mode_t mode; mode_t mode;
if (S_ISDIR(inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
error = ext3_set_acl(handle, inode, error = ext4_set_acl(handle, inode,
ACL_TYPE_DEFAULT, acl); ACL_TYPE_DEFAULT, acl);
if (error) if (error)
goto cleanup; goto cleanup;
...@@ -346,7 +346,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir) ...@@ -346,7 +346,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
inode->i_mode = mode; inode->i_mode = mode;
if (error > 0) { if (error > 0) {
/* This is an extended ACL */ /* This is an extended ACL */
error = ext3_set_acl(handle, inode, error = ext4_set_acl(handle, inode,
ACL_TYPE_ACCESS, clone); ACL_TYPE_ACCESS, clone);
} }
} }
...@@ -372,7 +372,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir) ...@@ -372,7 +372,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
* inode->i_mutex: down * inode->i_mutex: down
*/ */
int int
ext3_acl_chmod(struct inode *inode) ext4_acl_chmod(struct inode *inode)
{ {
struct posix_acl *acl, *clone; struct posix_acl *acl, *clone;
int error; int error;
...@@ -381,7 +381,7 @@ ext3_acl_chmod(struct inode *inode) ...@@ -381,7 +381,7 @@ ext3_acl_chmod(struct inode *inode)
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (!test_opt(inode->i_sb, POSIX_ACL)) if (!test_opt(inode->i_sb, POSIX_ACL))
return 0; return 0;
acl = ext3_get_acl(inode, ACL_TYPE_ACCESS); acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
if (IS_ERR(acl) || !acl) if (IS_ERR(acl) || !acl)
return PTR_ERR(acl); return PTR_ERR(acl);
clone = posix_acl_clone(acl, GFP_KERNEL); clone = posix_acl_clone(acl, GFP_KERNEL);
...@@ -394,17 +394,17 @@ ext3_acl_chmod(struct inode *inode) ...@@ -394,17 +394,17 @@ ext3_acl_chmod(struct inode *inode)
int retries = 0; int retries = 0;
retry: retry:
handle = ext3_journal_start(inode, handle = ext4_journal_start(inode,
EXT3_DATA_TRANS_BLOCKS(inode->i_sb)); EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
if (IS_ERR(handle)) { if (IS_ERR(handle)) {
error = PTR_ERR(handle); error = PTR_ERR(handle);
ext3_std_error(inode->i_sb, error); ext4_std_error(inode->i_sb, error);
goto out; goto out;
} }
error = ext3_set_acl(handle, inode, ACL_TYPE_ACCESS, clone); error = ext4_set_acl(handle, inode, ACL_TYPE_ACCESS, clone);
ext3_journal_stop(handle); ext4_journal_stop(handle);
if (error == -ENOSPC && if (error == -ENOSPC &&
ext3_should_retry_alloc(inode->i_sb, &retries)) ext4_should_retry_alloc(inode->i_sb, &retries))
goto retry; goto retry;
} }
out: out:
...@@ -416,7 +416,7 @@ ext3_acl_chmod(struct inode *inode) ...@@ -416,7 +416,7 @@ ext3_acl_chmod(struct inode *inode)
* Extended attribute handlers * Extended attribute handlers
*/ */
static size_t 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 char *name, size_t name_len)
{ {
const size_t size = sizeof(POSIX_ACL_XATTR_ACCESS); 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, ...@@ -429,7 +429,7 @@ ext3_xattr_list_acl_access(struct inode *inode, char *list, size_t list_len,
} }
static size_t 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 char *name, size_t name_len)
{ {
const size_t size = sizeof(POSIX_ACL_XATTR_DEFAULT); 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, ...@@ -442,7 +442,7 @@ ext3_xattr_list_acl_default(struct inode *inode, char *list, size_t list_len,
} }
static int 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; struct posix_acl *acl;
int error; int error;
...@@ -450,7 +450,7 @@ ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size) ...@@ -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)) if (!test_opt(inode->i_sb, POSIX_ACL))
return -EOPNOTSUPP; return -EOPNOTSUPP;
acl = ext3_get_acl(inode, type); acl = ext4_get_acl(inode, type);
if (IS_ERR(acl)) if (IS_ERR(acl))
return PTR_ERR(acl); return PTR_ERR(acl);
if (acl == NULL) if (acl == NULL)
...@@ -462,25 +462,25 @@ ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size) ...@@ -462,25 +462,25 @@ ext3_xattr_get_acl(struct inode *inode, int type, void *buffer, size_t size)
} }
static int 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) void *buffer, size_t size)
{ {
if (strcmp(name, "") != 0) if (strcmp(name, "") != 0)
return -EINVAL; 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 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) void *buffer, size_t size)
{ {
if (strcmp(name, "") != 0) if (strcmp(name, "") != 0)
return -EINVAL; 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 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) size_t size)
{ {
handle_t *handle; handle_t *handle;
...@@ -505,12 +505,12 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value, ...@@ -505,12 +505,12 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value,
acl = NULL; acl = NULL;
retry: 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)) if (IS_ERR(handle))
return PTR_ERR(handle); return PTR_ERR(handle);
error = ext3_set_acl(handle, inode, type, acl); error = ext4_set_acl(handle, inode, type, acl);
ext3_journal_stop(handle); ext4_journal_stop(handle);
if (error == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries)) if (error == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
goto retry; goto retry;
release_and_out: release_and_out:
...@@ -519,33 +519,33 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value, ...@@ -519,33 +519,33 @@ ext3_xattr_set_acl(struct inode *inode, int type, const void *value,
} }
static int 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) const void *value, size_t size, int flags)
{ {
if (strcmp(name, "") != 0) if (strcmp(name, "") != 0)
return -EINVAL; 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 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) const void *value, size_t size, int flags)
{ {
if (strcmp(name, "") != 0) if (strcmp(name, "") != 0)
return -EINVAL; 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, .prefix = POSIX_ACL_XATTR_ACCESS,
.list = ext3_xattr_list_acl_access, .list = ext4_xattr_list_acl_access,
.get = ext3_xattr_get_acl_access, .get = ext4_xattr_get_acl_access,
.set = ext3_xattr_set_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, .prefix = POSIX_ACL_XATTR_DEFAULT,
.list = ext3_xattr_list_acl_default, .list = ext4_xattr_list_acl_default,
.get = ext3_xattr_get_acl_default, .get = ext4_xattr_get_acl_default,
.set = ext3_xattr_set_acl_default, .set = ext4_xattr_set_acl_default,
}; };
fs/ext4/acl.h
浏览文件 @ 617ba13b
/* /*
File: fs/ext3/acl.h File: fs/ext4/acl.h
(C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org> (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
*/ */
#include <linux/posix_acl_xattr.h> #include <linux/posix_acl_xattr.h>
#define EXT3_ACL_VERSION 0x0001 #define EXT4_ACL_VERSION 0x0001
typedef struct { typedef struct {
__le16 e_tag; __le16 e_tag;
__le16 e_perm; __le16 e_perm;
__le32 e_id; __le32 e_id;
} ext3_acl_entry; } ext4_acl_entry;
typedef struct { typedef struct {
__le16 e_tag; __le16 e_tag;
__le16 e_perm; __le16 e_perm;
} ext3_acl_entry_short; } ext4_acl_entry_short;
typedef struct { typedef struct {
__le32 a_version; __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) { if (count <= 4) {
return sizeof(ext3_acl_header) + return sizeof(ext4_acl_header) +
count * sizeof(ext3_acl_entry_short); count * sizeof(ext4_acl_entry_short);
} else { } else {
return sizeof(ext3_acl_header) + return sizeof(ext4_acl_header) +
4 * sizeof(ext3_acl_entry_short) + 4 * sizeof(ext4_acl_entry_short) +
(count - 4) * sizeof(ext3_acl_entry); (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; ssize_t s;
size -= sizeof(ext3_acl_header); size -= sizeof(ext4_acl_header);
s = size - 4 * sizeof(ext3_acl_entry_short); s = size - 4 * sizeof(ext4_acl_entry_short);
if (s < 0) { if (s < 0) {
if (size % sizeof(ext3_acl_entry_short)) if (size % sizeof(ext4_acl_entry_short))
return -1; return -1;
return size / sizeof(ext3_acl_entry_short); return size / sizeof(ext4_acl_entry_short);
} else { } else {
if (s % sizeof(ext3_acl_entry)) if (s % sizeof(ext4_acl_entry))
return -1; 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 */ if the ACL has not been cached */
#define EXT3_ACL_NOT_CACHED ((void *)-1) #define EXT4_ACL_NOT_CACHED ((void *)-1)
/* acl.c */ /* acl.c */
extern int ext3_permission (struct inode *, int, struct nameidata *); extern int ext4_permission (struct inode *, int, struct nameidata *);
extern int ext3_acl_chmod (struct inode *); extern int ext4_acl_chmod (struct inode *);
extern int ext3_init_acl (handle_t *, struct inode *, 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> #include <linux/sched.h>
#define ext3_permission NULL #define ext4_permission NULL
static inline int static inline int
ext3_acl_chmod(struct inode *inode) ext4_acl_chmod(struct inode *inode)
{ {
return 0; return 0;
} }
static inline int 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; return 0;
} }
#endif /* CONFIG_EXT3_FS_POSIX_ACL */ #endif /* CONFIG_EXT4DEV_FS_POSIX_ACL */
fs/ext4/balloc.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/bitmap.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/bitmap.c * linux/fs/ext4/bitmap.c
* *
* Copyright (C) 1992, 1993, 1994, 1995 * Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr) * Remy Card (card@masi.ibp.fr)
...@@ -9,13 +9,13 @@ ...@@ -9,13 +9,13 @@
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/jbd.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}; 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 int i;
unsigned long sum = 0; unsigned long sum = 0;
...@@ -28,5 +28,5 @@ unsigned long ext3_count_free (struct buffer_head * map, unsigned int numchars) ...@@ -28,5 +28,5 @@ unsigned long ext3_count_free (struct buffer_head * map, unsigned int numchars)
return (sum); return (sum);
} }
#endif /* EXT3FS_DEBUG */ #endif /* EXT4FS_DEBUG */
fs/ext4/dir.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/dir.c * linux/fs/ext4/dir.c
* *
* Copyright (C) 1992, 1993, 1994, 1995 * Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr) * Remy Card (card@masi.ibp.fr)
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
* *
* Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
* *
* ext3 directory handling functions * ext4 directory handling functions
* *
* Big-endian to little-endian byte-swapping/bitmaps by * Big-endian to little-endian byte-swapping/bitmaps by
* David S. Miller (davem@caip.rutgers.edu), 1995 * David S. Miller (davem@caip.rutgers.edu), 1995
...@@ -23,69 +23,69 @@ ...@@ -23,69 +23,69 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/rbtree.h> #include <linux/rbtree.h>
static unsigned char ext3_filetype_table[] = { static unsigned char ext4_filetype_table[] = {
DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
}; };
static int ext3_readdir(struct file *, void *, filldir_t); static int ext4_readdir(struct file *, void *, filldir_t);
static int ext3_dx_readdir(struct file * filp, static int ext4_dx_readdir(struct file * filp,
void * dirent, filldir_t filldir); void * dirent, filldir_t filldir);
static int ext3_release_dir (struct inode * inode, static int ext4_release_dir (struct inode * inode,
struct file * filp); struct file * filp);
const struct file_operations ext3_dir_operations = { const struct file_operations ext4_dir_operations = {
.llseek = generic_file_llseek, .llseek = generic_file_llseek,
.read = generic_read_dir, .read = generic_read_dir,
.readdir = ext3_readdir, /* we take BKL. needed?*/ .readdir = ext4_readdir, /* we take BKL. needed?*/
.ioctl = ext3_ioctl, /* BKL held */ .ioctl = ext4_ioctl, /* BKL held */
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
.compat_ioctl = ext3_compat_ioctl, .compat_ioctl = ext4_compat_ioctl,
#endif #endif
.fsync = ext3_sync_file, /* BKL held */ .fsync = ext4_sync_file, /* BKL held */
#ifdef CONFIG_EXT3_INDEX #ifdef CONFIG_EXT4_INDEX
.release = ext3_release_dir, .release = ext4_release_dir,
#endif #endif
}; };
static unsigned char get_dtype(struct super_block *sb, int filetype) static unsigned char get_dtype(struct super_block *sb, int filetype)
{ {
if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_FILETYPE) || if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FILETYPE) ||
(filetype >= EXT3_FT_MAX)) (filetype >= EXT4_FT_MAX))
return DT_UNKNOWN; return DT_UNKNOWN;
return (ext3_filetype_table[filetype]); return (ext4_filetype_table[filetype]);
} }
int ext3_check_dir_entry (const char * function, struct inode * dir, int ext4_check_dir_entry (const char * function, struct inode * dir,
struct ext3_dir_entry_2 * de, struct ext4_dir_entry_2 * de,
struct buffer_head * bh, struct buffer_head * bh,
unsigned long offset) unsigned long offset)
{ {
const char * error_msg = NULL; const char * error_msg = NULL;
const int rlen = le16_to_cpu(de->rec_len); const int rlen = le16_to_cpu(de->rec_len);
if (rlen < EXT3_DIR_REC_LEN(1)) if (rlen < EXT4_DIR_REC_LEN(1))
error_msg = "rec_len is smaller than minimal"; error_msg = "rec_len is smaller than minimal";
else if (rlen % 4 != 0) else if (rlen % 4 != 0)
error_msg = "rec_len % 4 != 0"; error_msg = "rec_len % 4 != 0";
else if (rlen < EXT3_DIR_REC_LEN(de->name_len)) else if (rlen < EXT4_DIR_REC_LEN(de->name_len))
error_msg = "rec_len is too small for name_len"; error_msg = "rec_len is too small for name_len";
else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize) else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
error_msg = "directory entry across blocks"; error_msg = "directory entry across blocks";
else if (le32_to_cpu(de->inode) > else if (le32_to_cpu(de->inode) >
le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count)) le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count))
error_msg = "inode out of bounds"; error_msg = "inode out of bounds";
if (error_msg != NULL) if (error_msg != NULL)
ext3_error (dir->i_sb, function, ext4_error (dir->i_sb, function,
"bad entry in directory #%lu: %s - " "bad entry in directory #%lu: %s - "
"offset=%lu, inode=%lu, rec_len=%d, name_len=%d", "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
dir->i_ino, error_msg, offset, dir->i_ino, error_msg, offset,
...@@ -94,13 +94,13 @@ int ext3_check_dir_entry (const char * function, struct inode * dir, ...@@ -94,13 +94,13 @@ int ext3_check_dir_entry (const char * function, struct inode * dir,
return error_msg == NULL ? 1 : 0; return error_msg == NULL ? 1 : 0;
} }
static int ext3_readdir(struct file * filp, static int ext4_readdir(struct file * filp,
void * dirent, filldir_t filldir) void * dirent, filldir_t filldir)
{ {
int error = 0; int error = 0;
unsigned long offset; unsigned long offset;
int i, stored; int i, stored;
struct ext3_dir_entry_2 *de; struct ext4_dir_entry_2 *de;
struct super_block *sb; struct super_block *sb;
int err; int err;
struct inode *inode = filp->f_dentry->d_inode; struct inode *inode = filp->f_dentry->d_inode;
...@@ -108,12 +108,12 @@ static int ext3_readdir(struct file * filp, ...@@ -108,12 +108,12 @@ static int ext3_readdir(struct file * filp,
sb = inode->i_sb; sb = inode->i_sb;
#ifdef CONFIG_EXT3_INDEX #ifdef CONFIG_EXT4_INDEX
if (EXT3_HAS_COMPAT_FEATURE(inode->i_sb, if (EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
EXT3_FEATURE_COMPAT_DIR_INDEX) && EXT4_FEATURE_COMPAT_DIR_INDEX) &&
((EXT3_I(inode)->i_flags & EXT3_INDEX_FL) || ((EXT4_I(inode)->i_flags & EXT4_INDEX_FL) ||
((inode->i_size >> sb->s_blocksize_bits) == 1))) { ((inode->i_size >> sb->s_blocksize_bits) == 1))) {
err = ext3_dx_readdir(filp, dirent, filldir); err = ext4_dx_readdir(filp, dirent, filldir);
if (err != ERR_BAD_DX_DIR) { if (err != ERR_BAD_DX_DIR) {
ret = err; ret = err;
goto out; goto out;
...@@ -122,19 +122,19 @@ static int ext3_readdir(struct file * filp, ...@@ -122,19 +122,19 @@ static int ext3_readdir(struct file * filp,
* We don't set the inode dirty flag since it's not * We don't set the inode dirty flag since it's not
* critical that it get flushed back to the disk. * critical that it get flushed back to the disk.
*/ */
EXT3_I(filp->f_dentry->d_inode)->i_flags &= ~EXT3_INDEX_FL; EXT4_I(filp->f_dentry->d_inode)->i_flags &= ~EXT4_INDEX_FL;
} }
#endif #endif
stored = 0; stored = 0;
offset = filp->f_pos & (sb->s_blocksize - 1); offset = filp->f_pos & (sb->s_blocksize - 1);
while (!error && !stored && filp->f_pos < inode->i_size) { while (!error && !stored && filp->f_pos < inode->i_size) {
unsigned long blk = filp->f_pos >> EXT3_BLOCK_SIZE_BITS(sb); unsigned long blk = filp->f_pos >> EXT4_BLOCK_SIZE_BITS(sb);
struct buffer_head map_bh; struct buffer_head map_bh;
struct buffer_head *bh = NULL; struct buffer_head *bh = NULL;
map_bh.b_state = 0; map_bh.b_state = 0;
err = ext3_get_blocks_handle(NULL, inode, blk, 1, err = ext4_get_blocks_handle(NULL, inode, blk, 1,
&map_bh, 0, 0); &map_bh, 0, 0);
if (err > 0) { if (err > 0) {
page_cache_readahead(sb->s_bdev->bd_inode->i_mapping, page_cache_readahead(sb->s_bdev->bd_inode->i_mapping,
...@@ -143,7 +143,7 @@ static int ext3_readdir(struct file * filp, ...@@ -143,7 +143,7 @@ static int ext3_readdir(struct file * filp,
map_bh.b_blocknr >> map_bh.b_blocknr >>
(PAGE_CACHE_SHIFT - inode->i_blkbits), (PAGE_CACHE_SHIFT - inode->i_blkbits),
1); 1);
bh = ext3_bread(NULL, inode, blk, 0, &err); bh = ext4_bread(NULL, inode, blk, 0, &err);
} }
/* /*
...@@ -151,7 +151,7 @@ static int ext3_readdir(struct file * filp, ...@@ -151,7 +151,7 @@ static int ext3_readdir(struct file * filp,
* of recovering data when there's a bad sector * of recovering data when there's a bad sector
*/ */
if (!bh) { if (!bh) {
ext3_error (sb, "ext3_readdir", ext4_error (sb, "ext4_readdir",
"directory #%lu contains a hole at offset %lu", "directory #%lu contains a hole at offset %lu",
inode->i_ino, (unsigned long)filp->f_pos); inode->i_ino, (unsigned long)filp->f_pos);
filp->f_pos += sb->s_blocksize - offset; filp->f_pos += sb->s_blocksize - offset;
...@@ -165,7 +165,7 @@ static int ext3_readdir(struct file * filp, ...@@ -165,7 +165,7 @@ static int ext3_readdir(struct file * filp,
* to make sure. */ * to make sure. */
if (filp->f_version != inode->i_version) { if (filp->f_version != inode->i_version) {
for (i = 0; i < sb->s_blocksize && i < offset; ) { for (i = 0; i < sb->s_blocksize && i < offset; ) {
de = (struct ext3_dir_entry_2 *) de = (struct ext4_dir_entry_2 *)
(bh->b_data + i); (bh->b_data + i);
/* It's too expensive to do a full /* It's too expensive to do a full
* dirent test each time round this * dirent test each time round this
...@@ -174,7 +174,7 @@ static int ext3_readdir(struct file * filp, ...@@ -174,7 +174,7 @@ static int ext3_readdir(struct file * filp,
* failure will be detected in the * failure will be detected in the
* dirent test below. */ * dirent test below. */
if (le16_to_cpu(de->rec_len) < if (le16_to_cpu(de->rec_len) <
EXT3_DIR_REC_LEN(1)) EXT4_DIR_REC_LEN(1))
break; break;
i += le16_to_cpu(de->rec_len); i += le16_to_cpu(de->rec_len);
} }
...@@ -186,8 +186,8 @@ static int ext3_readdir(struct file * filp, ...@@ -186,8 +186,8 @@ static int ext3_readdir(struct file * filp,
while (!error && filp->f_pos < inode->i_size while (!error && filp->f_pos < inode->i_size
&& offset < sb->s_blocksize) { && offset < sb->s_blocksize) {
de = (struct ext3_dir_entry_2 *) (bh->b_data + offset); de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);
if (!ext3_check_dir_entry ("ext3_readdir", inode, de, if (!ext4_check_dir_entry ("ext4_readdir", inode, de,
bh, offset)) { bh, offset)) {
/* On error, skip the f_pos to the /* On error, skip the f_pos to the
next block. */ next block. */
...@@ -228,7 +228,7 @@ static int ext3_readdir(struct file * filp, ...@@ -228,7 +228,7 @@ static int ext3_readdir(struct file * filp,
return ret; return ret;
} }
#ifdef CONFIG_EXT3_INDEX #ifdef CONFIG_EXT4_INDEX
/* /*
* These functions convert from the major/minor hash to an f_pos * These functions convert from the major/minor hash to an f_pos
* value. * value.
...@@ -323,7 +323,7 @@ static struct dir_private_info *create_dir_info(loff_t pos) ...@@ -323,7 +323,7 @@ static struct dir_private_info *create_dir_info(loff_t pos)
return p; return p;
} }
void ext3_htree_free_dir_info(struct dir_private_info *p) void ext4_htree_free_dir_info(struct dir_private_info *p)
{ {
free_rb_tree_fname(&p->root); free_rb_tree_fname(&p->root);
kfree(p); kfree(p);
...@@ -332,9 +332,9 @@ void ext3_htree_free_dir_info(struct dir_private_info *p) ...@@ -332,9 +332,9 @@ void ext3_htree_free_dir_info(struct dir_private_info *p)
/* /*
* Given a directory entry, enter it into the fname rb tree. * Given a directory entry, enter it into the fname rb tree.
*/ */
int ext3_htree_store_dirent(struct file *dir_file, __u32 hash, int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
__u32 minor_hash, __u32 minor_hash,
struct ext3_dir_entry_2 *dirent) struct ext4_dir_entry_2 *dirent)
{ {
struct rb_node **p, *parent = NULL; struct rb_node **p, *parent = NULL;
struct fname * fname, *new_fn; struct fname * fname, *new_fn;
...@@ -390,7 +390,7 @@ int ext3_htree_store_dirent(struct file *dir_file, __u32 hash, ...@@ -390,7 +390,7 @@ int ext3_htree_store_dirent(struct file *dir_file, __u32 hash,
/* /*
* This is a helper function for ext3_dx_readdir. It calls filldir * This is a helper function for ext4_dx_readdir. It calls filldir
* for all entres on the fname linked list. (Normally there is only * for all entres on the fname linked list. (Normally there is only
* one entry on the linked list, unless there are 62 bit hash collisions.) * one entry on the linked list, unless there are 62 bit hash collisions.)
*/ */
...@@ -425,7 +425,7 @@ static int call_filldir(struct file * filp, void * dirent, ...@@ -425,7 +425,7 @@ static int call_filldir(struct file * filp, void * dirent,
return 0; return 0;
} }
static int ext3_dx_readdir(struct file * filp, static int ext4_dx_readdir(struct file * filp,
void * dirent, filldir_t filldir) void * dirent, filldir_t filldir)
{ {
struct dir_private_info *info = filp->private_data; struct dir_private_info *info = filp->private_data;
...@@ -440,7 +440,7 @@ static int ext3_dx_readdir(struct file * filp, ...@@ -440,7 +440,7 @@ static int ext3_dx_readdir(struct file * filp,
filp->private_data = info; filp->private_data = info;
} }
if (filp->f_pos == EXT3_HTREE_EOF) if (filp->f_pos == EXT4_HTREE_EOF)
return 0; /* EOF */ return 0; /* EOF */
/* Some one has messed with f_pos; reset the world */ /* Some one has messed with f_pos; reset the world */
...@@ -474,13 +474,13 @@ static int ext3_dx_readdir(struct file * filp, ...@@ -474,13 +474,13 @@ static int ext3_dx_readdir(struct file * filp,
info->curr_node = NULL; info->curr_node = NULL;
free_rb_tree_fname(&info->root); free_rb_tree_fname(&info->root);
filp->f_version = inode->i_version; filp->f_version = inode->i_version;
ret = ext3_htree_fill_tree(filp, info->curr_hash, ret = ext4_htree_fill_tree(filp, info->curr_hash,
info->curr_minor_hash, info->curr_minor_hash,
&info->next_hash); &info->next_hash);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (ret == 0) { if (ret == 0) {
filp->f_pos = EXT3_HTREE_EOF; filp->f_pos = EXT4_HTREE_EOF;
break; break;
} }
info->curr_node = rb_first(&info->root); info->curr_node = rb_first(&info->root);
...@@ -495,7 +495,7 @@ static int ext3_dx_readdir(struct file * filp, ...@@ -495,7 +495,7 @@ static int ext3_dx_readdir(struct file * filp,
info->curr_node = rb_next(info->curr_node); info->curr_node = rb_next(info->curr_node);
if (!info->curr_node) { if (!info->curr_node) {
if (info->next_hash == ~0) { if (info->next_hash == ~0) {
filp->f_pos = EXT3_HTREE_EOF; filp->f_pos = EXT4_HTREE_EOF;
break; break;
} }
info->curr_hash = info->next_hash; info->curr_hash = info->next_hash;
...@@ -507,10 +507,10 @@ static int ext3_dx_readdir(struct file * filp, ...@@ -507,10 +507,10 @@ static int ext3_dx_readdir(struct file * filp,
return 0; return 0;
} }
static int ext3_release_dir (struct inode * inode, struct file * filp) static int ext4_release_dir (struct inode * inode, struct file * filp)
{ {
if (filp->private_data) if (filp->private_data)
ext3_htree_free_dir_info(filp->private_data); ext4_htree_free_dir_info(filp->private_data);
return 0; return 0;
} }
......
fs/ext4/file.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/file.c * linux/fs/ext4/file.c
* *
* Copyright (C) 1992, 1993, 1994, 1995 * Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr) * Remy Card (card@masi.ibp.fr)
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
* *
* Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
* *
* ext3 fs regular file handling primitives * ext4 fs regular file handling primitives
* *
* 64-bit file support on 64-bit platforms by Jakub Jelinek * 64-bit file support on 64-bit platforms by Jakub Jelinek
* (jj@sunsite.ms.mff.cuni.cz) * (jj@sunsite.ms.mff.cuni.cz)
...@@ -21,34 +21,34 @@ ...@@ -21,34 +21,34 @@
#include <linux/time.h> #include <linux/time.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include "xattr.h" #include "xattr.h"
#include "acl.h" #include "acl.h"
/* /*
* Called when an inode is released. Note that this is different * Called when an inode is released. Note that this is different
* from ext3_file_open: open gets called at every open, but release * from ext4_file_open: open gets called at every open, but release
* gets called only when /all/ the files are closed. * gets called only when /all/ the files are closed.
*/ */
static int ext3_release_file (struct inode * inode, struct file * filp) static int ext4_release_file (struct inode * inode, struct file * filp)
{ {
/* if we are the last writer on the inode, drop the block reservation */ /* if we are the last writer on the inode, drop the block reservation */
if ((filp->f_mode & FMODE_WRITE) && if ((filp->f_mode & FMODE_WRITE) &&
(atomic_read(&inode->i_writecount) == 1)) (atomic_read(&inode->i_writecount) == 1))
{ {
mutex_lock(&EXT3_I(inode)->truncate_mutex); mutex_lock(&EXT4_I(inode)->truncate_mutex);
ext3_discard_reservation(inode); ext4_discard_reservation(inode);
mutex_unlock(&EXT3_I(inode)->truncate_mutex); mutex_unlock(&EXT4_I(inode)->truncate_mutex);
} }
if (is_dx(inode) && filp->private_data) if (is_dx(inode) && filp->private_data)
ext3_htree_free_dir_info(filp->private_data); ext4_htree_free_dir_info(filp->private_data);
return 0; return 0;
} }
static ssize_t static ssize_t
ext3_file_write(struct kiocb *iocb, const struct iovec *iov, ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
unsigned long nr_segs, loff_t pos) unsigned long nr_segs, loff_t pos)
{ {
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
...@@ -79,7 +79,7 @@ ext3_file_write(struct kiocb *iocb, const struct iovec *iov, ...@@ -79,7 +79,7 @@ ext3_file_write(struct kiocb *iocb, const struct iovec *iov,
* Open question --- do we care about flushing timestamps too * Open question --- do we care about flushing timestamps too
* if the inode is IS_SYNC? * if the inode is IS_SYNC?
*/ */
if (!ext3_should_journal_data(inode)) if (!ext4_should_journal_data(inode))
return ret; return ret;
goto force_commit; goto force_commit;
...@@ -100,40 +100,40 @@ ext3_file_write(struct kiocb *iocb, const struct iovec *iov, ...@@ -100,40 +100,40 @@ ext3_file_write(struct kiocb *iocb, const struct iovec *iov,
*/ */
force_commit: force_commit:
err = ext3_force_commit(inode->i_sb); err = ext4_force_commit(inode->i_sb);
if (err) if (err)
return err; return err;
return ret; return ret;
} }
const struct file_operations ext3_file_operations = { const struct file_operations ext4_file_operations = {
.llseek = generic_file_llseek, .llseek = generic_file_llseek,
.read = do_sync_read, .read = do_sync_read,
.write = do_sync_write, .write = do_sync_write,
.aio_read = generic_file_aio_read, .aio_read = generic_file_aio_read,
.aio_write = ext3_file_write, .aio_write = ext4_file_write,
.ioctl = ext3_ioctl, .ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
.compat_ioctl = ext3_compat_ioctl, .compat_ioctl = ext4_compat_ioctl,
#endif #endif
.mmap = generic_file_mmap, .mmap = generic_file_mmap,
.open = generic_file_open, .open = generic_file_open,
.release = ext3_release_file, .release = ext4_release_file,
.fsync = ext3_sync_file, .fsync = ext4_sync_file,
.sendfile = generic_file_sendfile, .sendfile = generic_file_sendfile,
.splice_read = generic_file_splice_read, .splice_read = generic_file_splice_read,
.splice_write = generic_file_splice_write, .splice_write = generic_file_splice_write,
}; };
struct inode_operations ext3_file_inode_operations = { struct inode_operations ext4_file_inode_operations = {
.truncate = ext3_truncate, .truncate = ext4_truncate,
.setattr = ext3_setattr, .setattr = ext4_setattr,
#ifdef CONFIG_EXT3_FS_XATTR #ifdef CONFIG_EXT4DEV_FS_XATTR
.setxattr = generic_setxattr, .setxattr = generic_setxattr,
.getxattr = generic_getxattr, .getxattr = generic_getxattr,
.listxattr = ext3_listxattr, .listxattr = ext4_listxattr,
.removexattr = generic_removexattr, .removexattr = generic_removexattr,
#endif #endif
.permission = ext3_permission, .permission = ext4_permission,
}; };
fs/ext4/fsync.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/fsync.c * linux/fs/ext4/fsync.c
* *
* Copyright (C) 1993 Stephen Tweedie (sct@redhat.com) * Copyright (C) 1993 Stephen Tweedie (sct@redhat.com)
* from * from
...@@ -9,7 +9,7 @@ ...@@ -9,7 +9,7 @@
* from * from
* linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds * linux/fs/minix/truncate.c Copyright (C) 1991, 1992 Linus Torvalds
* *
* ext3fs fsync primitive * ext4fs fsync primitive
* *
* Big-endian to little-endian byte-swapping/bitmaps by * Big-endian to little-endian byte-swapping/bitmaps by
* David S. Miller (davem@caip.rutgers.edu), 1995 * David S. Miller (davem@caip.rutgers.edu), 1995
...@@ -27,11 +27,11 @@ ...@@ -27,11 +27,11 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
/* /*
* akpm: A new design for ext3_sync_file(). * akpm: A new design for ext4_sync_file().
* *
* This is only called from sys_fsync(), sys_fdatasync() and sys_msync(). * This is only called from sys_fsync(), sys_fdatasync() and sys_msync().
* There cannot be a transaction open by this task. * There cannot be a transaction open by this task.
...@@ -42,12 +42,12 @@ ...@@ -42,12 +42,12 @@
* inode to disk. * inode to disk.
*/ */
int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync) int ext4_sync_file(struct file * file, struct dentry *dentry, int datasync)
{ {
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
int ret = 0; int ret = 0;
J_ASSERT(ext3_journal_current_handle() == 0); J_ASSERT(ext4_journal_current_handle() == 0);
/* /*
* data=writeback: * data=writeback:
...@@ -61,14 +61,14 @@ int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync) ...@@ -61,14 +61,14 @@ int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync)
* *
* data=journal: * data=journal:
* filemap_fdatawrite won't do anything (the buffers are clean). * filemap_fdatawrite won't do anything (the buffers are clean).
* ext3_force_commit will write the file data into the journal and * ext4_force_commit will write the file data into the journal and
* will wait on that. * will wait on that.
* filemap_fdatawait() will encounter a ton of newly-dirtied pages * filemap_fdatawait() will encounter a ton of newly-dirtied pages
* (they were dirtied by commit). But that's OK - the blocks are * (they were dirtied by commit). But that's OK - the blocks are
* safe in-journal, which is all fsync() needs to ensure. * safe in-journal, which is all fsync() needs to ensure.
*/ */
if (ext3_should_journal_data(inode)) { if (ext4_should_journal_data(inode)) {
ret = ext3_force_commit(inode->i_sb); ret = ext4_force_commit(inode->i_sb);
goto out; goto out;
} }
......
fs/ext4/hash.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/hash.c * linux/fs/ext4/hash.c
* *
* Copyright (C) 2002 by Theodore Ts'o * Copyright (C) 2002 by Theodore Ts'o
* *
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/cryptohash.h> #include <linux/cryptohash.h>
#define DELTA 0x9E3779B9 #define DELTA 0x9E3779B9
...@@ -89,7 +89,7 @@ static void str2hashbuf(const char *msg, int len, __u32 *buf, int num) ...@@ -89,7 +89,7 @@ static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
* represented, and whether or not the returned hash is 32 bits or 64 * represented, and whether or not the returned hash is 32 bits or 64
* bits. 32 bit hashes will return 0 for the minor hash. * bits. 32 bit hashes will return 0 for the minor hash.
*/ */
int ext3fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo) int ext4fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
{ {
__u32 hash; __u32 hash;
__u32 minor_hash = 0; __u32 minor_hash = 0;
...@@ -144,8 +144,8 @@ int ext3fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo) ...@@ -144,8 +144,8 @@ int ext3fs_dirhash(const char *name, int len, struct dx_hash_info *hinfo)
return -1; return -1;
} }
hash = hash & ~1; hash = hash & ~1;
if (hash == (EXT3_HTREE_EOF << 1)) if (hash == (EXT4_HTREE_EOF << 1))
hash = (EXT3_HTREE_EOF-1) << 1; hash = (EXT4_HTREE_EOF-1) << 1;
hinfo->hash = hash; hinfo->hash = hash;
hinfo->minor_hash = minor_hash; hinfo->minor_hash = minor_hash;
return 0; return 0;
......
fs/ext4/ialloc.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/inode.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/ioctl.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/ioctl.c * linux/fs/ext4/ioctl.c
* *
* Copyright (C) 1993, 1994, 1995 * Copyright (C) 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr) * Remy Card (card@masi.ibp.fr)
...@@ -10,30 +10,30 @@ ...@@ -10,30 +10,30 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, int ext4_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct ext3_inode_info *ei = EXT3_I(inode); struct ext4_inode_info *ei = EXT4_I(inode);
unsigned int flags; unsigned int flags;
unsigned short rsv_window_size; unsigned short rsv_window_size;
ext3_debug ("cmd = %u, arg = %lu\n", cmd, arg); ext4_debug ("cmd = %u, arg = %lu\n", cmd, arg);
switch (cmd) { switch (cmd) {
case EXT3_IOC_GETFLAGS: case EXT4_IOC_GETFLAGS:
flags = ei->i_flags & EXT3_FL_USER_VISIBLE; flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
return put_user(flags, (int __user *) arg); return put_user(flags, (int __user *) arg);
case EXT3_IOC_SETFLAGS: { case EXT4_IOC_SETFLAGS: {
handle_t *handle = NULL; handle_t *handle = NULL;
int err; int err;
struct ext3_iloc iloc; struct ext4_iloc iloc;
unsigned int oldflags; unsigned int oldflags;
unsigned int jflag; unsigned int jflag;
...@@ -47,13 +47,13 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -47,13 +47,13 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
return -EFAULT; return -EFAULT;
if (!S_ISDIR(inode->i_mode)) if (!S_ISDIR(inode->i_mode))
flags &= ~EXT3_DIRSYNC_FL; flags &= ~EXT4_DIRSYNC_FL;
mutex_lock(&inode->i_mutex); mutex_lock(&inode->i_mutex);
oldflags = ei->i_flags; oldflags = ei->i_flags;
/* The JOURNAL_DATA flag is modifiable only by root */ /* The JOURNAL_DATA flag is modifiable only by root */
jflag = flags & EXT3_JOURNAL_DATA_FL; jflag = flags & EXT4_JOURNAL_DATA_FL;
/* /*
* The IMMUTABLE and APPEND_ONLY flags can only be changed by * The IMMUTABLE and APPEND_ONLY flags can only be changed by
...@@ -61,7 +61,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -61,7 +61,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
* *
* This test looks nicer. Thanks to Pauline Middelink * This test looks nicer. Thanks to Pauline Middelink
*/ */
if ((flags ^ oldflags) & (EXT3_APPEND_FL | EXT3_IMMUTABLE_FL)) { if ((flags ^ oldflags) & (EXT4_APPEND_FL | EXT4_IMMUTABLE_FL)) {
if (!capable(CAP_LINUX_IMMUTABLE)) { if (!capable(CAP_LINUX_IMMUTABLE)) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return -EPERM; return -EPERM;
...@@ -72,7 +72,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -72,7 +72,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
* The JOURNAL_DATA flag can only be changed by * The JOURNAL_DATA flag can only be changed by
* the relevant capability. * the relevant capability.
*/ */
if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL)) { if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL)) {
if (!capable(CAP_SYS_RESOURCE)) { if (!capable(CAP_SYS_RESOURCE)) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return -EPERM; return -EPERM;
...@@ -80,44 +80,44 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -80,44 +80,44 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
} }
handle = ext3_journal_start(inode, 1); handle = ext4_journal_start(inode, 1);
if (IS_ERR(handle)) { if (IS_ERR(handle)) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return PTR_ERR(handle); return PTR_ERR(handle);
} }
if (IS_SYNC(inode)) if (IS_SYNC(inode))
handle->h_sync = 1; handle->h_sync = 1;
err = ext3_reserve_inode_write(handle, inode, &iloc); err = ext4_reserve_inode_write(handle, inode, &iloc);
if (err) if (err)
goto flags_err; goto flags_err;
flags = flags & EXT3_FL_USER_MODIFIABLE; flags = flags & EXT4_FL_USER_MODIFIABLE;
flags |= oldflags & ~EXT3_FL_USER_MODIFIABLE; flags |= oldflags & ~EXT4_FL_USER_MODIFIABLE;
ei->i_flags = flags; ei->i_flags = flags;
ext3_set_inode_flags(inode); ext4_set_inode_flags(inode);
inode->i_ctime = CURRENT_TIME_SEC; inode->i_ctime = CURRENT_TIME_SEC;
err = ext3_mark_iloc_dirty(handle, inode, &iloc); err = ext4_mark_iloc_dirty(handle, inode, &iloc);
flags_err: flags_err:
ext3_journal_stop(handle); ext4_journal_stop(handle);
if (err) { if (err) {
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return err; return err;
} }
if ((jflag ^ oldflags) & (EXT3_JOURNAL_DATA_FL)) if ((jflag ^ oldflags) & (EXT4_JOURNAL_DATA_FL))
err = ext3_change_inode_journal_flag(inode, jflag); err = ext4_change_inode_journal_flag(inode, jflag);
mutex_unlock(&inode->i_mutex); mutex_unlock(&inode->i_mutex);
return err; return err;
} }
case EXT3_IOC_GETVERSION: case EXT4_IOC_GETVERSION:
case EXT3_IOC_GETVERSION_OLD: case EXT4_IOC_GETVERSION_OLD:
return put_user(inode->i_generation, (int __user *) arg); return put_user(inode->i_generation, (int __user *) arg);
case EXT3_IOC_SETVERSION: case EXT4_IOC_SETVERSION:
case EXT3_IOC_SETVERSION_OLD: { case EXT4_IOC_SETVERSION_OLD: {
handle_t *handle; handle_t *handle;
struct ext3_iloc iloc; struct ext4_iloc iloc;
__u32 generation; __u32 generation;
int err; int err;
...@@ -128,20 +128,20 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -128,20 +128,20 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
if (get_user(generation, (int __user *) arg)) if (get_user(generation, (int __user *) arg))
return -EFAULT; return -EFAULT;
handle = ext3_journal_start(inode, 1); handle = ext4_journal_start(inode, 1);
if (IS_ERR(handle)) if (IS_ERR(handle))
return PTR_ERR(handle); return PTR_ERR(handle);
err = ext3_reserve_inode_write(handle, inode, &iloc); err = ext4_reserve_inode_write(handle, inode, &iloc);
if (err == 0) { if (err == 0) {
inode->i_ctime = CURRENT_TIME_SEC; inode->i_ctime = CURRENT_TIME_SEC;
inode->i_generation = generation; inode->i_generation = generation;
err = ext3_mark_iloc_dirty(handle, inode, &iloc); err = ext4_mark_iloc_dirty(handle, inode, &iloc);
} }
ext3_journal_stop(handle); ext4_journal_stop(handle);
return err; return err;
} }
#ifdef CONFIG_JBD_DEBUG #ifdef CONFIG_JBD_DEBUG
case EXT3_IOC_WAIT_FOR_READONLY: case EXT4_IOC_WAIT_FOR_READONLY:
/* /*
* This is racy - by the time we're woken up and running, * This is racy - by the time we're woken up and running,
* the superblock could be released. And the module could * the superblock could be released. And the module could
...@@ -155,16 +155,16 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -155,16 +155,16 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
int ret = 0; int ret = 0;
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
add_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait); add_wait_queue(&EXT4_SB(sb)->ro_wait_queue, &wait);
if (timer_pending(&EXT3_SB(sb)->turn_ro_timer)) { if (timer_pending(&EXT4_SB(sb)->turn_ro_timer)) {
schedule(); schedule();
ret = 1; ret = 1;
} }
remove_wait_queue(&EXT3_SB(sb)->ro_wait_queue, &wait); remove_wait_queue(&EXT4_SB(sb)->ro_wait_queue, &wait);
return ret; return ret;
} }
#endif #endif
case EXT3_IOC_GETRSVSZ: case EXT4_IOC_GETRSVSZ:
if (test_opt(inode->i_sb, RESERVATION) if (test_opt(inode->i_sb, RESERVATION)
&& S_ISREG(inode->i_mode) && S_ISREG(inode->i_mode)
&& ei->i_block_alloc_info) { && ei->i_block_alloc_info) {
...@@ -172,7 +172,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -172,7 +172,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
return put_user(rsv_window_size, (int __user *)arg); return put_user(rsv_window_size, (int __user *)arg);
} }
return -ENOTTY; return -ENOTTY;
case EXT3_IOC_SETRSVSZ: { case EXT4_IOC_SETRSVSZ: {
if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode)) if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode))
return -ENOTTY; return -ENOTTY;
...@@ -186,8 +186,8 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -186,8 +186,8 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
if (get_user(rsv_window_size, (int __user *)arg)) if (get_user(rsv_window_size, (int __user *)arg))
return -EFAULT; return -EFAULT;
if (rsv_window_size > EXT3_MAX_RESERVE_BLOCKS) if (rsv_window_size > EXT4_MAX_RESERVE_BLOCKS)
rsv_window_size = EXT3_MAX_RESERVE_BLOCKS; rsv_window_size = EXT4_MAX_RESERVE_BLOCKS;
/* /*
* need to allocate reservation structure for this inode * need to allocate reservation structure for this inode
...@@ -195,17 +195,17 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -195,17 +195,17 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
*/ */
mutex_lock(&ei->truncate_mutex); mutex_lock(&ei->truncate_mutex);
if (!ei->i_block_alloc_info) if (!ei->i_block_alloc_info)
ext3_init_block_alloc_info(inode); ext4_init_block_alloc_info(inode);
if (ei->i_block_alloc_info){ if (ei->i_block_alloc_info){
struct ext3_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node; struct ext4_reserve_window_node *rsv = &ei->i_block_alloc_info->rsv_window_node;
rsv->rsv_goal_size = rsv_window_size; rsv->rsv_goal_size = rsv_window_size;
} }
mutex_unlock(&ei->truncate_mutex); mutex_unlock(&ei->truncate_mutex);
return 0; return 0;
} }
case EXT3_IOC_GROUP_EXTEND: { case EXT4_IOC_GROUP_EXTEND: {
ext3_fsblk_t n_blocks_count; ext4_fsblk_t n_blocks_count;
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
int err; int err;
...@@ -218,15 +218,15 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -218,15 +218,15 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
if (get_user(n_blocks_count, (__u32 __user *)arg)) if (get_user(n_blocks_count, (__u32 __user *)arg))
return -EFAULT; return -EFAULT;
err = ext3_group_extend(sb, EXT3_SB(sb)->s_es, n_blocks_count); err = ext4_group_extend(sb, EXT4_SB(sb)->s_es, n_blocks_count);
journal_lock_updates(EXT3_SB(sb)->s_journal); journal_lock_updates(EXT4_SB(sb)->s_journal);
journal_flush(EXT3_SB(sb)->s_journal); journal_flush(EXT4_SB(sb)->s_journal);
journal_unlock_updates(EXT3_SB(sb)->s_journal); journal_unlock_updates(EXT4_SB(sb)->s_journal);
return err; return err;
} }
case EXT3_IOC_GROUP_ADD: { case EXT4_IOC_GROUP_ADD: {
struct ext3_new_group_data input; struct ext4_new_group_data input;
struct super_block *sb = inode->i_sb; struct super_block *sb = inode->i_sb;
int err; int err;
...@@ -236,14 +236,14 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -236,14 +236,14 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
if (IS_RDONLY(inode)) if (IS_RDONLY(inode))
return -EROFS; return -EROFS;
if (copy_from_user(&input, (struct ext3_new_group_input __user *)arg, if (copy_from_user(&input, (struct ext4_new_group_input __user *)arg,
sizeof(input))) sizeof(input)))
return -EFAULT; return -EFAULT;
err = ext3_group_add(sb, &input); err = ext4_group_add(sb, &input);
journal_lock_updates(EXT3_SB(sb)->s_journal); journal_lock_updates(EXT4_SB(sb)->s_journal);
journal_flush(EXT3_SB(sb)->s_journal); journal_flush(EXT4_SB(sb)->s_journal);
journal_unlock_updates(EXT3_SB(sb)->s_journal); journal_unlock_updates(EXT4_SB(sb)->s_journal);
return err; return err;
} }
...@@ -255,52 +255,52 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd, ...@@ -255,52 +255,52 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
} }
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
long ext3_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) long ext4_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
struct inode *inode = file->f_dentry->d_inode; struct inode *inode = file->f_dentry->d_inode;
int ret; int ret;
/* These are just misnamed, they actually get/put from/to user an int */ /* These are just misnamed, they actually get/put from/to user an int */
switch (cmd) { switch (cmd) {
case EXT3_IOC32_GETFLAGS: case EXT4_IOC32_GETFLAGS:
cmd = EXT3_IOC_GETFLAGS; cmd = EXT4_IOC_GETFLAGS;
break; break;
case EXT3_IOC32_SETFLAGS: case EXT4_IOC32_SETFLAGS:
cmd = EXT3_IOC_SETFLAGS; cmd = EXT4_IOC_SETFLAGS;
break; break;
case EXT3_IOC32_GETVERSION: case EXT4_IOC32_GETVERSION:
cmd = EXT3_IOC_GETVERSION; cmd = EXT4_IOC_GETVERSION;
break; break;
case EXT3_IOC32_SETVERSION: case EXT4_IOC32_SETVERSION:
cmd = EXT3_IOC_SETVERSION; cmd = EXT4_IOC_SETVERSION;
break; break;
case EXT3_IOC32_GROUP_EXTEND: case EXT4_IOC32_GROUP_EXTEND:
cmd = EXT3_IOC_GROUP_EXTEND; cmd = EXT4_IOC_GROUP_EXTEND;
break; break;
case EXT3_IOC32_GETVERSION_OLD: case EXT4_IOC32_GETVERSION_OLD:
cmd = EXT3_IOC_GETVERSION_OLD; cmd = EXT4_IOC_GETVERSION_OLD;
break; break;
case EXT3_IOC32_SETVERSION_OLD: case EXT4_IOC32_SETVERSION_OLD:
cmd = EXT3_IOC_SETVERSION_OLD; cmd = EXT4_IOC_SETVERSION_OLD;
break; break;
#ifdef CONFIG_JBD_DEBUG #ifdef CONFIG_JBD_DEBUG
case EXT3_IOC32_WAIT_FOR_READONLY: case EXT4_IOC32_WAIT_FOR_READONLY:
cmd = EXT3_IOC_WAIT_FOR_READONLY; cmd = EXT4_IOC_WAIT_FOR_READONLY;
break; break;
#endif #endif
case EXT3_IOC32_GETRSVSZ: case EXT4_IOC32_GETRSVSZ:
cmd = EXT3_IOC_GETRSVSZ; cmd = EXT4_IOC_GETRSVSZ;
break; break;
case EXT3_IOC32_SETRSVSZ: case EXT4_IOC32_SETRSVSZ:
cmd = EXT3_IOC_SETRSVSZ; cmd = EXT4_IOC_SETRSVSZ;
break; break;
case EXT3_IOC_GROUP_ADD: case EXT4_IOC_GROUP_ADD:
break; break;
default: default:
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
} }
lock_kernel(); lock_kernel();
ret = ext3_ioctl(inode, file, cmd, (unsigned long) compat_ptr(arg)); ret = ext4_ioctl(inode, file, cmd, (unsigned long) compat_ptr(arg));
unlock_kernel(); unlock_kernel();
return ret; return ret;
} }
......
fs/ext4/namei.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/namei.h
浏览文件 @ 617ba13b
/* linux/fs/ext3/namei.h /* linux/fs/ext4/namei.h
* *
* Copyright (C) 2005 Simtec Electronics * Copyright (C) 2005 Simtec Electronics
* Ben Dooks <ben@simtec.co.uk> * Ben Dooks <ben@simtec.co.uk>
* *
*/ */
extern struct dentry *ext3_get_parent(struct dentry *child); extern struct dentry *ext4_get_parent(struct dentry *child);
fs/ext4/resize.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/super.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/symlink.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/symlink.c * linux/fs/ext4/symlink.c
* *
* Only fast symlinks left here - the rest is done by generic code. AV, 1999 * Only fast symlinks left here - the rest is done by generic code. AV, 1999
* *
...@@ -14,41 +14,41 @@ ...@@ -14,41 +14,41 @@
* *
* Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
* *
* ext3 symlink handling code * ext4 symlink handling code
*/ */
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/jbd.h> #include <linux/jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/namei.h> #include <linux/namei.h>
#include "xattr.h" #include "xattr.h"
static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd) static void * ext4_follow_link(struct dentry *dentry, struct nameidata *nd)
{ {
struct ext3_inode_info *ei = EXT3_I(dentry->d_inode); struct ext4_inode_info *ei = EXT4_I(dentry->d_inode);
nd_set_link(nd, (char*)ei->i_data); nd_set_link(nd, (char*)ei->i_data);
return NULL; return NULL;
} }
struct inode_operations ext3_symlink_inode_operations = { struct inode_operations ext4_symlink_inode_operations = {
.readlink = generic_readlink, .readlink = generic_readlink,
.follow_link = page_follow_link_light, .follow_link = page_follow_link_light,
.put_link = page_put_link, .put_link = page_put_link,
#ifdef CONFIG_EXT3_FS_XATTR #ifdef CONFIG_EXT4DEV_FS_XATTR
.setxattr = generic_setxattr, .setxattr = generic_setxattr,
.getxattr = generic_getxattr, .getxattr = generic_getxattr,
.listxattr = ext3_listxattr, .listxattr = ext4_listxattr,
.removexattr = generic_removexattr, .removexattr = generic_removexattr,
#endif #endif
}; };
struct inode_operations ext3_fast_symlink_inode_operations = { struct inode_operations ext4_fast_symlink_inode_operations = {
.readlink = generic_readlink, .readlink = generic_readlink,
.follow_link = ext3_follow_link, .follow_link = ext4_follow_link,
#ifdef CONFIG_EXT3_FS_XATTR #ifdef CONFIG_EXT4DEV_FS_XATTR
.setxattr = generic_setxattr, .setxattr = generic_setxattr,
.getxattr = generic_getxattr, .getxattr = generic_getxattr,
.listxattr = ext3_listxattr, .listxattr = ext4_listxattr,
.removexattr = generic_removexattr, .removexattr = generic_removexattr,
#endif #endif
}; };
fs/ext4/xattr.c
浏览文件 @ 617ba13b
此差异已折叠。
fs/ext4/xattr.h
浏览文件 @ 617ba13b
/* /*
File: fs/ext3/xattr.h File: fs/ext4/xattr.h
On-disk format of extended attributes for the ext3 filesystem. On-disk format of extended attributes for the ext4 filesystem.
(C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org> (C) 2001 Andreas Gruenbacher, <a.gruenbacher@computer.org>
*/ */
...@@ -9,20 +9,20 @@ ...@@ -9,20 +9,20 @@
#include <linux/xattr.h> #include <linux/xattr.h>
/* Magic value in attribute blocks */ /* Magic value in attribute blocks */
#define EXT3_XATTR_MAGIC 0xEA020000 #define EXT4_XATTR_MAGIC 0xEA020000
/* Maximum number of references to one attribute block */ /* Maximum number of references to one attribute block */
#define EXT3_XATTR_REFCOUNT_MAX 1024 #define EXT4_XATTR_REFCOUNT_MAX 1024
/* Name indexes */ /* Name indexes */
#define EXT3_XATTR_INDEX_USER 1 #define EXT4_XATTR_INDEX_USER 1
#define EXT3_XATTR_INDEX_POSIX_ACL_ACCESS 2 #define EXT4_XATTR_INDEX_POSIX_ACL_ACCESS 2
#define EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT 3 #define EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT 3
#define EXT3_XATTR_INDEX_TRUSTED 4 #define EXT4_XATTR_INDEX_TRUSTED 4
#define EXT3_XATTR_INDEX_LUSTRE 5 #define EXT4_XATTR_INDEX_LUSTRE 5
#define EXT3_XATTR_INDEX_SECURITY 6 #define EXT4_XATTR_INDEX_SECURITY 6
struct ext3_xattr_header { struct ext4_xattr_header {
__le32 h_magic; /* magic number for identification */ __le32 h_magic; /* magic number for identification */
__le32 h_refcount; /* reference count */ __le32 h_refcount; /* reference count */
__le32 h_blocks; /* number of disk blocks used */ __le32 h_blocks; /* number of disk blocks used */
...@@ -30,11 +30,11 @@ struct ext3_xattr_header { ...@@ -30,11 +30,11 @@ struct ext3_xattr_header {
__u32 h_reserved[4]; /* zero right now */ __u32 h_reserved[4]; /* zero right now */
}; };
struct ext3_xattr_ibody_header { struct ext4_xattr_ibody_header {
__le32 h_magic; /* magic number for identification */ __le32 h_magic; /* magic number for identification */
}; };
struct ext3_xattr_entry { struct ext4_xattr_entry {
__u8 e_name_len; /* length of name */ __u8 e_name_len; /* length of name */
__u8 e_name_index; /* attribute name index */ __u8 e_name_index; /* attribute name index */
__le16 e_value_offs; /* offset in disk block of value */ __le16 e_value_offs; /* offset in disk block of value */
...@@ -44,100 +44,100 @@ struct ext3_xattr_entry { ...@@ -44,100 +44,100 @@ struct ext3_xattr_entry {
char e_name[0]; /* attribute name */ char e_name[0]; /* attribute name */
}; };
#define EXT3_XATTR_PAD_BITS 2 #define EXT4_XATTR_PAD_BITS 2
#define EXT3_XATTR_PAD (1<<EXT3_XATTR_PAD_BITS) #define EXT4_XATTR_PAD (1<<EXT4_XATTR_PAD_BITS)
#define EXT3_XATTR_ROUND (EXT3_XATTR_PAD-1) #define EXT4_XATTR_ROUND (EXT4_XATTR_PAD-1)
#define EXT3_XATTR_LEN(name_len) \ #define EXT4_XATTR_LEN(name_len) \
(((name_len) + EXT3_XATTR_ROUND + \ (((name_len) + EXT4_XATTR_ROUND + \
sizeof(struct ext3_xattr_entry)) & ~EXT3_XATTR_ROUND) sizeof(struct ext4_xattr_entry)) & ~EXT4_XATTR_ROUND)
#define EXT3_XATTR_NEXT(entry) \ #define EXT4_XATTR_NEXT(entry) \
( (struct ext3_xattr_entry *)( \ ( (struct ext4_xattr_entry *)( \
(char *)(entry) + EXT3_XATTR_LEN((entry)->e_name_len)) ) (char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)) )
#define EXT3_XATTR_SIZE(size) \ #define EXT4_XATTR_SIZE(size) \
(((size) + EXT3_XATTR_ROUND) & ~EXT3_XATTR_ROUND) (((size) + EXT4_XATTR_ROUND) & ~EXT4_XATTR_ROUND)
# ifdef CONFIG_EXT3_FS_XATTR # ifdef CONFIG_EXT4DEV_FS_XATTR
extern struct xattr_handler ext3_xattr_user_handler; extern struct xattr_handler ext4_xattr_user_handler;
extern struct xattr_handler ext3_xattr_trusted_handler; extern struct xattr_handler ext4_xattr_trusted_handler;
extern struct xattr_handler ext3_xattr_acl_access_handler; extern struct xattr_handler ext4_xattr_acl_access_handler;
extern struct xattr_handler ext3_xattr_acl_default_handler; extern struct xattr_handler ext4_xattr_acl_default_handler;
extern struct xattr_handler ext3_xattr_security_handler; extern struct xattr_handler ext4_xattr_security_handler;
extern ssize_t ext3_listxattr(struct dentry *, char *, size_t); extern ssize_t ext4_listxattr(struct dentry *, char *, size_t);
extern int ext3_xattr_get(struct inode *, int, const char *, void *, size_t); extern int ext4_xattr_get(struct inode *, int, const char *, void *, size_t);
extern int ext3_xattr_list(struct inode *, char *, size_t); extern int ext4_xattr_list(struct inode *, char *, size_t);
extern int ext3_xattr_set(struct inode *, int, const char *, const void *, size_t, int); extern int ext4_xattr_set(struct inode *, int, const char *, const void *, size_t, int);
extern int ext3_xattr_set_handle(handle_t *, struct inode *, int, const char *, const void *, size_t, int); extern int ext4_xattr_set_handle(handle_t *, struct inode *, int, const char *, const void *, size_t, int);
extern void ext3_xattr_delete_inode(handle_t *, struct inode *); extern void ext4_xattr_delete_inode(handle_t *, struct inode *);
extern void ext3_xattr_put_super(struct super_block *); extern void ext4_xattr_put_super(struct super_block *);
extern int init_ext3_xattr(void); extern int init_ext4_xattr(void);
extern void exit_ext3_xattr(void); extern void exit_ext4_xattr(void);
extern struct xattr_handler *ext3_xattr_handlers[]; extern struct xattr_handler *ext4_xattr_handlers[];
# else /* CONFIG_EXT3_FS_XATTR */ # else /* CONFIG_EXT4DEV_FS_XATTR */
static inline int static inline int
ext3_xattr_get(struct inode *inode, int name_index, const char *name, ext4_xattr_get(struct inode *inode, int name_index, const char *name,
void *buffer, size_t size, int flags) void *buffer, size_t size, int flags)
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
static inline int static inline int
ext3_xattr_list(struct inode *inode, void *buffer, size_t size) ext4_xattr_list(struct inode *inode, void *buffer, size_t size)
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
static inline int static inline int
ext3_xattr_set(struct inode *inode, int name_index, const char *name, ext4_xattr_set(struct inode *inode, int name_index, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
static inline int static inline int
ext3_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index, ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
const char *name, const void *value, size_t size, int flags) const char *name, const void *value, size_t size, int flags)
{ {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
static inline void static inline void
ext3_xattr_delete_inode(handle_t *handle, struct inode *inode) ext4_xattr_delete_inode(handle_t *handle, struct inode *inode)
{ {
} }
static inline void static inline void
ext3_xattr_put_super(struct super_block *sb) ext4_xattr_put_super(struct super_block *sb)
{ {
} }
static inline int static inline int
init_ext3_xattr(void) init_ext4_xattr(void)
{ {
return 0; return 0;
} }
static inline void static inline void
exit_ext3_xattr(void) exit_ext4_xattr(void)
{ {
} }
#define ext3_xattr_handlers NULL #define ext4_xattr_handlers NULL
# endif /* CONFIG_EXT3_FS_XATTR */ # endif /* CONFIG_EXT4DEV_FS_XATTR */
#ifdef CONFIG_EXT3_FS_SECURITY #ifdef CONFIG_EXT4DEV_FS_SECURITY
extern int ext3_init_security(handle_t *handle, struct inode *inode, extern int ext4_init_security(handle_t *handle, struct inode *inode,
struct inode *dir); struct inode *dir);
#else #else
static inline int ext3_init_security(handle_t *handle, struct inode *inode, static inline int ext4_init_security(handle_t *handle, struct inode *inode,
struct inode *dir) struct inode *dir)
{ {
return 0; return 0;
......
fs/ext4/xattr_security.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/xattr_security.c * linux/fs/ext4/xattr_security.c
* Handler for storing security labels as extended attributes. * Handler for storing security labels as extended attributes.
*/ */
...@@ -7,13 +7,13 @@ ...@@ -7,13 +7,13 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include <linux/security.h> #include <linux/security.h>
#include "xattr.h" #include "xattr.h"
static size_t static size_t
ext3_xattr_security_list(struct inode *inode, char *list, size_t list_size, ext4_xattr_security_list(struct inode *inode, char *list, size_t list_size,
const char *name, size_t name_len) const char *name, size_t name_len)
{ {
const size_t prefix_len = sizeof(XATTR_SECURITY_PREFIX)-1; const size_t prefix_len = sizeof(XATTR_SECURITY_PREFIX)-1;
...@@ -29,27 +29,27 @@ ext3_xattr_security_list(struct inode *inode, char *list, size_t list_size, ...@@ -29,27 +29,27 @@ ext3_xattr_security_list(struct inode *inode, char *list, size_t list_size,
} }
static int static int
ext3_xattr_security_get(struct inode *inode, const char *name, ext4_xattr_security_get(struct inode *inode, const char *name,
void *buffer, size_t size) void *buffer, size_t size)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
return ext3_xattr_get(inode, EXT3_XATTR_INDEX_SECURITY, name, return ext4_xattr_get(inode, EXT4_XATTR_INDEX_SECURITY, name,
buffer, size); buffer, size);
} }
static int static int
ext3_xattr_security_set(struct inode *inode, const char *name, ext4_xattr_security_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
return ext3_xattr_set(inode, EXT3_XATTR_INDEX_SECURITY, name, return ext4_xattr_set(inode, EXT4_XATTR_INDEX_SECURITY, name,
value, size, flags); value, size, flags);
} }
int int
ext3_init_security(handle_t *handle, struct inode *inode, struct inode *dir) ext4_init_security(handle_t *handle, struct inode *inode, struct inode *dir)
{ {
int err; int err;
size_t len; size_t len;
...@@ -62,16 +62,16 @@ ext3_init_security(handle_t *handle, struct inode *inode, struct inode *dir) ...@@ -62,16 +62,16 @@ ext3_init_security(handle_t *handle, struct inode *inode, struct inode *dir)
return 0; return 0;
return err; return err;
} }
err = ext3_xattr_set_handle(handle, inode, EXT3_XATTR_INDEX_SECURITY, err = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_SECURITY,
name, value, len, 0); name, value, len, 0);
kfree(name); kfree(name);
kfree(value); kfree(value);
return err; return err;
} }
struct xattr_handler ext3_xattr_security_handler = { struct xattr_handler ext4_xattr_security_handler = {
.prefix = XATTR_SECURITY_PREFIX, .prefix = XATTR_SECURITY_PREFIX,
.list = ext3_xattr_security_list, .list = ext4_xattr_security_list,
.get = ext3_xattr_security_get, .get = ext4_xattr_security_get,
.set = ext3_xattr_security_set, .set = ext4_xattr_security_set,
}; };
fs/ext4/xattr_trusted.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/xattr_trusted.c * linux/fs/ext4/xattr_trusted.c
* Handler for trusted extended attributes. * Handler for trusted extended attributes.
* *
* Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org> * Copyright (C) 2003 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
...@@ -10,14 +10,14 @@ ...@@ -10,14 +10,14 @@
#include <linux/capability.h> #include <linux/capability.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"
#define XATTR_TRUSTED_PREFIX "trusted." #define XATTR_TRUSTED_PREFIX "trusted."
static size_t static size_t
ext3_xattr_trusted_list(struct inode *inode, char *list, size_t list_size, ext4_xattr_trusted_list(struct inode *inode, char *list, size_t list_size,
const char *name, size_t name_len) const char *name, size_t name_len)
{ {
const size_t prefix_len = sizeof(XATTR_TRUSTED_PREFIX)-1; const size_t prefix_len = sizeof(XATTR_TRUSTED_PREFIX)-1;
...@@ -35,28 +35,28 @@ ext3_xattr_trusted_list(struct inode *inode, char *list, size_t list_size, ...@@ -35,28 +35,28 @@ ext3_xattr_trusted_list(struct inode *inode, char *list, size_t list_size,
} }
static int static int
ext3_xattr_trusted_get(struct inode *inode, const char *name, ext4_xattr_trusted_get(struct inode *inode, const char *name,
void *buffer, size_t size) void *buffer, size_t size)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
return ext3_xattr_get(inode, EXT3_XATTR_INDEX_TRUSTED, name, return ext4_xattr_get(inode, EXT4_XATTR_INDEX_TRUSTED, name,
buffer, size); buffer, size);
} }
static int static int
ext3_xattr_trusted_set(struct inode *inode, const char *name, ext4_xattr_trusted_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
return ext3_xattr_set(inode, EXT3_XATTR_INDEX_TRUSTED, name, return ext4_xattr_set(inode, EXT4_XATTR_INDEX_TRUSTED, name,
value, size, flags); value, size, flags);
} }
struct xattr_handler ext3_xattr_trusted_handler = { struct xattr_handler ext4_xattr_trusted_handler = {
.prefix = XATTR_TRUSTED_PREFIX, .prefix = XATTR_TRUSTED_PREFIX,
.list = ext3_xattr_trusted_list, .list = ext4_xattr_trusted_list,
.get = ext3_xattr_trusted_get, .get = ext4_xattr_trusted_get,
.set = ext3_xattr_trusted_set, .set = ext4_xattr_trusted_set,
}; };
fs/ext4/xattr_user.c
浏览文件 @ 617ba13b
/* /*
* linux/fs/ext3/xattr_user.c * linux/fs/ext4/xattr_user.c
* Handler for extended user attributes. * Handler for extended user attributes.
* *
* Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org> * Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
...@@ -9,14 +9,14 @@ ...@@ -9,14 +9,14 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/ext3_jbd.h> #include <linux/ext4_jbd.h>
#include <linux/ext3_fs.h> #include <linux/ext4_fs.h>
#include "xattr.h" #include "xattr.h"
#define XATTR_USER_PREFIX "user." #define XATTR_USER_PREFIX "user."
static size_t static size_t
ext3_xattr_user_list(struct inode *inode, char *list, size_t list_size, ext4_xattr_user_list(struct inode *inode, char *list, size_t list_size,
const char *name, size_t name_len) const char *name, size_t name_len)
{ {
const size_t prefix_len = sizeof(XATTR_USER_PREFIX)-1; const size_t prefix_len = sizeof(XATTR_USER_PREFIX)-1;
...@@ -34,31 +34,31 @@ ext3_xattr_user_list(struct inode *inode, char *list, size_t list_size, ...@@ -34,31 +34,31 @@ ext3_xattr_user_list(struct inode *inode, char *list, size_t list_size,
} }
static int static int
ext3_xattr_user_get(struct inode *inode, const char *name, ext4_xattr_user_get(struct inode *inode, const char *name,
void *buffer, size_t size) void *buffer, size_t size)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
if (!test_opt(inode->i_sb, XATTR_USER)) if (!test_opt(inode->i_sb, XATTR_USER))
return -EOPNOTSUPP; return -EOPNOTSUPP;
return ext3_xattr_get(inode, EXT3_XATTR_INDEX_USER, name, buffer, size); return ext4_xattr_get(inode, EXT4_XATTR_INDEX_USER, name, buffer, size);
} }
static int static int
ext3_xattr_user_set(struct inode *inode, const char *name, ext4_xattr_user_set(struct inode *inode, const char *name,
const void *value, size_t size, int flags) const void *value, size_t size, int flags)
{ {
if (strcmp(name, "") == 0) if (strcmp(name, "") == 0)
return -EINVAL; return -EINVAL;
if (!test_opt(inode->i_sb, XATTR_USER)) if (!test_opt(inode->i_sb, XATTR_USER))
return -EOPNOTSUPP; return -EOPNOTSUPP;
return ext3_xattr_set(inode, EXT3_XATTR_INDEX_USER, name, return ext4_xattr_set(inode, EXT4_XATTR_INDEX_USER, name,
value, size, flags); value, size, flags);
} }
struct xattr_handler ext3_xattr_user_handler = { struct xattr_handler ext4_xattr_user_handler = {
.prefix = XATTR_USER_PREFIX, .prefix = XATTR_USER_PREFIX,
.list = ext3_xattr_user_list, .list = ext4_xattr_user_list,
.get = ext3_xattr_user_get, .get = ext4_xattr_user_get,
.set = ext3_xattr_user_set, .set = ext4_xattr_user_set,
}; };
include/linux/ext4_fs.h
浏览文件 @ 617ba13b
此差异已折叠。
include/linux/ext4_fs_i.h
浏览文件 @ 617ba13b
/* /*
* linux/include/linux/ext3_fs_i.h * linux/include/linux/ext4_fs_i.h
* *
* Copyright (C) 1992, 1993, 1994, 1995 * Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr) * Remy Card (card@masi.ibp.fr)
...@@ -13,8 +13,8 @@ ...@@ -13,8 +13,8 @@
* Copyright (C) 1991, 1992 Linus Torvalds * Copyright (C) 1991, 1992 Linus Torvalds
*/ */
#ifndef _LINUX_EXT3_FS_I #ifndef _LINUX_EXT4_FS_I
#define _LINUX_EXT3_FS_I #define _LINUX_EXT4_FS_I
#include <linux/rwsem.h> #include <linux/rwsem.h>
#include <linux/rbtree.h> #include <linux/rbtree.h>
...@@ -22,43 +22,43 @@ ...@@ -22,43 +22,43 @@
#include <linux/mutex.h> #include <linux/mutex.h>
/* data type for block offset of block group */ /* data type for block offset of block group */
typedef int ext3_grpblk_t; typedef int ext4_grpblk_t;
/* data type for filesystem-wide blocks number */ /* data type for filesystem-wide blocks number */
typedef unsigned long ext3_fsblk_t; typedef unsigned long ext4_fsblk_t;
#define E3FSBLK "%lu" #define E3FSBLK "%lu"
struct ext3_reserve_window { struct ext4_reserve_window {
ext3_fsblk_t _rsv_start; /* First byte reserved */ ext4_fsblk_t _rsv_start; /* First byte reserved */
ext3_fsblk_t _rsv_end; /* Last byte reserved or 0 */ ext4_fsblk_t _rsv_end; /* Last byte reserved or 0 */
}; };
struct ext3_reserve_window_node { struct ext4_reserve_window_node {
struct rb_node rsv_node; struct rb_node rsv_node;
__u32 rsv_goal_size; __u32 rsv_goal_size;
__u32 rsv_alloc_hit; __u32 rsv_alloc_hit;
struct ext3_reserve_window rsv_window; struct ext4_reserve_window rsv_window;
}; };
struct ext3_block_alloc_info { struct ext4_block_alloc_info {
/* information about reservation window */ /* information about reservation window */
struct ext3_reserve_window_node rsv_window_node; struct ext4_reserve_window_node rsv_window_node;
/* /*
* was i_next_alloc_block in ext3_inode_info * was i_next_alloc_block in ext4_inode_info
* is the logical (file-relative) number of the * is the logical (file-relative) number of the
* most-recently-allocated block in this file. * most-recently-allocated block in this file.
* We use this for detecting linearly ascending allocation requests. * We use this for detecting linearly ascending allocation requests.
*/ */
__u32 last_alloc_logical_block; __u32 last_alloc_logical_block;
/* /*
* Was i_next_alloc_goal in ext3_inode_info * Was i_next_alloc_goal in ext4_inode_info
* is the *physical* companion to i_next_alloc_block. * is the *physical* companion to i_next_alloc_block.
* it the the physical block number of the block which was most-recentl * it the the physical block number of the block which was most-recentl
* allocated to this file. This give us the goal (target) for the next * allocated to this file. This give us the goal (target) for the next
* allocation when we detect linearly ascending requests. * allocation when we detect linearly ascending requests.
*/ */
ext3_fsblk_t last_alloc_physical_block; ext4_fsblk_t last_alloc_physical_block;
}; };
#define rsv_start rsv_window._rsv_start #define rsv_start rsv_window._rsv_start
...@@ -67,15 +67,15 @@ struct ext3_block_alloc_info { ...@@ -67,15 +67,15 @@ struct ext3_block_alloc_info {
/* /*
* third extended file system inode data in memory * third extended file system inode data in memory
*/ */
struct ext3_inode_info { struct ext4_inode_info {
__le32 i_data[15]; /* unconverted */ __le32 i_data[15]; /* unconverted */
__u32 i_flags; __u32 i_flags;
#ifdef EXT3_FRAGMENTS #ifdef EXT4_FRAGMENTS
__u32 i_faddr; __u32 i_faddr;
__u8 i_frag_no; __u8 i_frag_no;
__u8 i_frag_size; __u8 i_frag_size;
#endif #endif
ext3_fsblk_t i_file_acl; ext4_fsblk_t i_file_acl;
__u32 i_dir_acl; __u32 i_dir_acl;
__u32 i_dtime; __u32 i_dtime;
...@@ -87,13 +87,13 @@ struct ext3_inode_info { ...@@ -87,13 +87,13 @@ struct ext3_inode_info {
* near to their parent directory's inode. * near to their parent directory's inode.
*/ */
__u32 i_block_group; __u32 i_block_group;
__u32 i_state; /* Dynamic state flags for ext3 */ __u32 i_state; /* Dynamic state flags for ext4 */
/* block reservation info */ /* block reservation info */
struct ext3_block_alloc_info *i_block_alloc_info; struct ext4_block_alloc_info *i_block_alloc_info;
__u32 i_dir_start_lookup; __u32 i_dir_start_lookup;
#ifdef CONFIG_EXT3_FS_XATTR #ifdef CONFIG_EXT4DEV_FS_XATTR
/* /*
* Extended attributes can be read independently of the main file * Extended attributes can be read independently of the main file
* data. Taking i_mutex even when reading would cause contention * data. Taking i_mutex even when reading would cause contention
...@@ -103,7 +103,7 @@ struct ext3_inode_info { ...@@ -103,7 +103,7 @@ struct ext3_inode_info {
*/ */
struct rw_semaphore xattr_sem; struct rw_semaphore xattr_sem;
#endif #endif
#ifdef CONFIG_EXT3_FS_POSIX_ACL #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
struct posix_acl *i_acl; struct posix_acl *i_acl;
struct posix_acl *i_default_acl; struct posix_acl *i_default_acl;
#endif #endif
...@@ -113,7 +113,7 @@ struct ext3_inode_info { ...@@ -113,7 +113,7 @@ struct ext3_inode_info {
/* /*
* i_disksize keeps track of what the inode size is ON DISK, not * i_disksize keeps track of what the inode size is ON DISK, not
* in memory. During truncate, i_size is set to the new size by * in memory. During truncate, i_size is set to the new size by
* the VFS prior to calling ext3_truncate(), but the filesystem won't * the VFS prior to calling ext4_truncate(), but the filesystem won't
* set i_disksize to 0 until the truncate is actually under way. * set i_disksize to 0 until the truncate is actually under way.
* *
* The intent is that i_disksize always represents the blocks which * The intent is that i_disksize always represents the blocks which
...@@ -123,7 +123,7 @@ struct ext3_inode_info { ...@@ -123,7 +123,7 @@ struct ext3_inode_info {
* *
* The only time when i_disksize and i_size may be different is when * The only time when i_disksize and i_size may be different is when
* a truncate is in progress. The only things which change i_disksize * a truncate is in progress. The only things which change i_disksize
* are ext3_get_block (growth) and ext3_truncate (shrinkth). * are ext4_get_block (growth) and ext4_truncate (shrinkth).
*/ */
loff_t i_disksize; loff_t i_disksize;
...@@ -131,10 +131,10 @@ struct ext3_inode_info { ...@@ -131,10 +131,10 @@ struct ext3_inode_info {
__u16 i_extra_isize; __u16 i_extra_isize;
/* /*
* truncate_mutex is for serialising ext3_truncate() against * truncate_mutex is for serialising ext4_truncate() against
* ext3_getblock(). In the 2.4 ext2 design, great chunks of inode's * ext4_getblock(). In the 2.4 ext2 design, great chunks of inode's
* data tree are chopped off during truncate. We can't do that in * data tree are chopped off during truncate. We can't do that in
* ext3 because whenever we perform intermediate commits during * ext4 because whenever we perform intermediate commits during
* truncate, the inode and all the metadata blocks *must* be in a * truncate, the inode and all the metadata blocks *must* be in a
* consistent state which allows truncation of the orphans to restart * consistent state which allows truncation of the orphans to restart
* during recovery. Hence we must fix the get_block-vs-truncate race * during recovery. Hence we must fix the get_block-vs-truncate race
...@@ -144,4 +144,4 @@ struct ext3_inode_info { ...@@ -144,4 +144,4 @@ struct ext3_inode_info {
struct inode vfs_inode; struct inode vfs_inode;
}; };
#endif /* _LINUX_EXT3_FS_I */ #endif /* _LINUX_EXT4_FS_I */
include/linux/ext4_fs_sb.h
浏览文件 @ 617ba13b
此差异已折叠。
include/linux/ext4_jbd.h
浏览文件 @ 617ba13b
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或