Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6
* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6: ext2: Resolve 'dereferencing pointer to incomplete type' when enabling EXT2_XATTR_DEBUG ext3: Remove redundant unlikely() ext2: Remove redundant unlikely() ext3: speed up file creates by optimizing rec_len functions ext2: speed up file creates by optimizing rec_len functions ext3: Add more journal error check ext3: Add journal error check in resize.c quota: Use %pV and __attribute__((format (printf in __quota_error and fix fallout ext3: Add FITRIM handling ext3: Add batched discard support for ext3 ext3: Add journal error check into ext3_rename() ext3: Use search_dirblock() in ext3_dx_find_entry() ext3: Avoid uninitialized memory references with a corrupted htree directory ext3: Return error code from generic_check_addressable ext3: Add journal error check into ext3_delete_entry() ext3: Add error check in ext3_mkdir() fs/ext3/super.c: Use printf extension %pV fs/ext2/super.c: Use printf extension %pV ext3: don't update sb journal_devnum when RO dev
This commit is contained in:
Linus Torvalds
commit
40c73abbb3
|
|
@ -28,21 +28,30 @@
|
|||
|
||||
typedef struct ext2_dir_entry_2 ext2_dirent;
|
||||
|
||||
/*
|
||||
* Tests against MAX_REC_LEN etc were put in place for 64k block
|
||||
* sizes; if that is not possible on this arch, we can skip
|
||||
* those tests and speed things up.
|
||||
*/
|
||||
static inline unsigned ext2_rec_len_from_disk(__le16 dlen)
|
||||
{
|
||||
unsigned len = le16_to_cpu(dlen);
|
||||
|
||||
#if (PAGE_CACHE_SIZE >= 65536)
|
||||
if (len == EXT2_MAX_REC_LEN)
|
||||
return 1 << 16;
|
||||
#endif
|
||||
return len;
|
||||
}
|
||||
|
||||
static inline __le16 ext2_rec_len_to_disk(unsigned len)
|
||||
{
|
||||
#if (PAGE_CACHE_SIZE >= 65536)
|
||||
if (len == (1 << 16))
|
||||
return cpu_to_le16(EXT2_MAX_REC_LEN);
|
||||
else
|
||||
BUG_ON(len > (1 << 16));
|
||||
#endif
|
||||
return cpu_to_le16(len);
|
||||
}
|
||||
|
||||
|
|
@ -129,15 +138,15 @@ static void ext2_check_page(struct page *page, int quiet)
|
|||
p = (ext2_dirent *)(kaddr + offs);
|
||||
rec_len = ext2_rec_len_from_disk(p->rec_len);
|
||||
|
||||
if (rec_len < EXT2_DIR_REC_LEN(1))
|
||||
if (unlikely(rec_len < EXT2_DIR_REC_LEN(1)))
|
||||
goto Eshort;
|
||||
if (rec_len & 3)
|
||||
if (unlikely(rec_len & 3))
|
||||
goto Ealign;
|
||||
if (rec_len < EXT2_DIR_REC_LEN(p->name_len))
|
||||
if (unlikely(rec_len < EXT2_DIR_REC_LEN(p->name_len)))
|
||||
goto Enamelen;
|
||||
if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
|
||||
if (unlikely(((offs + rec_len - 1) ^ offs) & ~(chunk_size-1)))
|
||||
goto Espan;
|
||||
if (le32_to_cpu(p->inode) > max_inumber)
|
||||
if (unlikely(le32_to_cpu(p->inode) > max_inumber))
|
||||
goto Einumber;
|
||||
}
|
||||
if (offs != limit)
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, str
|
|||
inode = NULL;
|
||||
if (ino) {
|
||||
inode = ext2_iget(dir->i_sb, ino);
|
||||
if (unlikely(IS_ERR(inode))) {
|
||||
if (IS_ERR(inode)) {
|
||||
if (PTR_ERR(inode) == -ESTALE) {
|
||||
ext2_error(dir->i_sb, __func__,
|
||||
"deleted inode referenced: %lu",
|
||||
|
|
|
|||
|
|
@ -43,9 +43,10 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data);
|
|||
static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
|
||||
static int ext2_sync_fs(struct super_block *sb, int wait);
|
||||
|
||||
void ext2_error (struct super_block * sb, const char * function,
|
||||
const char * fmt, ...)
|
||||
void ext2_error(struct super_block *sb, const char *function,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
struct ext2_sb_info *sbi = EXT2_SB(sb);
|
||||
struct ext2_super_block *es = sbi->s_es;
|
||||
|
|
@ -59,9 +60,13 @@ void ext2_error (struct super_block * sb, const char * function,
|
|||
}
|
||||
|
||||
va_start(args, fmt);
|
||||
printk(KERN_CRIT "EXT2-fs (%s): error: %s: ", sb->s_id, function);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk(KERN_CRIT "EXT2-fs (%s): error: %s: %pV\n",
|
||||
sb->s_id, function, &vaf);
|
||||
|
||||
va_end(args);
|
||||
|
||||
if (test_opt(sb, ERRORS_PANIC))
|
||||
|
|
@ -76,12 +81,16 @@ void ext2_error (struct super_block * sb, const char * function,
|
|||
void ext2_msg(struct super_block *sb, const char *prefix,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk("%sEXT2-fs (%s): ", prefix, sb->s_id);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk("%sEXT2-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
|
|
|
|||
266
fs/ext3/balloc.c
266
fs/ext3/balloc.c
|
|
@ -20,6 +20,7 @@
|
|||
#include <linux/ext3_jbd.h>
|
||||
#include <linux/quotaops.h>
|
||||
#include <linux/buffer_head.h>
|
||||
#include <linux/blkdev.h>
|
||||
|
||||
/*
|
||||
* balloc.c contains the blocks allocation and deallocation routines
|
||||
|
|
@ -39,6 +40,21 @@
|
|||
|
||||
#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1)
|
||||
|
||||
/*
|
||||
* Calculate the block group number and offset, given a block number
|
||||
*/
|
||||
static void ext3_get_group_no_and_offset(struct super_block *sb,
|
||||
ext3_fsblk_t blocknr, unsigned long *blockgrpp, ext3_grpblk_t *offsetp)
|
||||
{
|
||||
struct ext3_super_block *es = EXT3_SB(sb)->s_es;
|
||||
|
||||
blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
|
||||
if (offsetp)
|
||||
*offsetp = blocknr % EXT3_BLOCKS_PER_GROUP(sb);
|
||||
if (blockgrpp)
|
||||
*blockgrpp = blocknr / EXT3_BLOCKS_PER_GROUP(sb);
|
||||
}
|
||||
|
||||
/**
|
||||
* ext3_get_group_desc() -- load group descriptor from disk
|
||||
* @sb: super block
|
||||
|
|
@ -1885,3 +1901,253 @@ unsigned long ext3_bg_num_gdb(struct super_block *sb, int group)
|
|||
return ext3_bg_num_gdb_meta(sb,group);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* ext3_trim_all_free -- function to trim all free space in alloc. group
|
||||
* @sb: super block for file system
|
||||
* @group: allocation group to trim
|
||||
* @start: first group block to examine
|
||||
* @max: last group block to examine
|
||||
* @gdp: allocation group description structure
|
||||
* @minblocks: minimum extent block count
|
||||
*
|
||||
* ext3_trim_all_free walks through group's block bitmap searching for free
|
||||
* blocks. When the free block is found, it tries to allocate this block and
|
||||
* consequent free block to get the biggest free extent possible, until it
|
||||
* reaches any used block. Then issue a TRIM command on this extent and free
|
||||
* the extent in the block bitmap. This is done until whole group is scanned.
|
||||
*/
|
||||
ext3_grpblk_t ext3_trim_all_free(struct super_block *sb, unsigned int group,
|
||||
ext3_grpblk_t start, ext3_grpblk_t max,
|
||||
ext3_grpblk_t minblocks)
|
||||
{
|
||||
handle_t *handle;
|
||||
ext3_grpblk_t next, free_blocks, bit, freed, count = 0;
|
||||
ext3_fsblk_t discard_block;
|
||||
struct ext3_sb_info *sbi;
|
||||
struct buffer_head *gdp_bh, *bitmap_bh = NULL;
|
||||
struct ext3_group_desc *gdp;
|
||||
int err = 0, ret = 0;
|
||||
|
||||
/*
|
||||
* We will update one block bitmap, and one group descriptor
|
||||
*/
|
||||
handle = ext3_journal_start_sb(sb, 2);
|
||||
if (IS_ERR(handle))
|
||||
return PTR_ERR(handle);
|
||||
|
||||
bitmap_bh = read_block_bitmap(sb, group);
|
||||
if (!bitmap_bh) {
|
||||
err = -EIO;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
BUFFER_TRACE(bitmap_bh, "getting undo access");
|
||||
err = ext3_journal_get_undo_access(handle, bitmap_bh);
|
||||
if (err)
|
||||
goto err_out;
|
||||
|
||||
gdp = ext3_get_group_desc(sb, group, &gdp_bh);
|
||||
if (!gdp) {
|
||||
err = -EIO;
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
BUFFER_TRACE(gdp_bh, "get_write_access");
|
||||
err = ext3_journal_get_write_access(handle, gdp_bh);
|
||||
if (err)
|
||||
goto err_out;
|
||||
|
||||
free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
|
||||
sbi = EXT3_SB(sb);
|
||||
|
||||
/* Walk through the whole group */
|
||||
while (start < max) {
|
||||
start = bitmap_search_next_usable_block(start, bitmap_bh, max);
|
||||
if (start < 0)
|
||||
break;
|
||||
next = start;
|
||||
|
||||
/*
|
||||
* Allocate contiguous free extents by setting bits in the
|
||||
* block bitmap
|
||||
*/
|
||||
while (next < max
|
||||
&& claim_block(sb_bgl_lock(sbi, group),
|
||||
next, bitmap_bh)) {
|
||||
next++;
|
||||
}
|
||||
|
||||
/* We did not claim any blocks */
|
||||
if (next == start)
|
||||
continue;
|
||||
|
||||
discard_block = (ext3_fsblk_t)start +
|
||||
ext3_group_first_block_no(sb, group);
|
||||
|
||||
/* Update counters */
|
||||
spin_lock(sb_bgl_lock(sbi, group));
|
||||
le16_add_cpu(&gdp->bg_free_blocks_count, start - next);
|
||||
spin_unlock(sb_bgl_lock(sbi, group));
|
||||
percpu_counter_sub(&sbi->s_freeblocks_counter, next - start);
|
||||
|
||||
/* Do not issue a TRIM on extents smaller than minblocks */
|
||||
if ((next - start) < minblocks)
|
||||
goto free_extent;
|
||||
|
||||
/* Send the TRIM command down to the device */
|
||||
err = sb_issue_discard(sb, discard_block, next - start,
|
||||
GFP_NOFS, 0);
|
||||
count += (next - start);
|
||||
free_extent:
|
||||
freed = 0;
|
||||
|
||||
/*
|
||||
* Clear bits in the bitmap
|
||||
*/
|
||||
for (bit = start; bit < next; bit++) {
|
||||
BUFFER_TRACE(bitmap_bh, "clear bit");
|
||||
if (!ext3_clear_bit_atomic(sb_bgl_lock(sbi, group),
|
||||
bit, bitmap_bh->b_data)) {
|
||||
ext3_error(sb, __func__,
|
||||
"bit already cleared for block "E3FSBLK,
|
||||
(unsigned long)bit);
|
||||
BUFFER_TRACE(bitmap_bh, "bit already cleared");
|
||||
} else {
|
||||
freed++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Update couters */
|
||||
spin_lock(sb_bgl_lock(sbi, group));
|
||||
le16_add_cpu(&gdp->bg_free_blocks_count, freed);
|
||||
spin_unlock(sb_bgl_lock(sbi, group));
|
||||
percpu_counter_add(&sbi->s_freeblocks_counter, freed);
|
||||
|
||||
start = next;
|
||||
if (err < 0) {
|
||||
if (err != -EOPNOTSUPP)
|
||||
ext3_warning(sb, __func__, "Discard command "
|
||||
"returned error %d\n", err);
|
||||
break;
|
||||
}
|
||||
|
||||
if (fatal_signal_pending(current)) {
|
||||
err = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
|
||||
cond_resched();
|
||||
|
||||
/* No more suitable extents */
|
||||
if ((free_blocks - count) < minblocks)
|
||||
break;
|
||||
}
|
||||
|
||||
/* We dirtied the bitmap block */
|
||||
BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
|
||||
ret = ext3_journal_dirty_metadata(handle, bitmap_bh);
|
||||
if (!err)
|
||||
err = ret;
|
||||
|
||||
/* And the group descriptor block */
|
||||
BUFFER_TRACE(gdp_bh, "dirtied group descriptor block");
|
||||
ret = ext3_journal_dirty_metadata(handle, gdp_bh);
|
||||
if (!err)
|
||||
err = ret;
|
||||
|
||||
ext3_debug("trimmed %d blocks in the group %d\n",
|
||||
count, group);
|
||||
|
||||
err_out:
|
||||
if (err)
|
||||
count = err;
|
||||
ext3_journal_stop(handle);
|
||||
brelse(bitmap_bh);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* ext3_trim_fs() -- trim ioctl handle function
|
||||
* @sb: superblock for filesystem
|
||||
* @start: First Byte to trim
|
||||
* @len: number of Bytes to trim from start
|
||||
* @minlen: minimum extent length in Bytes
|
||||
*
|
||||
* ext3_trim_fs goes through all allocation groups containing Bytes from
|
||||
* start to start+len. For each such a group ext3_trim_all_free function
|
||||
* is invoked to trim all free space.
|
||||
*/
|
||||
int ext3_trim_fs(struct super_block *sb, struct fstrim_range *range)
|
||||
{
|
||||
ext3_grpblk_t last_block, first_block, free_blocks;
|
||||
unsigned long first_group, last_group;
|
||||
unsigned long group, ngroups;
|
||||
struct ext3_group_desc *gdp;
|
||||
struct ext3_super_block *es = EXT3_SB(sb)->s_es;
|
||||
uint64_t start, len, minlen, trimmed;
|
||||
ext3_fsblk_t max_blks = le32_to_cpu(es->s_blocks_count);
|
||||
int ret = 0;
|
||||
|
||||
start = range->start >> sb->s_blocksize_bits;
|
||||
len = range->len >> sb->s_blocksize_bits;
|
||||
minlen = range->minlen >> sb->s_blocksize_bits;
|
||||
trimmed = 0;
|
||||
|
||||
if (unlikely(minlen > EXT3_BLOCKS_PER_GROUP(sb)))
|
||||
return -EINVAL;
|
||||
if (start >= max_blks)
|
||||
goto out;
|
||||
if (start < le32_to_cpu(es->s_first_data_block)) {
|
||||
len -= le32_to_cpu(es->s_first_data_block) - start;
|
||||
start = le32_to_cpu(es->s_first_data_block);
|
||||
}
|
||||
if (start + len > max_blks)
|
||||
len = max_blks - start;
|
||||
|
||||
ngroups = EXT3_SB(sb)->s_groups_count;
|
||||
smp_rmb();
|
||||
|
||||
/* Determine first and last group to examine based on start and len */
|
||||
ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) start,
|
||||
&first_group, &first_block);
|
||||
ext3_get_group_no_and_offset(sb, (ext3_fsblk_t) (start + len),
|
||||
&last_group, &last_block);
|
||||
last_group = (last_group > ngroups - 1) ? ngroups - 1 : last_group;
|
||||
last_block = EXT3_BLOCKS_PER_GROUP(sb);
|
||||
|
||||
if (first_group > last_group)
|
||||
return -EINVAL;
|
||||
|
||||
for (group = first_group; group <= last_group; group++) {
|
||||
gdp = ext3_get_group_desc(sb, group, NULL);
|
||||
if (!gdp)
|
||||
break;
|
||||
|
||||
free_blocks = le16_to_cpu(gdp->bg_free_blocks_count);
|
||||
if (free_blocks < minlen)
|
||||
continue;
|
||||
|
||||
if (len >= EXT3_BLOCKS_PER_GROUP(sb))
|
||||
len -= (EXT3_BLOCKS_PER_GROUP(sb) - first_block);
|
||||
else
|
||||
last_block = first_block + len;
|
||||
|
||||
ret = ext3_trim_all_free(sb, group, first_block,
|
||||
last_block, minlen);
|
||||
if (ret < 0)
|
||||
break;
|
||||
|
||||
trimmed += ret;
|
||||
first_block = 0;
|
||||
}
|
||||
|
||||
if (ret >= 0)
|
||||
ret = 0;
|
||||
|
||||
out:
|
||||
range->len = trimmed * sb->s_blocksize;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -69,25 +69,26 @@ int ext3_check_dir_entry (const char * function, struct inode * dir,
|
|||
const char * error_msg = NULL;
|
||||
const int rlen = ext3_rec_len_from_disk(de->rec_len);
|
||||
|
||||
if (rlen < EXT3_DIR_REC_LEN(1))
|
||||
if (unlikely(rlen < EXT3_DIR_REC_LEN(1)))
|
||||
error_msg = "rec_len is smaller than minimal";
|
||||
else if (rlen % 4 != 0)
|
||||
else if (unlikely(rlen % 4 != 0))
|
||||
error_msg = "rec_len % 4 != 0";
|
||||
else if (rlen < EXT3_DIR_REC_LEN(de->name_len))
|
||||
else if (unlikely(rlen < EXT3_DIR_REC_LEN(de->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 (unlikely((((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)))
|
||||
error_msg = "directory entry across blocks";
|
||||
else if (le32_to_cpu(de->inode) >
|
||||
le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count))
|
||||
else if (unlikely(le32_to_cpu(de->inode) >
|
||||
le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count)))
|
||||
error_msg = "inode out of bounds";
|
||||
|
||||
if (error_msg != NULL)
|
||||
if (unlikely(error_msg != NULL))
|
||||
ext3_error (dir->i_sb, function,
|
||||
"bad entry in directory #%lu: %s - "
|
||||
"offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
|
||||
dir->i_ino, error_msg, offset,
|
||||
(unsigned long) le32_to_cpu(de->inode),
|
||||
rlen, de->name_len);
|
||||
|
||||
return error_msg == NULL ? 1 : 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2145,13 +2145,15 @@ static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
|
|||
if (try_to_extend_transaction(handle, inode)) {
|
||||
if (bh) {
|
||||
BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
|
||||
ext3_journal_dirty_metadata(handle, bh);
|
||||
if (ext3_journal_dirty_metadata(handle, bh))
|
||||
return;
|
||||
}
|
||||
ext3_mark_inode_dirty(handle, inode);
|
||||
truncate_restart_transaction(handle, inode);
|
||||
if (bh) {
|
||||
BUFFER_TRACE(bh, "retaking write access");
|
||||
ext3_journal_get_write_access(handle, bh);
|
||||
if (ext3_journal_get_write_access(handle, bh))
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -276,7 +276,29 @@ group_add_out:
|
|||
mnt_drop_write(filp->f_path.mnt);
|
||||
return err;
|
||||
}
|
||||
case FITRIM: {
|
||||
|
||||
struct super_block *sb = inode->i_sb;
|
||||
struct fstrim_range range;
|
||||
int ret = 0;
|
||||
|
||||
if (!capable(CAP_SYS_ADMIN))
|
||||
return -EPERM;
|
||||
|
||||
if (copy_from_user(&range, (struct fstrim_range *)arg,
|
||||
sizeof(range)))
|
||||
return -EFAULT;
|
||||
|
||||
ret = ext3_trim_fs(sb, &range);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (copy_to_user((struct fstrim_range *)arg, &range,
|
||||
sizeof(range)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
default:
|
||||
return -ENOTTY;
|
||||
|
|
|
|||
138
fs/ext3/namei.c
138
fs/ext3/namei.c
|
|
@ -858,6 +858,7 @@ static struct buffer_head *ext3_find_entry(struct inode *dir,
|
|||
struct buffer_head * bh_use[NAMEI_RA_SIZE];
|
||||
struct buffer_head * bh, *ret = NULL;
|
||||
unsigned long start, block, b;
|
||||
const u8 *name = entry->name;
|
||||
int ra_max = 0; /* Number of bh's in the readahead
|
||||
buffer, bh_use[] */
|
||||
int ra_ptr = 0; /* Current index into readahead
|
||||
|
|
@ -871,6 +872,16 @@ static struct buffer_head *ext3_find_entry(struct inode *dir,
|
|||
namelen = entry->len;
|
||||
if (namelen > EXT3_NAME_LEN)
|
||||
return NULL;
|
||||
if ((namelen <= 2) && (name[0] == '.') &&
|
||||
(name[1] == '.' || name[1] == 0)) {
|
||||
/*
|
||||
* "." or ".." will only be in the first block
|
||||
* NFS may look up ".."; "." should be handled by the VFS
|
||||
*/
|
||||
block = start = 0;
|
||||
nblocks = 1;
|
||||
goto restart;
|
||||
}
|
||||
if (is_dx(dir)) {
|
||||
bh = ext3_dx_find_entry(dir, entry, res_dir, &err);
|
||||
/*
|
||||
|
|
@ -961,55 +972,35 @@ static struct buffer_head * ext3_dx_find_entry(struct inode *dir,
|
|||
struct qstr *entry, struct ext3_dir_entry_2 **res_dir,
|
||||
int *err)
|
||||
{
|
||||
struct super_block * sb;
|
||||
struct super_block *sb = dir->i_sb;
|
||||
struct dx_hash_info hinfo;
|
||||
u32 hash;
|
||||
struct dx_frame frames[2], *frame;
|
||||
struct ext3_dir_entry_2 *de, *top;
|
||||
struct buffer_head *bh;
|
||||
unsigned long block;
|
||||
int retval;
|
||||
int namelen = entry->len;
|
||||
const u8 *name = entry->name;
|
||||
|
||||
sb = dir->i_sb;
|
||||
/* NFS may look up ".." - look at dx_root directory block */
|
||||
if (namelen > 2 || name[0] != '.'|| (namelen == 2 && name[1] != '.')) {
|
||||
if (!(frame = dx_probe(entry, dir, &hinfo, frames, err)))
|
||||
return NULL;
|
||||
} else {
|
||||
frame = frames;
|
||||
frame->bh = NULL; /* for dx_release() */
|
||||
frame->at = (struct dx_entry *)frames; /* hack for zero entry*/
|
||||
dx_set_block(frame->at, 0); /* dx_root block is 0 */
|
||||
}
|
||||
hash = hinfo.hash;
|
||||
if (!(frame = dx_probe(entry, dir, &hinfo, frames, err)))
|
||||
return NULL;
|
||||
do {
|
||||
block = dx_get_block(frame->at);
|
||||
if (!(bh = ext3_bread (NULL,dir, block, 0, err)))
|
||||
goto errout;
|
||||
de = (struct ext3_dir_entry_2 *) bh->b_data;
|
||||
top = (struct ext3_dir_entry_2 *) ((char *) de + sb->s_blocksize -
|
||||
EXT3_DIR_REC_LEN(0));
|
||||
for (; de < top; de = ext3_next_entry(de)) {
|
||||
int off = (block << EXT3_BLOCK_SIZE_BITS(sb))
|
||||
+ ((char *) de - bh->b_data);
|
||||
|
||||
if (!ext3_check_dir_entry(__func__, dir, de, bh, off)) {
|
||||
brelse(bh);
|
||||
*err = ERR_BAD_DX_DIR;
|
||||
goto errout;
|
||||
}
|
||||
|
||||
if (ext3_match(namelen, name, de)) {
|
||||
*res_dir = de;
|
||||
dx_release(frames);
|
||||
return bh;
|
||||
}
|
||||
retval = search_dirblock(bh, dir, entry,
|
||||
block << EXT3_BLOCK_SIZE_BITS(sb),
|
||||
res_dir);
|
||||
if (retval == 1) {
|
||||
dx_release(frames);
|
||||
return bh;
|
||||
}
|
||||
brelse (bh);
|
||||
brelse(bh);
|
||||
if (retval == -1) {
|
||||
*err = ERR_BAD_DX_DIR;
|
||||
goto errout;
|
||||
}
|
||||
|
||||
/* Check to see if we should continue to search */
|
||||
retval = ext3_htree_next_block(dir, hash, frame,
|
||||
retval = ext3_htree_next_block(dir, hinfo.hash, frame,
|
||||
frames, NULL);
|
||||
if (retval < 0) {
|
||||
ext3_warning(sb, __func__,
|
||||
|
|
@ -1047,7 +1038,7 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
|
|||
return ERR_PTR(-EIO);
|
||||
}
|
||||
inode = ext3_iget(dir->i_sb, ino);
|
||||
if (unlikely(IS_ERR(inode))) {
|
||||
if (IS_ERR(inode)) {
|
||||
if (PTR_ERR(inode) == -ESTALE) {
|
||||
ext3_error(dir->i_sb, __func__,
|
||||
"deleted inode referenced: %lu",
|
||||
|
|
@ -1607,7 +1598,9 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
|
|||
if (err)
|
||||
goto journal_error;
|
||||
}
|
||||
ext3_journal_dirty_metadata(handle, frames[0].bh);
|
||||
err = ext3_journal_dirty_metadata(handle, frames[0].bh);
|
||||
if (err)
|
||||
goto journal_error;
|
||||
}
|
||||
de = do_split(handle, dir, &bh, frame, &hinfo, &err);
|
||||
if (!de)
|
||||
|
|
@ -1644,8 +1637,13 @@ static int ext3_delete_entry (handle_t *handle,
|
|||
if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i))
|
||||
return -EIO;
|
||||
if (de == de_del) {
|
||||
int err;
|
||||
|
||||
BUFFER_TRACE(bh, "get_write_access");
|
||||
ext3_journal_get_write_access(handle, bh);
|
||||
err = ext3_journal_get_write_access(handle, bh);
|
||||
if (err)
|
||||
goto journal_error;
|
||||
|
||||
if (pde)
|
||||
pde->rec_len = ext3_rec_len_to_disk(
|
||||
ext3_rec_len_from_disk(pde->rec_len) +
|
||||
|
|
@ -1654,7 +1652,12 @@ static int ext3_delete_entry (handle_t *handle,
|
|||
de->inode = 0;
|
||||
dir->i_version++;
|
||||
BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata");
|
||||
ext3_journal_dirty_metadata(handle, bh);
|
||||
err = ext3_journal_dirty_metadata(handle, bh);
|
||||
if (err) {
|
||||
journal_error:
|
||||
ext3_std_error(dir->i_sb, err);
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
i += ext3_rec_len_from_disk(de->rec_len);
|
||||
|
|
@ -1762,7 +1765,7 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
|
|||
{
|
||||
handle_t *handle;
|
||||
struct inode * inode;
|
||||
struct buffer_head * dir_block;
|
||||
struct buffer_head * dir_block = NULL;
|
||||
struct ext3_dir_entry_2 * de;
|
||||
int err, retries = 0;
|
||||
|
||||
|
|
@ -1790,15 +1793,14 @@ retry:
|
|||
inode->i_fop = &ext3_dir_operations;
|
||||
inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize;
|
||||
dir_block = ext3_bread (handle, inode, 0, 1, &err);
|
||||
if (!dir_block) {
|
||||
drop_nlink(inode); /* is this nlink == 0? */
|
||||
unlock_new_inode(inode);
|
||||
ext3_mark_inode_dirty(handle, inode);
|
||||
iput (inode);
|
||||
goto out_stop;
|
||||
}
|
||||
if (!dir_block)
|
||||
goto out_clear_inode;
|
||||
|
||||
BUFFER_TRACE(dir_block, "get_write_access");
|
||||
ext3_journal_get_write_access(handle, dir_block);
|
||||
err = ext3_journal_get_write_access(handle, dir_block);
|
||||
if (err)
|
||||
goto out_clear_inode;
|
||||
|
||||
de = (struct ext3_dir_entry_2 *) dir_block->b_data;
|
||||
de->inode = cpu_to_le32(inode->i_ino);
|
||||
de->name_len = 1;
|
||||
|
|
@ -1814,11 +1816,16 @@ retry:
|
|||
ext3_set_de_type(dir->i_sb, de, S_IFDIR);
|
||||
inode->i_nlink = 2;
|
||||
BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata");
|
||||
ext3_journal_dirty_metadata(handle, dir_block);
|
||||
brelse (dir_block);
|
||||
ext3_mark_inode_dirty(handle, inode);
|
||||
err = ext3_add_entry (handle, dentry, inode);
|
||||
err = ext3_journal_dirty_metadata(handle, dir_block);
|
||||
if (err)
|
||||
goto out_clear_inode;
|
||||
|
||||
err = ext3_mark_inode_dirty(handle, inode);
|
||||
if (!err)
|
||||
err = ext3_add_entry (handle, dentry, inode);
|
||||
|
||||
if (err) {
|
||||
out_clear_inode:
|
||||
inode->i_nlink = 0;
|
||||
unlock_new_inode(inode);
|
||||
ext3_mark_inode_dirty(handle, inode);
|
||||
|
|
@ -1827,10 +1834,14 @@ retry:
|
|||
}
|
||||
inc_nlink(dir);
|
||||
ext3_update_dx_flag(dir);
|
||||
ext3_mark_inode_dirty(handle, dir);
|
||||
err = ext3_mark_inode_dirty(handle, dir);
|
||||
if (err)
|
||||
goto out_clear_inode;
|
||||
|
||||
d_instantiate(dentry, inode);
|
||||
unlock_new_inode(inode);
|
||||
out_stop:
|
||||
brelse(dir_block);
|
||||
ext3_journal_stop(handle);
|
||||
if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries))
|
||||
goto retry;
|
||||
|
|
@ -2353,7 +2364,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
|
|||
goto end_rename;
|
||||
} else {
|
||||
BUFFER_TRACE(new_bh, "get write access");
|
||||
ext3_journal_get_write_access(handle, new_bh);
|
||||
retval = ext3_journal_get_write_access(handle, new_bh);
|
||||
if (retval)
|
||||
goto journal_error;
|
||||
new_de->inode = cpu_to_le32(old_inode->i_ino);
|
||||
if (EXT3_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
|
||||
EXT3_FEATURE_INCOMPAT_FILETYPE))
|
||||
|
|
@ -2362,7 +2375,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
|
|||
new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME_SEC;
|
||||
ext3_mark_inode_dirty(handle, new_dir);
|
||||
BUFFER_TRACE(new_bh, "call ext3_journal_dirty_metadata");
|
||||
ext3_journal_dirty_metadata(handle, new_bh);
|
||||
retval = ext3_journal_dirty_metadata(handle, new_bh);
|
||||
if (retval)
|
||||
goto journal_error;
|
||||
brelse(new_bh);
|
||||
new_bh = NULL;
|
||||
}
|
||||
|
|
@ -2411,10 +2426,17 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
|
|||
ext3_update_dx_flag(old_dir);
|
||||
if (dir_bh) {
|
||||
BUFFER_TRACE(dir_bh, "get_write_access");
|
||||
ext3_journal_get_write_access(handle, dir_bh);
|
||||
retval = ext3_journal_get_write_access(handle, dir_bh);
|
||||
if (retval)
|
||||
goto journal_error;
|
||||
PARENT_INO(dir_bh->b_data) = cpu_to_le32(new_dir->i_ino);
|
||||
BUFFER_TRACE(dir_bh, "call ext3_journal_dirty_metadata");
|
||||
ext3_journal_dirty_metadata(handle, dir_bh);
|
||||
retval = ext3_journal_dirty_metadata(handle, dir_bh);
|
||||
if (retval) {
|
||||
journal_error:
|
||||
ext3_std_error(new_dir->i_sb, retval);
|
||||
goto end_rename;
|
||||
}
|
||||
drop_nlink(old_dir);
|
||||
if (new_inode) {
|
||||
drop_nlink(new_inode);
|
||||
|
|
|
|||
|
|
@ -249,7 +249,11 @@ static int setup_new_group_blocks(struct super_block *sb,
|
|||
memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size);
|
||||
set_buffer_uptodate(gdb);
|
||||
unlock_buffer(gdb);
|
||||
ext3_journal_dirty_metadata(handle, gdb);
|
||||
err = ext3_journal_dirty_metadata(handle, gdb);
|
||||
if (err) {
|
||||
brelse(gdb);
|
||||
goto exit_bh;
|
||||
}
|
||||
ext3_set_bit(bit, bh->b_data);
|
||||
brelse(gdb);
|
||||
}
|
||||
|
|
@ -269,7 +273,11 @@ static int setup_new_group_blocks(struct super_block *sb,
|
|||
err = PTR_ERR(gdb);
|
||||
goto exit_bh;
|
||||
}
|
||||
ext3_journal_dirty_metadata(handle, gdb);
|
||||
err = ext3_journal_dirty_metadata(handle, gdb);
|
||||
if (err) {
|
||||
brelse(gdb);
|
||||
goto exit_bh;
|
||||
}
|
||||
ext3_set_bit(bit, bh->b_data);
|
||||
brelse(gdb);
|
||||
}
|
||||
|
|
@ -295,7 +303,11 @@ static int setup_new_group_blocks(struct super_block *sb,
|
|||
err = PTR_ERR(it);
|
||||
goto exit_bh;
|
||||
}
|
||||
ext3_journal_dirty_metadata(handle, it);
|
||||
err = ext3_journal_dirty_metadata(handle, it);
|
||||
if (err) {
|
||||
brelse(it);
|
||||
goto exit_bh;
|
||||
}
|
||||
brelse(it);
|
||||
ext3_set_bit(bit, bh->b_data);
|
||||
}
|
||||
|
|
@ -306,7 +318,9 @@ static int setup_new_group_blocks(struct super_block *sb,
|
|||
|
||||
mark_bitmap_end(input->blocks_count, EXT3_BLOCKS_PER_GROUP(sb),
|
||||
bh->b_data);
|
||||
ext3_journal_dirty_metadata(handle, bh);
|
||||
err = ext3_journal_dirty_metadata(handle, bh);
|
||||
if (err)
|
||||
goto exit_bh;
|
||||
brelse(bh);
|
||||
|
||||
/* Mark unused entries in inode bitmap used */
|
||||
|
|
@ -319,7 +333,7 @@ static int setup_new_group_blocks(struct super_block *sb,
|
|||
|
||||
mark_bitmap_end(EXT3_INODES_PER_GROUP(sb), EXT3_BLOCKS_PER_GROUP(sb),
|
||||
bh->b_data);
|
||||
ext3_journal_dirty_metadata(handle, bh);
|
||||
err = ext3_journal_dirty_metadata(handle, bh);
|
||||
exit_bh:
|
||||
brelse(bh);
|
||||
|
||||
|
|
@ -503,12 +517,19 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
|
|||
* reserved inode, and will become GDT blocks (primary and backup).
|
||||
*/
|
||||
data[gdb_num % EXT3_ADDR_PER_BLOCK(sb)] = 0;
|
||||
ext3_journal_dirty_metadata(handle, dind);
|
||||
err = ext3_journal_dirty_metadata(handle, dind);
|
||||
if (err)
|
||||
goto exit_group_desc;
|
||||
brelse(dind);
|
||||
dind = NULL;
|
||||
inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
|
||||
ext3_mark_iloc_dirty(handle, inode, &iloc);
|
||||
err = ext3_mark_iloc_dirty(handle, inode, &iloc);
|
||||
if (err)
|
||||
goto exit_group_desc;
|
||||
memset((*primary)->b_data, 0, sb->s_blocksize);
|
||||
ext3_journal_dirty_metadata(handle, *primary);
|
||||
err = ext3_journal_dirty_metadata(handle, *primary);
|
||||
if (err)
|
||||
goto exit_group_desc;
|
||||
|
||||
o_group_desc = EXT3_SB(sb)->s_group_desc;
|
||||
memcpy(n_group_desc, o_group_desc,
|
||||
|
|
@ -519,10 +540,14 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
|
|||
kfree(o_group_desc);
|
||||
|
||||
le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
|
||||
ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
|
||||
err = ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
|
||||
if (err)
|
||||
goto exit_inode;
|
||||
|
||||
return 0;
|
||||
|
||||
exit_group_desc:
|
||||
kfree(n_group_desc);
|
||||
exit_inode:
|
||||
//ext3_journal_release_buffer(handle, iloc.bh);
|
||||
brelse(iloc.bh);
|
||||
|
|
@ -706,16 +731,20 @@ static void update_backups(struct super_block *sb,
|
|||
}
|
||||
ext3_debug("update metadata backup %#04lx\n",
|
||||
(unsigned long)bh->b_blocknr);
|
||||
if ((err = ext3_journal_get_write_access(handle, bh)))
|
||||
if ((err = ext3_journal_get_write_access(handle, bh))) {
|
||||
brelse(bh);
|
||||
break;
|
||||
}
|
||||
lock_buffer(bh);
|
||||
memcpy(bh->b_data, data, size);
|
||||
if (rest)
|
||||
memset(bh->b_data + size, 0, rest);
|
||||
set_buffer_uptodate(bh);
|
||||
unlock_buffer(bh);
|
||||
ext3_journal_dirty_metadata(handle, bh);
|
||||
err = ext3_journal_dirty_metadata(handle, bh);
|
||||
brelse(bh);
|
||||
if (err)
|
||||
break;
|
||||
}
|
||||
if ((err2 = ext3_journal_stop(handle)) && !err)
|
||||
err = err2;
|
||||
|
|
@ -922,7 +951,9 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
|
|||
/* Update the global fs size fields */
|
||||
sbi->s_groups_count++;
|
||||
|
||||
ext3_journal_dirty_metadata(handle, primary);
|
||||
err = ext3_journal_dirty_metadata(handle, primary);
|
||||
if (err)
|
||||
goto exit_journal;
|
||||
|
||||
/* Update the reserved block counts only once the new group is
|
||||
* active. */
|
||||
|
|
@ -934,7 +965,7 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
|
|||
percpu_counter_add(&sbi->s_freeinodes_counter,
|
||||
EXT3_INODES_PER_GROUP(sb));
|
||||
|
||||
ext3_journal_dirty_metadata(handle, sbi->s_sbh);
|
||||
err = ext3_journal_dirty_metadata(handle, sbi->s_sbh);
|
||||
|
||||
exit_journal:
|
||||
mutex_unlock(&sbi->s_resize_lock);
|
||||
|
|
@ -1064,8 +1095,14 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
|
|||
goto exit_put;
|
||||
}
|
||||
es->s_blocks_count = cpu_to_le32(o_blocks_count + add);
|
||||
ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
|
||||
err = ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
|
||||
mutex_unlock(&EXT3_SB(sb)->s_resize_lock);
|
||||
if (err) {
|
||||
ext3_warning(sb, __func__,
|
||||
"error %d on journal dirty metadata", err);
|
||||
ext3_journal_stop(handle);
|
||||
goto exit_put;
|
||||
}
|
||||
ext3_debug("freeing blocks "E3FSBLK" through "E3FSBLK"\n",
|
||||
o_blocks_count, o_blocks_count + add);
|
||||
ext3_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);
|
||||
|
|
|
|||
|
|
@ -143,12 +143,16 @@ void ext3_journal_abort_handle(const char *caller, const char *err_fn,
|
|||
void ext3_msg(struct super_block *sb, const char *prefix,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk("%sEXT3-fs (%s): ", prefix, sb->s_id);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk("%sEXT3-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
|
|
@ -195,15 +199,20 @@ static void ext3_handle_error(struct super_block *sb)
|
|||
sb->s_id);
|
||||
}
|
||||
|
||||
void ext3_error (struct super_block * sb, const char * function,
|
||||
const char * fmt, ...)
|
||||
void ext3_error(struct super_block *sb, const char *function,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk(KERN_CRIT "EXT3-fs error (device %s): %s: %pV\n",
|
||||
sb->s_id, function, &vaf);
|
||||
|
||||
va_end(args);
|
||||
|
||||
ext3_handle_error(sb);
|
||||
|
|
@ -274,15 +283,20 @@ void __ext3_std_error (struct super_block * sb, const char * function,
|
|||
* case we take the easy way out and panic immediately.
|
||||
*/
|
||||
|
||||
void ext3_abort (struct super_block * sb, const char * function,
|
||||
const char * fmt, ...)
|
||||
void ext3_abort(struct super_block *sb, const char *function,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk(KERN_CRIT "EXT3-fs (%s): error: %s: ", sb->s_id, function);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk(KERN_CRIT "EXT3-fs (%s): error: %s: %pV\n",
|
||||
sb->s_id, function, &vaf);
|
||||
|
||||
va_end(args);
|
||||
|
||||
if (test_opt(sb, ERRORS_PANIC))
|
||||
|
|
@ -300,16 +314,20 @@ void ext3_abort (struct super_block * sb, const char * function,
|
|||
journal_abort(EXT3_SB(sb)->s_journal, -EIO);
|
||||
}
|
||||
|
||||
void ext3_warning (struct super_block * sb, const char * function,
|
||||
const char * fmt, ...)
|
||||
void ext3_warning(struct super_block *sb, const char *function,
|
||||
const char *fmt, ...)
|
||||
{
|
||||
struct va_format vaf;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk(KERN_WARNING "EXT3-fs (%s): warning: %s: ",
|
||||
sb->s_id, function);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk(KERN_WARNING "EXT3-fs (%s): warning: %s: %pV\n",
|
||||
sb->s_id, function, &vaf);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
|
|
@ -1848,13 +1866,15 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
|
|||
goto failed_mount;
|
||||
}
|
||||
|
||||
if (generic_check_addressable(sb->s_blocksize_bits,
|
||||
le32_to_cpu(es->s_blocks_count))) {
|
||||
err = generic_check_addressable(sb->s_blocksize_bits,
|
||||
le32_to_cpu(es->s_blocks_count));
|
||||
if (err) {
|
||||
ext3_msg(sb, KERN_ERR,
|
||||
"error: filesystem is too large to mount safely");
|
||||
if (sizeof(sector_t) < 8)
|
||||
ext3_msg(sb, KERN_ERR,
|
||||
"error: CONFIG_LBDAF not enabled");
|
||||
ret = err;
|
||||
goto failed_mount;
|
||||
}
|
||||
|
||||
|
|
@ -2297,7 +2317,7 @@ static int ext3_load_journal(struct super_block *sb,
|
|||
EXT3_SB(sb)->s_journal = journal;
|
||||
ext3_clear_journal_err(sb, es);
|
||||
|
||||
if (journal_devnum &&
|
||||
if (!really_read_only && journal_devnum &&
|
||||
journal_devnum != le32_to_cpu(es->s_journal_dev)) {
|
||||
es->s_journal_dev = cpu_to_le32(journal_devnum);
|
||||
|
||||
|
|
|
|||
12
fs/mbcache.c
12
fs/mbcache.c
|
|
@ -76,18 +76,6 @@ EXPORT_SYMBOL(mb_cache_entry_find_first);
|
|||
EXPORT_SYMBOL(mb_cache_entry_find_next);
|
||||
#endif
|
||||
|
||||
struct mb_cache {
|
||||
struct list_head c_cache_list;
|
||||
const char *c_name;
|
||||
atomic_t c_entry_count;
|
||||
int c_max_entries;
|
||||
int c_bucket_bits;
|
||||
struct kmem_cache *c_entry_cache;
|
||||
struct list_head *c_block_hash;
|
||||
struct list_head *c_index_hash;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Global data: list of all mbcache's, lru list, and a spinlock for
|
||||
* accessing cache data structures on SMP machines. The lru list is
|
||||
|
|
|
|||
|
|
@ -133,16 +133,20 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
|
|||
EXPORT_SYMBOL(dq_data_lock);
|
||||
|
||||
void __quota_error(struct super_block *sb, const char *func,
|
||||
const char *fmt, ...)
|
||||
const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
if (printk_ratelimit()) {
|
||||
va_list args;
|
||||
struct va_format vaf;
|
||||
|
||||
va_start(args, fmt);
|
||||
printk(KERN_ERR "Quota error (device %s): %s: ",
|
||||
sb->s_id, func);
|
||||
vprintk(fmt, args);
|
||||
printk("\n");
|
||||
|
||||
vaf.fmt = fmt;
|
||||
vaf.va = &args;
|
||||
|
||||
printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
|
||||
sb->s_id, func, &vaf);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -468,8 +468,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
|
|||
return -ENOMEM;
|
||||
ret = read_blk(info, *blk, buf);
|
||||
if (ret < 0) {
|
||||
quota_error(dquot->dq_sb, "Can't read quota data "
|
||||
"block %u", blk);
|
||||
quota_error(dquot->dq_sb, "Can't read quota data block %u",
|
||||
*blk);
|
||||
goto out_buf;
|
||||
}
|
||||
newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]);
|
||||
|
|
@ -493,8 +493,9 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
|
|||
} else {
|
||||
ret = write_blk(info, *blk, buf);
|
||||
if (ret < 0)
|
||||
quota_error(dquot->dq_sb, "Can't write quota "
|
||||
"tree block %u", blk);
|
||||
quota_error(dquot->dq_sb,
|
||||
"Can't write quota tree block %u",
|
||||
*blk);
|
||||
}
|
||||
}
|
||||
out_buf:
|
||||
|
|
|
|||
|
|
@ -724,21 +724,30 @@ struct ext3_dir_entry_2 {
|
|||
~EXT3_DIR_ROUND)
|
||||
#define EXT3_MAX_REC_LEN ((1<<16)-1)
|
||||
|
||||
/*
|
||||
* Tests against MAX_REC_LEN etc were put in place for 64k block
|
||||
* sizes; if that is not possible on this arch, we can skip
|
||||
* those tests and speed things up.
|
||||
*/
|
||||
static inline unsigned ext3_rec_len_from_disk(__le16 dlen)
|
||||
{
|
||||
unsigned len = le16_to_cpu(dlen);
|
||||
|
||||
#if (PAGE_CACHE_SIZE >= 65536)
|
||||
if (len == EXT3_MAX_REC_LEN)
|
||||
return 1 << 16;
|
||||
#endif
|
||||
return len;
|
||||
}
|
||||
|
||||
static inline __le16 ext3_rec_len_to_disk(unsigned len)
|
||||
{
|
||||
#if (PAGE_CACHE_SIZE >= 65536)
|
||||
if (len == (1 << 16))
|
||||
return cpu_to_le16(EXT3_MAX_REC_LEN);
|
||||
else if (len > (1 << 16))
|
||||
BUG();
|
||||
#endif
|
||||
return cpu_to_le16(len);
|
||||
}
|
||||
|
||||
|
|
@ -856,6 +865,7 @@ extern struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb,
|
|||
extern int ext3_should_retry_alloc(struct super_block *sb, int *retries);
|
||||
extern void ext3_init_block_alloc_info(struct inode *);
|
||||
extern void ext3_rsv_window_add(struct super_block *sb, struct ext3_reserve_window_node *rsv);
|
||||
extern int ext3_trim_fs(struct super_block *sb, struct fstrim_range *range);
|
||||
|
||||
/* dir.c */
|
||||
extern int ext3_check_dir_entry(const char *, struct inode *,
|
||||
|
|
|
|||
|
|
@ -18,6 +18,17 @@ struct mb_cache_entry {
|
|||
} e_index;
|
||||
};
|
||||
|
||||
struct mb_cache {
|
||||
struct list_head c_cache_list;
|
||||
const char *c_name;
|
||||
atomic_t c_entry_count;
|
||||
int c_max_entries;
|
||||
int c_bucket_bits;
|
||||
struct kmem_cache *c_entry_cache;
|
||||
struct list_head *c_block_hash;
|
||||
struct list_head *c_index_hash;
|
||||
};
|
||||
|
||||
/* Functions on caches */
|
||||
|
||||
struct mb_cache *mb_cache_create(const char *, int);
|
||||
|
|
|
|||
|
|
@ -31,8 +31,9 @@ static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
|
|||
#define quota_error(sb, fmt, args...) \
|
||||
__quota_error((sb), __func__, fmt , ## args)
|
||||
|
||||
extern void __quota_error(struct super_block *sb, const char *func,
|
||||
const char *fmt, ...);
|
||||
extern __attribute__((format (printf, 3, 4)))
|
||||
void __quota_error(struct super_block *sb, const char *func,
|
||||
const char *fmt, ...);
|
||||
|
||||
/*
|
||||
* declaration of quota_function calls in kernel.
|
||||
|
|
|
|||
Loading…
Reference in a new issue