Commit 40c73abb authored by Linus Torvalds's avatar Linus Torvalds

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
parents 0945f352 d96336b0
...@@ -28,21 +28,30 @@ ...@@ -28,21 +28,30 @@
typedef struct ext2_dir_entry_2 ext2_dirent; 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) static inline unsigned ext2_rec_len_from_disk(__le16 dlen)
{ {
unsigned len = le16_to_cpu(dlen); unsigned len = le16_to_cpu(dlen);
#if (PAGE_CACHE_SIZE >= 65536)
if (len == EXT2_MAX_REC_LEN) if (len == EXT2_MAX_REC_LEN)
return 1 << 16; return 1 << 16;
#endif
return len; return len;
} }
static inline __le16 ext2_rec_len_to_disk(unsigned len) static inline __le16 ext2_rec_len_to_disk(unsigned len)
{ {
#if (PAGE_CACHE_SIZE >= 65536)
if (len == (1 << 16)) if (len == (1 << 16))
return cpu_to_le16(EXT2_MAX_REC_LEN); return cpu_to_le16(EXT2_MAX_REC_LEN);
else else
BUG_ON(len > (1 << 16)); BUG_ON(len > (1 << 16));
#endif
return cpu_to_le16(len); return cpu_to_le16(len);
} }
...@@ -129,15 +138,15 @@ static void ext2_check_page(struct page *page, int quiet) ...@@ -129,15 +138,15 @@ static void ext2_check_page(struct page *page, int quiet)
p = (ext2_dirent *)(kaddr + offs); p = (ext2_dirent *)(kaddr + offs);
rec_len = ext2_rec_len_from_disk(p->rec_len); 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; goto Eshort;
if (rec_len & 3) if (unlikely(rec_len & 3))
goto Ealign; 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; goto Enamelen;
if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1)) if (unlikely(((offs + rec_len - 1) ^ offs) & ~(chunk_size-1)))
goto Espan; goto Espan;
if (le32_to_cpu(p->inode) > max_inumber) if (unlikely(le32_to_cpu(p->inode) > max_inumber))
goto Einumber; goto Einumber;
} }
if (offs != limit) if (offs != limit)
......
...@@ -67,7 +67,7 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, str ...@@ -67,7 +67,7 @@ static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, str
inode = NULL; inode = NULL;
if (ino) { if (ino) {
inode = ext2_iget(dir->i_sb, ino); inode = ext2_iget(dir->i_sb, ino);
if (unlikely(IS_ERR(inode))) { if (IS_ERR(inode)) {
if (PTR_ERR(inode) == -ESTALE) { if (PTR_ERR(inode) == -ESTALE) {
ext2_error(dir->i_sb, __func__, ext2_error(dir->i_sb, __func__,
"deleted inode referenced: %lu", "deleted inode referenced: %lu",
......
...@@ -43,9 +43,10 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data); ...@@ -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_statfs (struct dentry * dentry, struct kstatfs * buf);
static int ext2_sync_fs(struct super_block *sb, int wait); static int ext2_sync_fs(struct super_block *sb, int wait);
void ext2_error (struct super_block * sb, const char * function, void ext2_error(struct super_block *sb, const char *function,
const char * fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
struct ext2_sb_info *sbi = EXT2_SB(sb); struct ext2_sb_info *sbi = EXT2_SB(sb);
struct ext2_super_block *es = sbi->s_es; struct ext2_super_block *es = sbi->s_es;
...@@ -59,9 +60,13 @@ void ext2_error (struct super_block * sb, const char * function, ...@@ -59,9 +60,13 @@ void ext2_error (struct super_block * sb, const char * function,
} }
va_start(args, fmt); va_start(args, fmt);
printk(KERN_CRIT "EXT2-fs (%s): error: %s: ", sb->s_id, function);
vprintk(fmt, args); vaf.fmt = fmt;
printk("\n"); vaf.va = &args;
printk(KERN_CRIT "EXT2-fs (%s): error: %s: %pV\n",
sb->s_id, function, &vaf);
va_end(args); va_end(args);
if (test_opt(sb, ERRORS_PANIC)) if (test_opt(sb, ERRORS_PANIC))
...@@ -76,12 +81,16 @@ void ext2_error (struct super_block * sb, const char * function, ...@@ -76,12 +81,16 @@ void ext2_error (struct super_block * sb, const char * function,
void ext2_msg(struct super_block *sb, const char *prefix, void ext2_msg(struct super_block *sb, const char *prefix,
const char *fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
printk("%sEXT2-fs (%s): ", prefix, sb->s_id);
vprintk(fmt, args); vaf.fmt = fmt;
printk("\n"); vaf.va = &args;
printk("%sEXT2-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
va_end(args); va_end(args);
} }
......
...@@ -20,6 +20,7 @@ ...@@ -20,6 +20,7 @@
#include <linux/ext3_jbd.h> #include <linux/ext3_jbd.h>
#include <linux/quotaops.h> #include <linux/quotaops.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/blkdev.h>
/* /*
* balloc.c contains the blocks allocation and deallocation routines * balloc.c contains the blocks allocation and deallocation routines
...@@ -39,6 +40,21 @@ ...@@ -39,6 +40,21 @@
#define in_range(b, first, len) ((b) >= (first) && (b) <= (first) + (len) - 1) #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 * ext3_get_group_desc() -- load group descriptor from disk
* @sb: super block * @sb: super block
...@@ -1885,3 +1901,253 @@ unsigned long ext3_bg_num_gdb(struct super_block *sb, int group) ...@@ -1885,3 +1901,253 @@ unsigned long ext3_bg_num_gdb(struct super_block *sb, int group)
return ext3_bg_num_gdb_meta(sb,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, ...@@ -69,25 +69,26 @@ int ext3_check_dir_entry (const char * function, struct inode * dir,
const char * error_msg = NULL; const char * error_msg = NULL;
const int rlen = ext3_rec_len_from_disk(de->rec_len); 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"; 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"; 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"; 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"; error_msg = "directory entry across blocks";
else if (le32_to_cpu(de->inode) > else if (unlikely(le32_to_cpu(de->inode) >
le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count)) le32_to_cpu(EXT3_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 (unlikely(error_msg != NULL))
ext3_error (dir->i_sb, function, ext3_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,
(unsigned long) le32_to_cpu(de->inode), (unsigned long) le32_to_cpu(de->inode),
rlen, de->name_len); rlen, de->name_len);
return error_msg == NULL ? 1 : 0; return error_msg == NULL ? 1 : 0;
} }
......
...@@ -2145,13 +2145,15 @@ static void ext3_clear_blocks(handle_t *handle, struct inode *inode, ...@@ -2145,13 +2145,15 @@ static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
if (try_to_extend_transaction(handle, inode)) { if (try_to_extend_transaction(handle, inode)) {
if (bh) { if (bh) {
BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata"); 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); ext3_mark_inode_dirty(handle, inode);
truncate_restart_transaction(handle, inode); truncate_restart_transaction(handle, inode);
if (bh) { if (bh) {
BUFFER_TRACE(bh, "retaking write access"); 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 @@ long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -276,7 +276,29 @@ long ext3_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
mnt_drop_write(filp->f_path.mnt); mnt_drop_write(filp->f_path.mnt);
return err; 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: default:
return -ENOTTY; return -ENOTTY;
......
...@@ -858,6 +858,7 @@ static struct buffer_head *ext3_find_entry(struct inode *dir, ...@@ -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_use[NAMEI_RA_SIZE];
struct buffer_head * bh, *ret = NULL; struct buffer_head * bh, *ret = NULL;
unsigned long start, block, b; unsigned long start, block, b;
const u8 *name = entry->name;
int ra_max = 0; /* Number of bh's in the readahead int ra_max = 0; /* Number of bh's in the readahead
buffer, bh_use[] */ buffer, bh_use[] */
int ra_ptr = 0; /* Current index into readahead int ra_ptr = 0; /* Current index into readahead
...@@ -871,6 +872,16 @@ static struct buffer_head *ext3_find_entry(struct inode *dir, ...@@ -871,6 +872,16 @@ static struct buffer_head *ext3_find_entry(struct inode *dir,
namelen = entry->len; namelen = entry->len;
if (namelen > EXT3_NAME_LEN) if (namelen > EXT3_NAME_LEN)
return NULL; 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)) { if (is_dx(dir)) {
bh = ext3_dx_find_entry(dir, entry, res_dir, &err); 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, ...@@ -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, struct qstr *entry, struct ext3_dir_entry_2 **res_dir,
int *err) int *err)
{ {
struct super_block * sb; struct super_block *sb = dir->i_sb;
struct dx_hash_info hinfo; struct dx_hash_info hinfo;
u32 hash;
struct dx_frame frames[2], *frame; struct dx_frame frames[2], *frame;
struct ext3_dir_entry_2 *de, *top;
struct buffer_head *bh; struct buffer_head *bh;
unsigned long block; unsigned long block;
int retval; int retval;
int namelen = entry->len;
const u8 *name = entry->name;
sb = dir->i_sb; if (!(frame = dx_probe(entry, dir, &hinfo, frames, err)))
/* NFS may look up ".." - look at dx_root directory block */ return NULL;
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;
do { do {
block = dx_get_block(frame->at); block = dx_get_block(frame->at);
if (!(bh = ext3_bread (NULL,dir, block, 0, err))) if (!(bh = ext3_bread (NULL,dir, block, 0, err)))
goto errout; 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)) { retval = search_dirblock(bh, dir, entry,
*res_dir = de; block << EXT3_BLOCK_SIZE_BITS(sb),
dx_release(frames); res_dir);
return bh; 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 */ /* 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); frames, NULL);
if (retval < 0) { if (retval < 0) {
ext3_warning(sb, __func__, ext3_warning(sb, __func__,
...@@ -1047,7 +1038,7 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str ...@@ -1047,7 +1038,7 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
return ERR_PTR(-EIO); return ERR_PTR(-EIO);
} }
inode = ext3_iget(dir->i_sb, ino); inode = ext3_iget(dir->i_sb, ino);
if (unlikely(IS_ERR(inode))) { if (IS_ERR(inode)) {
if (PTR_ERR(inode) == -ESTALE) { if (PTR_ERR(inode) == -ESTALE) {
ext3_error(dir->i_sb, __func__, ext3_error(dir->i_sb, __func__,
"deleted inode referenced: %lu", "deleted inode referenced: %lu",
...@@ -1607,7 +1598,9 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry, ...@@ -1607,7 +1598,9 @@ static int ext3_dx_add_entry(handle_t *handle, struct dentry *dentry,
if (err) if (err)
goto journal_error; 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); de = do_split(handle, dir, &bh, frame, &hinfo, &err);
if (!de) if (!de)
...@@ -1644,8 +1637,13 @@ static int ext3_delete_entry (handle_t *handle, ...@@ -1644,8 +1637,13 @@ static int ext3_delete_entry (handle_t *handle,
if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i)) if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i))
return -EIO; return -EIO;
if (de == de_del) { if (de == de_del) {
int err;
BUFFER_TRACE(bh, "get_write_access"); 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) if (pde)
pde->rec_len = ext3_rec_len_to_disk( pde->rec_len = ext3_rec_len_to_disk(
ext3_rec_len_from_disk(pde->rec_len) + ext3_rec_len_from_disk(pde->rec_len) +
...@@ -1654,7 +1652,12 @@ static int ext3_delete_entry (handle_t *handle, ...@@ -1654,7 +1652,12 @@ static int ext3_delete_entry (handle_t *handle,
de->inode = 0; de->inode = 0;
dir->i_version++; dir->i_version++;
BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata"); 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; return 0;
} }
i += ext3_rec_len_from_disk(de->rec_len); 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) ...@@ -1762,7 +1765,7 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{ {
handle_t *handle; handle_t *handle;
struct inode * inode; struct inode * inode;
struct buffer_head * dir_block; struct buffer_head * dir_block = NULL;
struct ext3_dir_entry_2 * de; struct ext3_dir_entry_2 * de;
int err, retries = 0; int err, retries = 0;
...@@ -1790,15 +1793,14 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -1790,15 +1793,14 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
inode->i_fop = &ext3_dir_operations; inode->i_fop = &ext3_dir_operations;
inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize; inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize;
dir_block = ext3_bread (handle, inode, 0, 1, &err); dir_block = ext3_bread (handle, inode, 0, 1, &err);
if (!dir_block) { if (!dir_block)
drop_nlink(inode); /* is this nlink == 0? */ goto out_clear_inode;
unlock_new_inode(inode);
ext3_mark_inode_dirty(handle, inode);
iput (inode);
goto out_stop;
}
BUFFER_TRACE(dir_block, "get_write_access"); 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 = (struct ext3_dir_entry_2 *) dir_block->b_data;
de->inode = cpu_to_le32(inode->i_ino); de->inode = cpu_to_le32(inode->i_ino);
de->name_len = 1; de->name_len = 1;
...@@ -1814,11 +1816,16 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -1814,11 +1816,16 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
ext3_set_de_type(dir->i_sb, de, S_IFDIR); ext3_set_de_type(dir->i_sb, de, S_IFDIR);
inode->i_nlink = 2; inode->i_nlink = 2;
BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata"); BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata");
ext3_journal_dirty_metadata(handle, dir_block); err = ext3_journal_dirty_metadata(handle, dir_block);
brelse (dir_block); if (err)
ext3_mark_inode_dirty(handle, inode); goto out_clear_inode;
err = ext3_add_entry (handle, dentry, inode);
err = ext3_mark_inode_dirty(handle, inode);
if (!err)
err = ext3_add_entry (handle, dentry, inode);
if (err) { if (err) {
out_clear_inode:
inode->i_nlink = 0; inode->i_nlink = 0;
unlock_new_inode(inode); unlock_new_inode(inode);
ext3_mark_inode_dirty(handle, inode); ext3_mark_inode_dirty(handle, inode);
...@@ -1827,10 +1834,14 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode) ...@@ -1827,10 +1834,14 @@ static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode)
} }
inc_nlink(dir); inc_nlink(dir);
ext3_update_dx_flag(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); d_instantiate(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
out_stop: out_stop:
brelse(dir_block);
ext3_journal_stop(handle); ext3_journal_stop(handle);
if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries))
goto retry; goto retry;
...@@ -2353,7 +2364,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry, ...@@ -2353,7 +2364,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
goto end_rename; goto end_rename;
} else { } else {
BUFFER_TRACE(new_bh, "get write access"); 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); new_de->inode = cpu_to_le32(old_inode->i_ino);
if (EXT3_HAS_INCOMPAT_FEATURE(new_dir->i_sb, if (EXT3_HAS_INCOMPAT_FEATURE(new_dir->i_sb,
EXT3_FEATURE_INCOMPAT_FILETYPE)) EXT3_FEATURE_INCOMPAT_FILETYPE))
...@@ -2362,7 +2375,9 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry, ...@@ -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; new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME_SEC;
ext3_mark_inode_dirty(handle, new_dir); ext3_mark_inode_dirty(handle, new_dir);
BUFFER_TRACE(new_bh, "call ext3_journal_dirty_metadata"); 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); brelse(new_bh);
new_bh = NULL; new_bh = NULL;
} }
...@@ -2411,10 +2426,17 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry, ...@@ -2411,10 +2426,17 @@ static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry,
ext3_update_dx_flag(old_dir); ext3_update_dx_flag(old_dir);
if (dir_bh) { if (dir_bh) {
BUFFER_TRACE(dir_bh, "get_write_access"); 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); PARENT_INO(dir_bh->b_data) = cpu_to_le32(new_dir->i_ino);
BUFFER_TRACE(dir_bh, "call ext3_journal_dirty_metadata"); 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); drop_nlink(old_dir);
if (new_inode) { if (new_inode) {
drop_nlink(new_inode); drop_nlink(new_inode);
......
...@@ -249,7 +249,11 @@ static int setup_new_group_blocks(struct super_block *sb, ...@@ -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); memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size);
set_buffer_uptodate(gdb); set_buffer_uptodate(gdb);
unlock_buffer(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); ext3_set_bit(bit, bh->b_data);
brelse(gdb); brelse(gdb);
} }
...@@ -269,7 +273,11 @@ static int setup_new_group_blocks(struct super_block *sb, ...@@ -269,7 +273,11 @@ static int setup_new_group_blocks(struct super_block *sb,
err = PTR_ERR(gdb); err = PTR_ERR(gdb);
goto exit_bh; 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); ext3_set_bit(bit, bh->b_data);
brelse(gdb); brelse(gdb);
} }
...@@ -295,7 +303,11 @@ static int setup_new_group_blocks(struct super_block *sb, ...@@ -295,7 +303,11 @@ static int setup_new_group_blocks(struct super_block *sb,
err = PTR_ERR(it); err = PTR_ERR(it);
goto exit_bh; 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); brelse(it);
ext3_set_bit(bit, bh->b_data); ext3_set_bit(bit, bh->b_data);
} }
...@@ -306,7 +318,9 @@ static int setup_new_group_blocks(struct super_block *sb, ...@@ -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), mark_bitmap_end(input->blocks_count, EXT3_BLOCKS_PER_GROUP(sb),
bh->b_data); bh->b_data);
ext3_journal_dirty_metadata(handle, bh); err = ext3_journal_dirty_metadata(handle, bh);
if (err)
goto exit_bh;
brelse(bh); brelse(bh);
/* Mark unused entries in inode bitmap used */ /* Mark unused entries in inode bitmap used */
...@@ -319,7 +333,7 @@ static int setup_new_group_blocks(struct super_block *sb, ...@@ -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), mark_bitmap_end(EXT3_INODES_PER_GROUP(sb), EXT3_BLOCKS_PER_GROUP(sb),
bh->b_data); bh->b_data);
ext3_journal_dirty_metadata(handle, bh); err = ext3_journal_dirty_metadata(handle, bh);
exit_bh: exit_bh:
brelse(bh); brelse(bh);
...@@ -503,12 +517,19 @@ static int add_new_gdb(handle_t *handle, struct inode *inode, ...@@ -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). * reserved inode, and will become GDT blocks (primary and backup).
*/ */
data[gdb_num % EXT3_ADDR_PER_BLOCK(sb)] = 0; 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); brelse(dind);
dind = NULL;
inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9; 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); 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; o_group_desc = EXT3_SB(sb)->s_group_desc;
memcpy(n_group_desc, o_group_desc, memcpy(n_group_desc, o_group_desc,
...@@ -519,10 +540,14 @@ static int add_new_gdb(handle_t *handle, struct inode *inode, ...@@ -519,10 +540,14 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
kfree(o_group_desc); kfree(o_group_desc);
le16_add_cpu(&es->s_reserved_gdt_blocks, -1); 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; return 0;
exit_group_desc:
kfree(n_group_desc);
exit_inode: exit_inode:
//ext3_journal_release_buffer(handle, iloc.bh); //ext3_journal_release_buffer(handle, iloc.bh);
brelse(iloc.bh); brelse(iloc.bh);
...@@ -706,16 +731,20 @@ static void update_backups(struct super_block *sb, ...@@ -706,16 +731,20 @@ static void update_backups(struct super_block *sb,
} }
ext3_debug("update metadata backup %#04lx\n", ext3_debug("update metadata backup %#04lx\n",
(unsigned long)bh->b_blocknr); (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; break;
}
lock_buffer(bh); lock_buffer(bh);
memcpy(bh->b_data, data, size); memcpy(bh->b_data, data, size);
if (rest) if (rest)
memset(bh->b_data + size, 0, rest); memset(bh->b_data + size, 0, rest);
set_buffer_uptodate(bh); set_buffer_uptodate(bh);
unlock_buffer(bh); unlock_buffer(bh);
ext3_journal_dirty_metadata(handle, bh); err = ext3_journal_dirty_metadata(handle, bh);
brelse(bh); brelse(bh);
if (err)
break;
} }
if ((err2 = ext3_journal_stop(handle)) && !err) if ((err2 = ext3_journal_stop(handle)) && !err)
err = err2; err = err2;
...@@ -922,7 +951,9 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input) ...@@ -922,7 +951,9 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
/* Update the global fs size fields */ /* Update the global fs size fields */
sbi->s_groups_count++; 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 /* Update the reserved block counts only once the new group is
* active. */ * active. */
...@@ -934,7 +965,7 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input) ...@@ -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, percpu_counter_add(&sbi->s_freeinodes_counter,
EXT3_INODES_PER_GROUP(sb)); EXT3_INODES_PER_GROUP(sb));
ext3_journal_dirty_metadata(handle, sbi->s_sbh); err = ext3_journal_dirty_metadata(handle, sbi->s_sbh);
exit_journal: exit_journal:
mutex_unlock(&sbi->s_resize_lock); mutex_unlock(&sbi->s_resize_lock);
...@@ -1064,8 +1095,14 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es, ...@@ -1064,8 +1095,14 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
goto exit_put; goto exit_put;
} }
es->s_blocks_count = cpu_to_le32(o_blocks_count + add); 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); 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", ext3_debug("freeing blocks "E3FSBLK" through "E3FSBLK"\n",
o_blocks_count, o_blocks_count + add); o_blocks_count, o_blocks_count + add);
ext3_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks); 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, ...@@ -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, void ext3_msg(struct super_block *sb, const char *prefix,
const char *fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
printk("%sEXT3-fs (%s): ", prefix, sb->s_id);
vprintk(fmt, args); vaf.fmt = fmt;
printk("\n"); vaf.va = &args;
printk("%sEXT3-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
va_end(args); va_end(args);
} }
...@@ -195,15 +199,20 @@ static void ext3_handle_error(struct super_block *sb) ...@@ -195,15 +199,20 @@ static void ext3_handle_error(struct super_block *sb)
sb->s_id); sb->s_id);
} }
void ext3_error (struct super_block * sb, const char * function, void ext3_error(struct super_block *sb, const char *function,
const char * fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
vprintk(fmt, args); vaf.fmt = fmt;
printk("\n"); vaf.va = &args;
printk(KERN_CRIT "EXT3-fs error (device %s): %s: %pV\n",
sb->s_id, function, &vaf);
va_end(args); va_end(args);
ext3_handle_error(sb); ext3_handle_error(sb);
...@@ -274,15 +283,20 @@ void __ext3_std_error (struct super_block * sb, const char * function, ...@@ -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. * case we take the easy way out and panic immediately.
*/ */
void ext3_abort (struct super_block * sb, const char * function, void ext3_abort(struct super_block *sb, const char *function,
const char * fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
printk(KERN_CRIT "EXT3-fs (%s): error: %s: ", sb->s_id, function);
vprintk(fmt, args); vaf.fmt = fmt;
printk("\n"); vaf.va = &args;
printk(KERN_CRIT "EXT3-fs (%s): error: %s: %pV\n",
sb->s_id, function, &vaf);
va_end(args); va_end(args);
if (test_opt(sb, ERRORS_PANIC)) if (test_opt(sb, ERRORS_PANIC))
...@@ -300,16 +314,20 @@ void ext3_abort (struct super_block * sb, const char * function, ...@@ -300,16 +314,20 @@ void ext3_abort (struct super_block * sb, const char * function,
journal_abort(EXT3_SB(sb)->s_journal, -EIO); journal_abort(EXT3_SB(sb)->s_journal, -EIO);
} }
void ext3_warning (struct super_block * sb, const char * function, void ext3_warning(struct super_block *sb, const char *function,
const char * fmt, ...) const char *fmt, ...)
{ {
struct va_format vaf;
va_list args; va_list args;
va_start(args, fmt); va_start(args, fmt);
printk(KERN_WARNING "EXT3-fs (%s): warning: %s: ",
sb->s_id, function); vaf.fmt = fmt;
vprintk(fmt, args); vaf.va = &args;
printk("\n");
printk(KERN_WARNING "EXT3-fs (%s): warning: %s: %pV\n",
sb->s_id, function, &vaf);
va_end(args); va_end(args);
} }
...@@ -1848,13 +1866,15 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent) ...@@ -1848,13 +1866,15 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
goto failed_mount; goto failed_mount;
} }
if (generic_check_addressable(sb->s_blocksize_bits, err = generic_check_addressable(sb->s_blocksize_bits,
le32_to_cpu(es->s_blocks_count))) { le32_to_cpu(es->s_blocks_count));
if (err) {
ext3_msg(sb, KERN_ERR, ext3_msg(sb, KERN_ERR,
"error: filesystem is too large to mount safely"); "error: filesystem is too large to mount safely");
if (sizeof(sector_t) < 8) if (sizeof(sector_t) < 8)
ext3_msg(sb, KERN_ERR, ext3_msg(sb, KERN_ERR,
"error: CONFIG_LBDAF not enabled"); "error: CONFIG_LBDAF not enabled");
ret = err;
goto failed_mount; goto failed_mount;
} }
...@@ -2297,7 +2317,7 @@ static int ext3_load_journal(struct super_block *sb, ...@@ -2297,7 +2317,7 @@ static int ext3_load_journal(struct super_block *sb,
EXT3_SB(sb)->s_journal = journal; EXT3_SB(sb)->s_journal = journal;
ext3_clear_journal_err(sb, es); ext3_clear_journal_err(sb, es);
if (journal_devnum && if (!really_read_only && journal_devnum &&
journal_devnum != le32_to_cpu(es->s_journal_dev)) { journal_devnum != le32_to_cpu(es->s_journal_dev)) {
es->s_journal_dev = cpu_to_le32(journal_devnum); es->s_journal_dev = cpu_to_le32(journal_devnum);
......
...@@ -76,18 +76,6 @@ EXPORT_SYMBOL(mb_cache_entry_find_first); ...@@ -76,18 +76,6 @@ EXPORT_SYMBOL(mb_cache_entry_find_first);
EXPORT_SYMBOL(mb_cache_entry_find_next); EXPORT_SYMBOL(mb_cache_entry_find_next);
#endif #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 * Global data: list of all mbcache's, lru list, and a spinlock for
* accessing cache data structures on SMP machines. The lru list is * accessing cache data structures on SMP machines. The lru list is
......
...@@ -133,16 +133,20 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); ...@@ -133,16 +133,20 @@ __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
EXPORT_SYMBOL(dq_data_lock); EXPORT_SYMBOL(dq_data_lock);
void __quota_error(struct super_block *sb, const char *func, void __quota_error(struct super_block *sb, const char *func,
const char *fmt, ...) const char *fmt, ...)
{ {
va_list args;
if (printk_ratelimit()) { if (printk_ratelimit()) {
va_list args;
struct va_format vaf;
va_start(args, fmt); va_start(args, fmt);
printk(KERN_ERR "Quota error (device %s): %s: ",
sb->s_id, func); vaf.fmt = fmt;
vprintk(fmt, args); vaf.va = &args;
printk("\n");
printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
sb->s_id, func, &vaf);
va_end(args); va_end(args);
} }
} }
......
...@@ -468,8 +468,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, ...@@ -468,8 +468,8 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
return -ENOMEM; return -ENOMEM;
ret = read_blk(info, *blk, buf); ret = read_blk(info, *blk, buf);
if (ret < 0) { if (ret < 0) {
quota_error(dquot->dq_sb, "Can't read quota data " quota_error(dquot->dq_sb, "Can't read quota data block %u",
"block %u", blk); *blk);
goto out_buf; goto out_buf;
} }
newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); 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, ...@@ -493,8 +493,9 @@ static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot,
} else { } else {
ret = write_blk(info, *blk, buf); ret = write_blk(info, *blk, buf);
if (ret < 0) if (ret < 0)
quota_error(dquot->dq_sb, "Can't write quota " quota_error(dquot->dq_sb,
"tree block %u", blk); "Can't write quota tree block %u",
*blk);
} }
} }
out_buf: out_buf:
......
...@@ -724,21 +724,30 @@ struct ext3_dir_entry_2 { ...@@ -724,21 +724,30 @@ struct ext3_dir_entry_2 {
~EXT3_DIR_ROUND) ~EXT3_DIR_ROUND)
#define EXT3_MAX_REC_LEN ((1<<16)-1) #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) static inline unsigned ext3_rec_len_from_disk(__le16 dlen)
{ {
unsigned len = le16_to_cpu(dlen); unsigned len = le16_to_cpu(dlen);
#if (PAGE_CACHE_SIZE >= 65536)
if (len == EXT3_MAX_REC_LEN) if (len == EXT3_MAX_REC_LEN)
return 1 << 16; return 1 << 16;
#endif
return len; return len;
} }
static inline __le16 ext3_rec_len_to_disk(unsigned len) static inline __le16 ext3_rec_len_to_disk(unsigned len)
{ {
#if (PAGE_CACHE_SIZE >= 65536)
if (len == (1 << 16)) if (len == (1 << 16))
return cpu_to_le16(EXT3_MAX_REC_LEN); return cpu_to_le16(EXT3_MAX_REC_LEN);
else if (len > (1 << 16)) else if (len > (1 << 16))
BUG(); BUG();
#endif
return cpu_to_le16(len); return cpu_to_le16(len);
} }
...@@ -856,6 +865,7 @@ extern struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb, ...@@ -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 int ext3_should_retry_alloc(struct super_block *sb, int *retries);
extern void ext3_init_block_alloc_info(struct inode *); 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 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 */ /* dir.c */
extern int ext3_check_dir_entry(const char *, struct inode *, extern int ext3_check_dir_entry(const char *, struct inode *,
......
...@@ -18,6 +18,17 @@ struct mb_cache_entry { ...@@ -18,6 +18,17 @@ struct mb_cache_entry {
} e_index; } 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 */ /* Functions on caches */
struct mb_cache *mb_cache_create(const char *, int); 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) ...@@ -31,8 +31,9 @@ static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
#define quota_error(sb, fmt, args...) \ #define quota_error(sb, fmt, args...) \
__quota_error((sb), __func__, fmt , ## args) __quota_error((sb), __func__, fmt , ## args)
extern void __quota_error(struct super_block *sb, const char *func, extern __attribute__((format (printf, 3, 4)))
const char *fmt, ...); void __quota_error(struct super_block *sb, const char *func,
const char *fmt, ...);
/* /*
* declaration of quota_function calls in kernel. * declaration of quota_function calls in kernel.
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment