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:
commit
40c73abbb3
|
@ -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)
|
||||||
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
|
||||||
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);
|
||||||
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,
|
||||||
}
|
}
|
||||||
|
|
||||||
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,
|
||||||
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);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
266
fs/ext3/balloc.c
266
fs/ext3/balloc.c
|
@ -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 @@
|
||||||
|
|
||||||
#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)
|
||||||
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,
|
||||||
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,
|
||||||
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 @@ group_add_out:
|
||||||
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;
|
||||||
|
|
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_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,
|
||||||
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,
|
||||||
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)) {
|
retval = search_dirblock(bh, dir, entry,
|
||||||
brelse(bh);
|
block << EXT3_BLOCK_SIZE_BITS(sb),
|
||||||
*err = ERR_BAD_DX_DIR;
|
res_dir);
|
||||||
goto errout;
|
if (retval == 1) {
|
||||||
}
|
dx_release(frames);
|
||||||
|
return bh;
|
||||||
if (ext3_match(namelen, name, de)) {
|
|
||||||
*res_dir = de;
|
|
||||||
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
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
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)
|
||||||
{
|
{
|
||||||
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 @@ retry:
|
||||||
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 @@ retry:
|
||||||
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 @@ retry:
|
||||||
}
|
}
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
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,
|
||||||
|
|
||||||
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,
|
||||||
|
|
||||||
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,
|
||||||
* 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,
|
||||||
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,
|
||||||
}
|
}
|
||||||
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)
|
||||||
/* 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)
|
||||||
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,
|
||||||
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,
|
||||||
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)
|
||||||
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,
|
||||||
* 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,
|
||||||
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)
|
||||||
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,
|
||||||
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);
|
||||||
|
|
||||||
|
|
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);
|
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);
|
||||||
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,
|
||||||
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,
|
||||||
} 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 {
|
||||||
~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,
|
||||||
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 {
|
||||||
} 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)
|
||||||
#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.
|
||||||
|
|
Loading…
Reference in a new issue