#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
-#include <asm/semaphore.h>
+#include <linux/gfs2_ondisk.h>
+#include <linux/crc32.h>
#include "gfs2.h"
+#include "lm_interface.h"
+#include "incore.h"
#include "bmap.h"
#include "glock.h"
#include "inode.h"
#include "rgrp.h"
#include "trans.h"
#include "dir.h"
+#include "util.h"
/* This doesn't need to be that large as max 64 bit pointers in a 4k
* block is 512, so __u16 is fine for that. It saves stack space to
};
/**
- * @gfs2_unstuffer_sync - Synchronously unstuff a dinode
- * @ip:
- * @dibh:
- * @block:
- * @private:
- *
- * Cheat and use a metadata buffer instead of a data page.
- *
- * Returns: errno
- */
-
-int gfs2_unstuffer_sync(struct gfs2_inode *ip, struct buffer_head *dibh,
- uint64_t block, void *private)
-{
- struct buffer_head *bh;
- int error;
-
- bh = gfs2_meta_new(ip->i_gl, block);
-
- gfs2_buffer_copy_tail(bh, 0, dibh, sizeof(struct gfs2_dinode));
-
- set_buffer_dirty(bh);
- error = sync_dirty_buffer(bh);
-
- brelse(bh);
-
- return error;
-}
-
-/**
* gfs2_unstuff_dinode - Unstuff a dinode when the data has grown too big
* @ip: The GFS2 inode to unstuff
* @unstuffer: the routine that handles unstuffing a non-zero length file
if (isdir) {
block = gfs2_alloc_meta(ip);
- error = gfs2_dir_get_buffer(ip, block, 1, &bh);
+ error = gfs2_dir_get_new_buffer(ip, block, &bh);
if (error)
goto out_brelse;
gfs2_buffer_copy_tail(bh,
* @ip: The GFS2 inode
* @height: The height to build to
*
- * This routine makes sure that the metadata tree is tall enough to hold
- * "size" bytes of data.
*
* Returns: errno
*/
-static int build_height(struct gfs2_inode *ip, int height)
+static int build_height(struct inode *inode, unsigned height)
{
- struct gfs2_sbd *sdp = ip->i_sbd;
- struct buffer_head *bh, *dibh;
- uint64_t block = 0, *bp;
- unsigned int x;
- int new_block;
+ struct gfs2_inode *ip = inode->u.generic_ip;
+ unsigned new_height = height - ip->i_di.di_height;
+ struct buffer_head *dibh;
+ struct buffer_head *blocks[GFS2_MAX_META_HEIGHT];
int error;
+ u64 *bp;
+ u64 bn;
+ unsigned n;
- while (ip->i_di.di_height < height) {
- error = gfs2_meta_inode_buffer(ip, &dibh);
- if (error)
- return error;
-
- new_block = 0;
- bp = (uint64_t *)(dibh->b_data + sizeof(struct gfs2_dinode));
- for (x = 0; x < sdp->sd_diptrs; x++, bp++)
- if (*bp) {
- new_block = 1;
- break;
- }
-
- if (new_block) {
- /* Get a new block, fill it with the old direct
- pointers, and write it out */
+ if (height <= ip->i_di.di_height)
+ return 0;
- block = gfs2_alloc_meta(ip);
+ error = gfs2_meta_inode_buffer(ip, &dibh);
+ if (error)
+ return error;
- bh = gfs2_meta_new(ip->i_gl, block);
- gfs2_trans_add_bh(ip->i_gl, bh, 1);
- gfs2_metatype_set(bh,
- GFS2_METATYPE_IN,
+ 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);
+ }
+
+ n = 0;
+ bn = blocks[0]->b_blocknr;
+ if (new_height > 1) {
+ for(; n < new_height-1; n++) {
+ gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN,
GFS2_FORMAT_IN);
- gfs2_buffer_copy_tail(bh,
- sizeof(struct gfs2_meta_header),
- dibh, sizeof(struct gfs2_dinode));
-
- brelse(bh);
- }
-
- /* Set up the new direct pointer and write it out to disk */
-
- gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-
- gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
-
- if (new_block) {
- *(uint64_t *)(dibh->b_data +
- sizeof(struct gfs2_dinode)) =
- cpu_to_be64(block);
- ip->i_di.di_blocks++;
+ gfs2_buffer_clear_tail(blocks[n],
+ sizeof(struct gfs2_meta_header));
+ bp = (u64 *)(blocks[n]->b_data +
+ sizeof(struct gfs2_meta_header));
+ *bp = cpu_to_be64(blocks[n+1]->b_blocknr);
+ brelse(blocks[n]);
+ blocks[n] = NULL;
}
-
- ip->i_di.di_height++;
-
- gfs2_dinode_out(&ip->i_di, dibh->b_data);
- brelse(dibh);
}
-
- return 0;
+ gfs2_metatype_set(blocks[n], GFS2_METATYPE_IN, GFS2_FORMAT_IN);
+ gfs2_buffer_copy_tail(blocks[n], sizeof(struct gfs2_meta_header),
+ dibh, sizeof(struct gfs2_dinode));
+ brelse(blocks[n]);
+ gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+ gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
+ bp = (u64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
+ *bp = cpu_to_be64(bn);
+ ip->i_di.di_height += new_height;
+ ip->i_di.di_blocks += new_height;
+ gfs2_dinode_out(&ip->i_di, dibh->b_data);
+ brelse(dibh);
+ return error;
}
/**
* metadata tree.
*/
-static inline uint64_t *metapointer(struct buffer_head *bh,
- unsigned int height, struct metapath *mp)
+static inline u64 *metapointer(struct buffer_head *bh, int *boundary,
+ unsigned int height, const struct metapath *mp)
{
unsigned int head_size = (height > 0) ?
sizeof(struct gfs2_meta_header) : sizeof(struct gfs2_dinode);
-
- return ((uint64_t *)(bh->b_data + head_size)) + mp->mp_list[height];
+ u64 *ptr;
+ *boundary = 0;
+ ptr = ((u64 *)(bh->b_data + head_size)) + mp->mp_list[height];
+ if (ptr + 1 == (u64*)(bh->b_data + bh->b_size))
+ *boundary = 1;
+ return ptr;
}
/**
*
*/
-static void lookup_block(struct gfs2_inode *ip, struct buffer_head *bh,
- unsigned int height, struct metapath *mp, int create,
- int *new, uint64_t *block)
+static int lookup_block(struct gfs2_inode *ip, struct buffer_head *bh,
+ unsigned int height, struct metapath *mp, int create,
+ int *new, uint64_t *block)
{
- uint64_t *ptr = metapointer(bh, height, mp);
+ int boundary;
+ uint64_t *ptr = metapointer(bh, &boundary, height, mp);
if (*ptr) {
*block = be64_to_cpu(*ptr);
- return;
+ return boundary;
}
*block = 0;
if (!create)
- return;
+ return 0;
- if (height == ip->i_di.di_height - 1 &&
- !gfs2_is_dir(ip))
+ if (height == ip->i_di.di_height - 1 && !gfs2_is_dir(ip))
*block = gfs2_alloc_data(ip);
else
*block = gfs2_alloc_meta(ip);
ip->i_di.di_blocks++;
*new = 1;
+ return 0;
}
/**
- * gfs2_block_map - Map a block from an inode to a disk block
- * @ip: The GFS2 inode
+ * gfs2_block_pointers - Map a block from an inode to a disk block
+ * @inode: The inode
* @lblock: The logical block number
* @new: Value/Result argument (1 = may create/did create new blocks)
- * @dblock: the disk block number of the start of an extent
- * @extlen: the size of the extent
+ * @boundary: gets set if we've hit a block boundary
+ * @mp: metapath to use
*
* Find the block number on the current device which corresponds to an
* inode's block. If the block had to be created, "new" will be set.
* Returns: errno
*/
-int gfs2_block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,
- uint64_t *dblock, uint32_t *extlen)
+static struct buffer_head *gfs2_block_pointers(struct inode *inode, u64 lblock,
+ int *new, u64 *dblock,
+ int *boundary,
+ struct metapath *mp)
{
+ struct gfs2_inode *ip = inode->u.generic_ip;
struct gfs2_sbd *sdp = ip->i_sbd;
struct buffer_head *bh;
- struct metapath mp;
int create = *new;
unsigned int bsize;
unsigned int height;
*new = 0;
*dblock = 0;
- if (extlen)
- *extlen = 0;
-
- if (create)
- down_write(&ip->i_rw_mutex);
- else
- down_read(&ip->i_rw_mutex);
if (gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
goto out;
if (!create)
goto out;
- error = build_height(ip, height);
+ error = build_height(inode, height);
if (error)
goto out;
}
- find_metapath(ip, lblock, &mp);
+ find_metapath(ip, lblock, mp);
end_of_metadata = ip->i_di.di_height - 1;
error = gfs2_meta_inode_buffer(ip, &bh);
goto out;
for (x = 0; x < end_of_metadata; x++) {
- lookup_block(ip, bh, x, &mp, create, new, dblock);
+ lookup_block(ip, bh, x, mp, create, new, dblock);
brelse(bh);
if (!*dblock)
goto out;
goto out;
}
- lookup_block(ip, bh, end_of_metadata, &mp, create, new, dblock);
-
- if (extlen && *dblock) {
- *extlen = 1;
-
- if (!*new) {
- uint64_t tmp_dblock;
- int tmp_new;
- unsigned int nptrs;
-
- nptrs = (end_of_metadata) ? sdp->sd_inptrs :
- sdp->sd_diptrs;
-
- while (++mp.mp_list[end_of_metadata] < nptrs) {
- lookup_block(ip, bh, end_of_metadata, &mp,
- 0, &tmp_new, &tmp_dblock);
-
- if (*dblock + *extlen != tmp_dblock)
- break;
-
- (*extlen)++;
- }
- }
- }
-
- brelse(bh);
-
+ *boundary = lookup_block(ip, bh, end_of_metadata, mp, create, new, dblock);
if (*new) {
- error = gfs2_meta_inode_buffer(ip, &bh);
+ struct buffer_head *dibh;
+ error = gfs2_meta_inode_buffer(ip, &dibh);
if (!error) {
- gfs2_trans_add_bh(ip->i_gl, bh, 1);
- gfs2_dinode_out(&ip->i_di, bh->b_data);
- brelse(bh);
+ gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+ gfs2_dinode_out(&ip->i_di, dibh->b_data);
+ brelse(dibh);
}
}
+ return bh;
+out:
+ return ERR_PTR(error);
+}
- out:
+
+static inline void bmap_lock(struct inode *inode, int create)
+{
+ struct gfs2_inode *ip = inode->u.generic_ip;
+ if (create)
+ down_write(&ip->i_rw_mutex);
+ else
+ down_read(&ip->i_rw_mutex);
+}
+
+static inline void bmap_unlock(struct inode *inode, int create)
+{
+ struct gfs2_inode *ip = inode->u.generic_ip;
if (create)
up_write(&ip->i_rw_mutex);
else
up_read(&ip->i_rw_mutex);
+}
- return error;
+int gfs2_block_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, int *boundary)
+{
+ struct metapath mp;
+ struct buffer_head *bh;
+ int create = *new;
+
+ bmap_lock(inode, create);
+ bh = gfs2_block_pointers(inode, lblock, new, dblock, boundary, &mp);
+ bmap_unlock(inode, create);
+ if (!bh)
+ return 0;
+ if (IS_ERR(bh))
+ return PTR_ERR(bh);
+ brelse(bh);
+ return 0;
+}
+
+int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen)
+{
+ struct gfs2_inode *ip = inode->u.generic_ip;
+ struct gfs2_sbd *sdp = ip->i_sbd;
+ struct metapath mp;
+ struct buffer_head *bh;
+ int boundary;
+ int create = *new;
+
+ BUG_ON(!extlen);
+ BUG_ON(!dblock);
+ BUG_ON(!new);
+
+ bmap_lock(inode, create);
+ bh = gfs2_block_pointers(inode, lblock, new, dblock, &boundary, &mp);
+ *extlen = 1;
+
+ if (bh && !IS_ERR(bh) && *dblock && !*new) {
+ u64 tmp_dblock;
+ int tmp_new;
+ unsigned int nptrs;
+ unsigned end_of_metadata = ip->i_di.di_height - 1;
+
+ nptrs = (end_of_metadata) ? sdp->sd_inptrs : sdp->sd_diptrs;
+ while (++mp.mp_list[end_of_metadata] < nptrs) {
+ lookup_block(ip, bh, end_of_metadata, &mp, 0, &tmp_new, &tmp_dblock);
+ if (*dblock + *extlen != tmp_dblock)
+ break;
+ (*extlen)++;
+ }
+ }
+ bmap_unlock(inode, create);
+ if (!bh)
+ return 0;
+ if (IS_ERR(bh))
+ return PTR_ERR(bh);
+ brelse(bh);
+ return 0;
}
/**
for (x = 0; x < rlist.rl_rgrps; x++) {
struct gfs2_rgrpd *rgd;
- rgd = get_gl2rgd(rlist.rl_ghs[x].gh_gl);
+ rgd = rlist.rl_ghs[x].gh_gl->gl_object;
rg_blocks += rgd->rd_ri.ri_length;
}
h = calc_tree_height(ip, size);
if (ip->i_di.di_height < h) {
down_write(&ip->i_rw_mutex);
- error = build_height(ip, h);
+ error = build_height(ip->i_vnode, h);
up_write(&ip->i_rw_mutex);
if (error)
goto out_end_trans;
unsigned int tmp;
if (gfs2_is_dir(ip)) {
- *data_blocks = DIV_RU(len, sdp->sd_jbsize) + 2;
+ *data_blocks = DIV_ROUND_UP(len, sdp->sd_jbsize) + 2;
*ind_blocks = 3 * (sdp->sd_max_jheight - 1);
} else {
*data_blocks = (len >> sdp->sd_sb.sb_bsize_shift) + 3;
}
for (tmp = *data_blocks; tmp > sdp->sd_diptrs;) {
- tmp = DIV_RU(tmp, sdp->sd_inptrs);
+ tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs);
*ind_blocks += tmp;
}
}
}
for (; lblock < lblock_stop; lblock += extlen) {
- error = gfs2_block_map(ip, lblock, &new, &dblock, &extlen);
+ error = gfs2_extent_map(ip->i_vnode, lblock, &new, &dblock, &extlen);
if (error)
return error;
git://ftp.safe.ca / safe / jmp / linux-2.6 / blobdiff