summaryrefslogtreecommitdiff
path: root/fs/ocfs2/suballoc.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/ocfs2/suballoc.c')
-rw-r--r--fs/ocfs2/suballoc.c418
1 files changed, 389 insertions, 29 deletions
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index f7b483f0de2a..d284e0e37252 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -11,6 +11,7 @@
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>
+#include <linux/string.h>
#include <linux/highmem.h>
#include <cluster/masklog.h>
@@ -196,6 +197,31 @@ static int ocfs2_validate_gd_self(struct super_block *sb,
8 * le16_to_cpu(gd->bg_size));
}
+ /*
+ * For discontiguous block groups, validate the on-disk extent list
+ * against the maximum number of extent records that can physically
+ * fit in a single block.
+ */
+ if (ocfs2_gd_is_discontig(gd)) {
+ u16 max_recs = ocfs2_extent_recs_per_gd(sb);
+ u16 l_count = le16_to_cpu(gd->bg_list.l_count);
+ u16 l_next_free_rec = le16_to_cpu(gd->bg_list.l_next_free_rec);
+
+ if (l_count != max_recs) {
+ do_error("Group descriptor #%llu bad discontig l_count %u expected %u\n",
+ (unsigned long long)bh->b_blocknr,
+ l_count,
+ max_recs);
+ }
+
+ if (l_next_free_rec > l_count) {
+ do_error("Group descriptor #%llu bad discontig l_next_free_rec %u max %u\n",
+ (unsigned long long)bh->b_blocknr,
+ l_next_free_rec,
+ l_count);
+ }
+ }
+
return 0;
}
@@ -294,6 +320,74 @@ static int ocfs2_validate_group_descriptor(struct super_block *sb,
return ocfs2_validate_gd_self(sb, bh, 0);
}
+/*
+ * The hint group descriptor (gd) may already have been released
+ * in _ocfs2_free_suballoc_bits(). We first check the gd signature,
+ * then perform the standard ocfs2_read_group_descriptor() jobs.
+ *
+ * If the gd signature is invalid, we return 'rc=0' and set
+ * '*released=1'. The caller is expected to handle this specific case.
+ * Otherwise, we return the actual error code.
+ *
+ * We treat gd signature corruption case as a release case. The
+ * caller ocfs2_claim_suballoc_bits() will use ocfs2_search_chain()
+ * to search each gd block. The code will eventually find this
+ * corrupted gd block - Late, but not missed.
+ *
+ * Note:
+ * The caller is responsible for initializing the '*released' status.
+ */
+static int ocfs2_read_hint_group_descriptor(struct inode *inode,
+ struct ocfs2_dinode *di, u64 gd_blkno,
+ struct buffer_head **bh, int *released)
+{
+ int rc;
+ struct buffer_head *tmp = *bh;
+ struct ocfs2_group_desc *gd;
+
+ rc = ocfs2_read_block(INODE_CACHE(inode), gd_blkno, &tmp, NULL);
+ if (rc)
+ goto out;
+
+ gd = (struct ocfs2_group_desc *) tmp->b_data;
+ if (!OCFS2_IS_VALID_GROUP_DESC(gd)) {
+ /*
+ * Invalid gd cache was set in ocfs2_read_block(),
+ * which will affect block_group allocation.
+ * Path:
+ * ocfs2_reserve_suballoc_bits
+ * ocfs2_block_group_alloc
+ * ocfs2_block_group_alloc_contig
+ * ocfs2_set_new_buffer_uptodate
+ */
+ ocfs2_remove_from_cache(INODE_CACHE(inode), tmp);
+ *released = 1; /* we return 'rc=0' for this case */
+ goto free_bh;
+ }
+
+ /* below jobs same with ocfs2_read_group_descriptor() */
+ if (!buffer_jbd(tmp)) {
+ rc = ocfs2_validate_group_descriptor(inode->i_sb, tmp);
+ if (rc)
+ goto free_bh;
+ }
+
+ rc = ocfs2_validate_gd_parent(inode->i_sb, di, tmp, 0);
+ if (rc)
+ goto free_bh;
+
+ /* If ocfs2_read_block() got us a new bh, pass it up. */
+ if (!*bh)
+ *bh = tmp;
+
+ return rc;
+
+free_bh:
+ brelse(tmp);
+out:
+ return rc;
+}
+
int ocfs2_read_group_descriptor(struct inode *inode, struct ocfs2_dinode *di,
u64 gd_blkno, struct buffer_head **bh)
{
@@ -372,7 +466,7 @@ static int ocfs2_block_group_fill(handle_t *handle,
}
memset(bg, 0, sb->s_blocksize);
- strcpy(bg->bg_signature, OCFS2_GROUP_DESC_SIGNATURE);
+ strscpy(bg->bg_signature, OCFS2_GROUP_DESC_SIGNATURE);
bg->bg_generation = cpu_to_le32(osb->fs_generation);
bg->bg_size = cpu_to_le16(ocfs2_group_bitmap_size(sb, 1,
osb->s_feature_incompat));
@@ -698,10 +792,12 @@ static int ocfs2_block_group_alloc(struct ocfs2_super *osb,
bg_bh = ocfs2_block_group_alloc_contig(osb, handle, alloc_inode,
ac, cl);
- if (PTR_ERR(bg_bh) == -ENOSPC)
+ if (PTR_ERR(bg_bh) == -ENOSPC) {
+ ac->ac_which = OCFS2_AC_USE_MAIN_DISCONTIG;
bg_bh = ocfs2_block_group_alloc_discontig(handle,
alloc_inode,
ac, cl);
+ }
if (IS_ERR(bg_bh)) {
status = PTR_ERR(bg_bh);
bg_bh = NULL;
@@ -963,7 +1059,7 @@ int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb,
int status;
int slot = ocfs2_get_meta_steal_slot(osb);
- *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
+ *ac = kzalloc_obj(struct ocfs2_alloc_context);
if (!(*ac)) {
status = -ENOMEM;
mlog_errno(status);
@@ -1034,7 +1130,7 @@ int ocfs2_reserve_new_inode(struct ocfs2_super *osb,
int slot = ocfs2_get_inode_steal_slot(osb);
u64 alloc_group;
- *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
+ *ac = kzalloc_obj(struct ocfs2_alloc_context);
if (!(*ac)) {
status = -ENOMEM;
mlog_errno(status);
@@ -1150,7 +1246,7 @@ static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb,
int status, ret = 0;
int retried = 0;
- *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL);
+ *ac = kzalloc_obj(struct ocfs2_alloc_context);
if (!(*ac)) {
status = -ENOMEM;
mlog_errno(status);
@@ -1722,7 +1818,7 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
u32 bits_wanted,
u32 min_bits,
struct ocfs2_suballoc_result *res,
- u16 *bits_left)
+ u16 *bits_left, int *released)
{
int ret;
struct buffer_head *group_bh = NULL;
@@ -1730,9 +1826,11 @@ static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac,
struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data;
struct inode *alloc_inode = ac->ac_inode;
- ret = ocfs2_read_group_descriptor(alloc_inode, di,
- res->sr_bg_blkno, &group_bh);
- if (ret < 0) {
+ ret = ocfs2_read_hint_group_descriptor(alloc_inode, di,
+ res->sr_bg_blkno, &group_bh, released);
+ if (*released) {
+ return 0;
+ } else if (ret < 0) {
mlog_errno(ret);
return ret;
}
@@ -1794,6 +1892,7 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
{
int status;
u16 chain;
+ u32 contig_bits;
u64 next_group;
struct inode *alloc_inode = ac->ac_inode;
struct buffer_head *group_bh = NULL;
@@ -1819,10 +1918,21 @@ static int ocfs2_search_chain(struct ocfs2_alloc_context *ac,
status = -ENOSPC;
/* for now, the chain search is a bit simplistic. We just use
* the 1st group with any empty bits. */
- while ((status = ac->ac_group_search(alloc_inode, group_bh,
- bits_wanted, min_bits,
- ac->ac_max_block,
- res)) == -ENOSPC) {
+ while (1) {
+ if (ac->ac_which == OCFS2_AC_USE_MAIN_DISCONTIG) {
+ contig_bits = le16_to_cpu(bg->bg_contig_free_bits);
+ if (!contig_bits)
+ contig_bits = ocfs2_find_max_contig_free_bits(bg->bg_bitmap,
+ le16_to_cpu(bg->bg_bits), 0);
+ if (bits_wanted > contig_bits && contig_bits >= min_bits)
+ bits_wanted = contig_bits;
+ }
+
+ status = ac->ac_group_search(alloc_inode, group_bh,
+ bits_wanted, min_bits,
+ ac->ac_max_block, res);
+ if (status != -ENOSPC)
+ break;
if (!bg->bg_next_group)
break;
@@ -1935,6 +2045,7 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
struct ocfs2_suballoc_result *res)
{
int status;
+ int released = 0;
u16 victim, i;
u16 bits_left = 0;
u64 hint = ac->ac_last_group;
@@ -1961,6 +2072,7 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
goto bail;
}
+ /* the hint bg may already be released, we quiet search this group. */
res->sr_bg_blkno = hint;
if (res->sr_bg_blkno) {
/* Attempt to short-circuit the usual search mechanism
@@ -1968,7 +2080,12 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
* allocation group. This helps us maintain some
* contiguousness across allocations. */
status = ocfs2_search_one_group(ac, handle, bits_wanted,
- min_bits, res, &bits_left);
+ min_bits, res, &bits_left,
+ &released);
+ if (released) {
+ res->sr_bg_blkno = 0;
+ goto chain_search;
+ }
if (!status)
goto set_hint;
if (status < 0 && status != -ENOSPC) {
@@ -1976,12 +2093,23 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
goto bail;
}
}
-
+chain_search:
cl = (struct ocfs2_chain_list *) &fe->id2.i_chain;
+ if (!le16_to_cpu(cl->cl_next_free_rec) ||
+ le16_to_cpu(cl->cl_next_free_rec) > le16_to_cpu(cl->cl_count)) {
+ status = ocfs2_error(ac->ac_inode->i_sb,
+ "Chain allocator dinode %llu has invalid next "
+ "free chain record %u, but only %u total\n",
+ (unsigned long long)le64_to_cpu(fe->i_blkno),
+ le16_to_cpu(cl->cl_next_free_rec),
+ le16_to_cpu(cl->cl_count));
+ goto bail;
+ }
victim = ocfs2_find_victim_chain(cl);
ac->ac_chain = victim;
+search:
status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits,
res, &bits_left);
if (!status) {
@@ -2022,6 +2150,16 @@ static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac,
}
}
+ /* Chains can't supply the bits_wanted contiguous space.
+ * We should switch to using every single bit when allocating
+ * from the global bitmap. */
+ if (i == le16_to_cpu(cl->cl_next_free_rec) &&
+ status == -ENOSPC && ac->ac_which == OCFS2_AC_USE_MAIN) {
+ ac->ac_which = OCFS2_AC_USE_MAIN_DISCONTIG;
+ ac->ac_chain = victim;
+ goto search;
+ }
+
set_hint:
if (status != -ENOSPC) {
/* If the next search of this group is not likely to
@@ -2077,6 +2215,12 @@ bail:
return status;
}
+/*
+ * after ocfs2 has the ability to release block group unused space,
+ * the ->ip_last_used_group may be invalid. so this function returns
+ * ac->ac_last_group need to verify.
+ * refer the 'hint' in ocfs2_claim_suballoc_bits() for more details.
+ */
static void ocfs2_init_inode_ac_group(struct inode *dir,
struct buffer_head *parent_di_bh,
struct ocfs2_alloc_context *ac)
@@ -2126,7 +2270,7 @@ int ocfs2_find_new_inode_loc(struct inode *dir,
BUG_ON(ac->ac_bits_wanted != 1);
BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE);
- res = kzalloc(sizeof(*res), GFP_NOFS);
+ res = kzalloc_obj(*res, GFP_NOFS);
if (res == NULL) {
ret = -ENOMEM;
mlog_errno(ret);
@@ -2365,7 +2509,8 @@ int __ocfs2_claim_clusters(handle_t *handle,
BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL
- && ac->ac_which != OCFS2_AC_USE_MAIN);
+ && ac->ac_which != OCFS2_AC_USE_MAIN
+ && ac->ac_which != OCFS2_AC_USE_MAIN_DISCONTIG);
if (ac->ac_which == OCFS2_AC_USE_LOCAL) {
WARN_ON(min_clusters > 1);
@@ -2515,6 +2660,198 @@ bail:
}
/*
+ * Reclaim the suballocator managed space to main bitmap.
+ * This function first works on the suballocator to perform the
+ * cleanup rec/alloc_inode job, then switches to the main bitmap
+ * to reclaim released space.
+ *
+ * handle: The transaction handle
+ * alloc_inode: The suballoc inode
+ * alloc_bh: The buffer_head of suballoc inode
+ * group_bh: The group descriptor buffer_head of suballocator managed.
+ * Caller should release the input group_bh.
+ */
+static int _ocfs2_reclaim_suballoc_to_main(handle_t *handle,
+ struct inode *alloc_inode,
+ struct buffer_head *alloc_bh,
+ struct buffer_head *group_bh)
+{
+ int idx, status = 0;
+ int i, next_free_rec, len = 0;
+ __le16 old_bg_contig_free_bits = 0;
+ u16 start_bit;
+ u32 tmp_used;
+ u64 bg_blkno, start_blk;
+ unsigned int count;
+ struct ocfs2_chain_rec *rec;
+ struct buffer_head *main_bm_bh = NULL;
+ struct inode *main_bm_inode = NULL;
+ struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb);
+ struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data;
+ struct ocfs2_chain_list *cl = &fe->id2.i_chain;
+ struct ocfs2_group_desc *group = (struct ocfs2_group_desc *) group_bh->b_data;
+
+ idx = le16_to_cpu(group->bg_chain);
+ rec = &(cl->cl_recs[idx]);
+
+ status = ocfs2_extend_trans(handle,
+ ocfs2_calc_group_alloc_credits(osb->sb,
+ le16_to_cpu(cl->cl_cpg)));
+ if (status) {
+ mlog_errno(status);
+ goto bail;
+ }
+ status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode),
+ alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE);
+ if (status < 0) {
+ mlog_errno(status);
+ goto bail;
+ }
+
+ /*
+ * Only clear the suballocator rec item in-place.
+ *
+ * If idx is not the last, we don't compress (remove the empty item)
+ * the cl_recs[]. If not, we need to do lots jobs.
+ *
+ * Compress cl_recs[] code example:
+ * if (idx != cl->cl_next_free_rec - 1)
+ * memmove(&cl->cl_recs[idx], &cl->cl_recs[idx + 1],
+ * sizeof(struct ocfs2_chain_rec) *
+ * (cl->cl_next_free_rec - idx - 1));
+ * for(i = idx; i < cl->cl_next_free_rec-1; i++) {
+ * group->bg_chain = "later group->bg_chain";
+ * group->bg_blkno = xxx;
+ * ... ...
+ * }
+ */
+
+ tmp_used = le32_to_cpu(fe->id1.bitmap1.i_total);
+ fe->id1.bitmap1.i_total = cpu_to_le32(tmp_used - le32_to_cpu(rec->c_total));
+
+ /* Substraction 1 for the block group itself */
+ tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used);
+ fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - 1);
+
+ tmp_used = le32_to_cpu(fe->i_clusters);
+ fe->i_clusters = cpu_to_le32(tmp_used - le16_to_cpu(cl->cl_cpg));
+
+ spin_lock(&OCFS2_I(alloc_inode)->ip_lock);
+ OCFS2_I(alloc_inode)->ip_clusters -= le32_to_cpu(fe->i_clusters);
+ fe->i_size = cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode->i_sb,
+ le32_to_cpu(fe->i_clusters)));
+ spin_unlock(&OCFS2_I(alloc_inode)->ip_lock);
+ i_size_write(alloc_inode, le64_to_cpu(fe->i_size));
+ alloc_inode->i_blocks = ocfs2_inode_sector_count(alloc_inode);
+
+ ocfs2_journal_dirty(handle, alloc_bh);
+ ocfs2_update_inode_fsync_trans(handle, alloc_inode, 0);
+
+ start_blk = le64_to_cpu(rec->c_blkno);
+ count = le32_to_cpu(rec->c_total) / le16_to_cpu(cl->cl_bpc);
+
+ /*
+ * If the rec is the last one, let's compress the chain list by
+ * removing the empty cl_recs[] at the end.
+ */
+ next_free_rec = le16_to_cpu(cl->cl_next_free_rec);
+ if (idx == (next_free_rec - 1)) {
+ len++; /* the last item should be counted first */
+ for (i = (next_free_rec - 2); i > 0; i--) {
+ if (cl->cl_recs[i].c_free == cl->cl_recs[i].c_total)
+ len++;
+ else
+ break;
+ }
+ }
+ le16_add_cpu(&cl->cl_next_free_rec, -len);
+
+ rec->c_free = 0;
+ rec->c_total = 0;
+ rec->c_blkno = 0;
+ ocfs2_remove_from_cache(INODE_CACHE(alloc_inode), group_bh);
+ memset(group, 0, sizeof(struct ocfs2_group_desc));
+
+ /* prepare job for reclaim clusters */
+ main_bm_inode = ocfs2_get_system_file_inode(osb,
+ GLOBAL_BITMAP_SYSTEM_INODE,
+ OCFS2_INVALID_SLOT);
+ if (!main_bm_inode)
+ goto bail; /* ignore the error in reclaim path */
+
+ inode_lock(main_bm_inode);
+
+ status = ocfs2_inode_lock(main_bm_inode, &main_bm_bh, 1);
+ if (status < 0)
+ goto free_bm_inode; /* ignore the error in reclaim path */
+
+ ocfs2_block_to_cluster_group(main_bm_inode, start_blk, &bg_blkno,
+ &start_bit);
+ fe = (struct ocfs2_dinode *) main_bm_bh->b_data;
+ cl = &fe->id2.i_chain;
+ /* reuse group_bh, caller will release the input group_bh */
+ group_bh = NULL;
+
+ /* reclaim clusters to global_bitmap */
+ status = ocfs2_read_group_descriptor(main_bm_inode, fe, bg_blkno,
+ &group_bh);
+ if (status < 0) {
+ mlog_errno(status);
+ goto free_bm_bh;
+ }
+ group = (struct ocfs2_group_desc *) group_bh->b_data;
+
+ if ((count + start_bit) > le16_to_cpu(group->bg_bits)) {
+ ocfs2_error(alloc_inode->i_sb,
+ "reclaim length (%d) beyands block group length (%d)",
+ count + start_bit, le16_to_cpu(group->bg_bits));
+ goto free_group_bh;
+ }
+
+ old_bg_contig_free_bits = group->bg_contig_free_bits;
+ status = ocfs2_block_group_clear_bits(handle, main_bm_inode,
+ group, group_bh,
+ start_bit, count, 0,
+ _ocfs2_clear_bit);
+ if (status < 0) {
+ mlog_errno(status);
+ goto free_group_bh;
+ }
+
+ status = ocfs2_journal_access_di(handle, INODE_CACHE(main_bm_inode),
+ main_bm_bh, OCFS2_JOURNAL_ACCESS_WRITE);
+ if (status < 0) {
+ mlog_errno(status);
+ ocfs2_block_group_set_bits(handle, main_bm_inode, group, group_bh,
+ start_bit, count,
+ le16_to_cpu(old_bg_contig_free_bits), 1);
+ goto free_group_bh;
+ }
+
+ idx = le16_to_cpu(group->bg_chain);
+ rec = &(cl->cl_recs[idx]);
+
+ le32_add_cpu(&rec->c_free, count);
+ tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used);
+ fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count);
+ ocfs2_journal_dirty(handle, main_bm_bh);
+
+free_group_bh:
+ brelse(group_bh);
+
+free_bm_bh:
+ ocfs2_inode_unlock(main_bm_inode, 1);
+ brelse(main_bm_bh);
+
+free_bm_inode:
+ inode_unlock(main_bm_inode);
+ iput(main_bm_inode);
+
+bail:
+ return status;
+}
+
+/*
* expects the suballoc inode to already be locked.
*/
static int _ocfs2_free_suballoc_bits(handle_t *handle,
@@ -2526,12 +2863,13 @@ static int _ocfs2_free_suballoc_bits(handle_t *handle,
void (*undo_fn)(unsigned int bit,
unsigned long *bitmap))
{
- int status = 0;
+ int idx, status = 0;
u32 tmp_used;
struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data;
struct ocfs2_chain_list *cl = &fe->id2.i_chain;
struct buffer_head *group_bh = NULL;
struct ocfs2_group_desc *group;
+ struct ocfs2_chain_rec *rec;
__le16 old_bg_contig_free_bits = 0;
/* The alloc_bh comes from ocfs2_free_dinode() or
@@ -2577,12 +2915,26 @@ static int _ocfs2_free_suballoc_bits(handle_t *handle,
goto bail;
}
- le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free,
- count);
+ idx = le16_to_cpu(group->bg_chain);
+ rec = &(cl->cl_recs[idx]);
+
+ le32_add_cpu(&rec->c_free, count);
tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used);
fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count);
ocfs2_journal_dirty(handle, alloc_bh);
+ /*
+ * Reclaim suballocator free space.
+ * Bypass: global_bitmap, non empty rec, first rec in cl_recs[]
+ */
+ if (ocfs2_is_cluster_bitmap(alloc_inode) ||
+ (le32_to_cpu(rec->c_free) != (le32_to_cpu(rec->c_total) - 1)) ||
+ (le16_to_cpu(cl->cl_next_free_rec) == 1)) {
+ goto bail;
+ }
+
+ _ocfs2_reclaim_suballoc_to_main(handle, alloc_inode, alloc_bh, group_bh);
+
bail:
brelse(group_bh);
return status;
@@ -2836,7 +3188,7 @@ static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb,
struct ocfs2_group_desc *group;
struct buffer_head *group_bh = NULL;
u64 bg_blkno;
- int status;
+ int status, quiet = 0, released = 0;
trace_ocfs2_test_suballoc_bit((unsigned long long)blkno,
(unsigned int)bit);
@@ -2852,9 +3204,13 @@ static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb,
bg_blkno = group_blkno ? group_blkno :
ocfs2_which_suballoc_group(blkno, bit);
- status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno,
- &group_bh);
- if (status < 0) {
+ status = ocfs2_read_hint_group_descriptor(suballoc, alloc_di, bg_blkno,
+ &group_bh, &released);
+ if (released) {
+ quiet = 1;
+ status = -ESTALE;
+ goto bail;
+ } else if (status < 0) {
mlog(ML_ERROR, "read group %llu failed %d\n",
(unsigned long long)bg_blkno, status);
goto bail;
@@ -2866,7 +3222,7 @@ static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb,
bail:
brelse(group_bh);
- if (status)
+ if (status && !quiet)
mlog_errno(status);
return status;
}
@@ -2886,7 +3242,7 @@ bail:
*/
int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
{
- int status;
+ int status, quiet = 0;
u64 group_blkno = 0;
u16 suballoc_bit = 0, suballoc_slot = 0;
struct inode *inode_alloc_inode;
@@ -2928,8 +3284,12 @@ int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh,
group_blkno, blkno, suballoc_bit, res);
- if (status < 0)
- mlog(ML_ERROR, "test suballoc bit failed %d\n", status);
+ if (status < 0) {
+ if (status == -ESTALE)
+ quiet = 1;
+ else
+ mlog(ML_ERROR, "test suballoc bit failed %d\n", status);
+ }
ocfs2_inode_unlock(inode_alloc_inode, 0);
inode_unlock(inode_alloc_inode);
@@ -2937,7 +3297,7 @@ int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res)
iput(inode_alloc_inode);
brelse(alloc_bh);
bail:
- if (status)
+ if (status && !quiet)
mlog_errno(status);
return status;
}