* keep it small.
*/
struct metapath {
+ struct buffer_head *mp_bh[GFS2_MAX_META_HEIGHT];
__u16 mp_list[GFS2_MAX_META_HEIGHT];
};
if (isdir) {
block = gfs2_alloc_meta(ip);
-
+ gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
error = gfs2_dir_get_new_buffer(ip, block, &bh);
if (error)
goto out_brelse;
* Returns: errno
*/
-static int build_height(struct inode *inode, unsigned height)
+static int build_height(struct inode *inode, struct metapath *mp, unsigned height)
{
struct gfs2_inode *ip = GFS2_I(inode);
unsigned new_height = height - ip->i_height;
struct buffer_head *dibh;
- struct buffer_head *blocks[GFS2_MAX_META_HEIGHT];
struct gfs2_dinode *di;
int error;
__be64 *bp;
for(n = 0; n < new_height; n++) {
bn = gfs2_alloc_meta(ip);
- blocks[n] = gfs2_meta_new(ip->i_gl, bn);
- gfs2_trans_add_bh(ip->i_gl, blocks[n], 1);
+ gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
+ mp->mp_bh[n] = gfs2_meta_new(ip->i_gl, bn);
+ gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[n], 1);
}
n = 0;
- bn = blocks[0]->b_blocknr;
+ bn = mp->mp_bh[0]->b_blocknr;
if (new_height > 1) {
for(; n < new_height-1; n++) {
- gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN,
+ gfs2_metatype_set(mp->mp_bh[n], GFS2_METATYPE_IN,
GFS2_FORMAT_IN);
- gfs2_buffer_clear_tail(blocks[n],
+ gfs2_buffer_clear_tail(mp->mp_bh[n],
sizeof(struct gfs2_meta_header));
- bp = (__be64 *)(blocks[n]->b_data +
+ bp = (__be64 *)(mp->mp_bh[n]->b_data +
sizeof(struct gfs2_meta_header));
- *bp = cpu_to_be64(blocks[n+1]->b_blocknr);
- brelse(blocks[n]);
- blocks[n] = NULL;
+ *bp = cpu_to_be64(mp->mp_bh[n+1]->b_blocknr);
+ brelse(mp->mp_bh[n]);
+ mp->mp_bh[n] = NULL;
}
}
- gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
- gfs2_buffer_copy_tail(blocks[n], sizeof(struct gfs2_meta_header),
+ gfs2_metatype_set(mp->mp_bh[n], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
+ gfs2_buffer_copy_tail(mp->mp_bh[n], sizeof(struct gfs2_meta_header),
dibh, sizeof(struct gfs2_dinode));
- brelse(blocks[n]);
+ brelse(mp->mp_bh[n]);
gfs2_trans_add_bh(ip->i_gl, dibh, 1);
di = (struct gfs2_dinode *)dibh->b_data;
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
struct metapath *mp)
{
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
- u64 b = block;
unsigned int i;
for (i = ip->i_height; i--;)
- mp->mp_list[i] = do_div(b, sdp->sd_inptrs);
+ mp->mp_list[i] = do_div(block, sdp->sd_inptrs);
}
/**
* metapointer - Return pointer to start of metadata in a buffer
- * @bh: The buffer
* @height: The metadata height (0 = dinode)
* @mp: The metapath
*
* metadata tree.
*/
-static inline __be64 *metapointer(struct buffer_head *bh, int *boundary,
- unsigned int height, const struct metapath *mp)
+static inline __be64 *metapointer(int *boundary, unsigned int height,
+ const struct metapath *mp)
{
+ struct buffer_head *bh = mp->mp_bh[height];
unsigned int head_size = (height > 0) ?
sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
__be64 *ptr;
/**
* lookup_block - Get the next metadata block in metadata tree
* @ip: The GFS2 inode
- * @bh: Buffer containing the pointers to metadata blocks
* @height: The height of the tree (0 = dinode)
* @mp: The metapath
* @create: Non-zero if we may create a new meatdata block
*
*/
-static int lookup_block(struct gfs2_inode *ip, struct buffer_head *bh,
- unsigned int height, struct metapath *mp, int create,
+static int lookup_block(struct gfs2_inode *ip, unsigned int height,
+ struct metapath *mp, int create,
int *new, u64 *block)
{
int boundary;
- __be64 *ptr = metapointer(bh, &boundary, height, mp);
+ __be64 *ptr = metapointer(&boundary, height, mp);
if (*ptr) {
*block = be64_to_cpu(*ptr);
if (height == ip->i_height - 1 && !gfs2_is_dir(ip))
*block = gfs2_alloc_data(ip);
- else
+ else {
*block = gfs2_alloc_meta(ip);
+ gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), *block, 1);
+ }
- gfs2_trans_add_bh(ip->i_gl, bh, 1);
+ gfs2_trans_add_bh(ip->i_gl, mp->mp_bh[height], 1);
*ptr = cpu_to_be64(*block);
ip->i_di.di_blocks++;
return 0;
}
+static int lookup_metapath(struct inode *inode, struct metapath *mp,
+ int create, int *new, u64 *dblock)
+{
+ struct buffer_head *bh;
+ struct gfs2_inode *ip = GFS2_I(inode);
+ unsigned int end_of_metadata = ip->i_height - 1;
+ unsigned int x;
+ int ret = gfs2_meta_inode_buffer(ip, &bh);
+ if (ret)
+ return ret;
+
+ mp->mp_bh[0] = bh;
+
+ for (x = 0; x < end_of_metadata; x++) {
+ lookup_block(ip, x, mp, create, new, dblock);
+ if (!dblock)
+ return 0;
+
+ ret = gfs2_meta_indirect_buffer(ip, x+1, *dblock, *new, &mp->mp_bh[x+1]);
+ if (ret)
+ return ret;
+ }
+
+ return lookup_block(ip, end_of_metadata, mp, create, new, dblock);
+}
+
+static void release_metapath(struct metapath *mp)
+{
+ int i;
+
+ for (i = 0; i < GFS2_MAX_META_HEIGHT; i++)
+ if (mp->mp_bh[i])
+ brelse(mp->mp_bh[i]);
+}
+
static inline void bmap_lock(struct inode *inode, int create)
{
struct gfs2_inode *ip = GFS2_I(inode);
{
struct gfs2_inode *ip = GFS2_I(inode);
struct gfs2_sbd *sdp = GFS2_SB(inode);
- struct buffer_head *bh;
unsigned int bsize = sdp->sd_sb.sb_bsize;
- unsigned int end_of_metadata;
- unsigned int x;
int error = 0;
int new = 0;
u64 dblock = 0;
unsigned int maxlen = bh_map->b_size >> inode->i_blkbits;
struct metapath mp;
u64 size;
- struct buffer_head *dibh = NULL;
const u64 *arr = sdp->sd_heightsize;
BUG_ON(maxlen == 0);
if (gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
return 0;
+ memset(mp.mp_bh, 0, sizeof(mp.mp_bh));
bmap_lock(inode, create);
clear_buffer_mapped(bh_map);
clear_buffer_new(bh_map);
goto out_ok;
while (size > arr[height])
height++;
- error = build_height(inode, height);
+ error = build_height(inode, &mp, height);
if (error)
goto out_fail;
}
find_metapath(ip, lblock, &mp);
- end_of_metadata = ip->i_height - 1;
- error = gfs2_meta_inode_buffer(ip, &bh);
- if (error)
+ error = lookup_metapath(inode, &mp, create, &new, &dblock);
+ if (error < 0)
goto out_fail;
- dibh = bh;
- get_bh(dibh);
-
- for (x = 0; x < end_of_metadata; x++) {
- lookup_block(ip, bh, x, &mp, create, &new, &dblock);
- brelse(bh);
- if (!dblock)
- goto out_ok;
+ boundary = error;
- error = gfs2_meta_indirect_buffer(ip, x+1, dblock, new, &bh);
- if (error)
- goto out_fail;
- }
-
- boundary = lookup_block(ip, bh, end_of_metadata, &mp, create, &new, &dblock);
if (dblock) {
map_bh(bh_map, inode->i_sb, dblock);
if (boundary)
set_buffer_boundary(bh_map);
if (new) {
- gfs2_trans_add_bh(ip->i_gl, dibh, 1);
- gfs2_dinode_out(ip, dibh->b_data);
+ gfs2_trans_add_bh(ip->i_gl, mp.mp_bh[0], 1);
+ gfs2_dinode_out(ip, mp.mp_bh[0]->b_data);
set_buffer_new(bh_map);
- goto out_brelse;
+ goto out_ok;
}
while(--maxlen && !buffer_boundary(bh_map)) {
u64 eblock;
-
- mp.mp_list[end_of_metadata]++;
- boundary = lookup_block(ip, bh, end_of_metadata, &mp, 0, &new, &eblock);
+ mp.mp_list[ip->i_height - 1]++;
+ boundary = lookup_block(ip, ip->i_height - 1, &mp, 0, &new, &eblock);
if (eblock != ++dblock)
break;
bh_map->b_size += (1 << inode->i_blkbits);
set_buffer_boundary(bh_map);
}
}
-out_brelse:
- brelse(bh);
out_ok:
error = 0;
out_fail:
- if (dibh)
- brelse(dibh);
+ release_metapath(&mp);
bmap_unlock(inode, create);
return error;
}
else
goto out; /* Nothing to do */
- gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE, 0);
+ gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
for (x = 0; x < rlist.rl_rgrps; x++) {
struct gfs2_rgrpd *rgd;
down_write(&ip->i_rw_mutex);
if (size > arr[ip->i_height]) {
+ struct metapath mp;
u8 height = ip->i_height;
while(size > arr[height])
height++;
- error = build_height(&ip->i_inode, height);
+ error = build_height(&ip->i_inode, &mp, height);
}
up_write(&ip->i_rw_mutex);
if (error)
if (!ip->i_di.di_size) {
ip->i_height = 0;
- ip->i_di.di_goal_meta =
- ip->i_di.di_goal_data =
- ip->i_no_addr;
+ ip->i_goal = ip->i_no_addr;
gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
}
ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blobdiff