#include "clusterautoconfig.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <inttypes.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include <linux/types.h>

#include "libgfs2.h"

#include "rgrp.h"

static __inline__ uint64_t *metapointer(struct gfs2_buffer_head *bh,

					unsigned int height,

					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];

}

/* Detect directory is a stuffed inode */

static int inode_is_stuffed(const struct gfs2_inode *ip)

{

	return !ip->i_di.di_height;

}

struct gfs2_inode *lgfs2_inode_get(struct gfs2_sbd *sdp, struct gfs2_buffer_head *bh)

{

	struct gfs2_inode *ip;

	ip = calloc(1, sizeof(struct gfs2_inode));

	if (ip == NULL) {

		return NULL;

	}

	gfs2_dinode_in(&ip->i_di, bh->b_data);

	ip->i_bh = bh;

	ip->i_sbd = sdp;

	return ip;

}

struct gfs2_inode *lgfs2_inode_read(struct gfs2_sbd *sdp, uint64_t di_addr)

{

	struct gfs2_inode *ip;

	struct gfs2_buffer_head *bh = bread(sdp, di_addr);

	if (bh == NULL) {

		return NULL;

	}

	ip = lgfs2_inode_get(sdp, bh);

	if (ip == NULL) {

		brelse(bh);

		return NULL;

	}

	ip->bh_owned = 1; /* We did the bread so we own the bh */

	return ip;

}

struct gfs2_inode *is_system_inode(struct gfs2_sbd *sdp, uint64_t block)

{

	int j;

	if (sdp->md.inum && block == sdp->md.inum->i_di.di_num.no_addr)

		return sdp->md.inum;

	if (sdp->md.statfs && block == sdp->md.statfs->i_di.di_num.no_addr)

		return sdp->md.statfs;

	if (sdp->md.jiinode && block == sdp->md.jiinode->i_di.di_num.no_addr)

		return sdp->md.jiinode;

	if (sdp->md.riinode && block == sdp->md.riinode->i_di.di_num.no_addr)

		return sdp->md.riinode;

	if (sdp->md.qinode && block == sdp->md.qinode->i_di.di_num.no_addr)

		return sdp->md.qinode;

	if (sdp->md.pinode && block == sdp->md.pinode->i_di.di_num.no_addr)

		return sdp->md.pinode;

	if (sdp->md.rooti && block == sdp->md.rooti->i_di.di_num.no_addr)

		return sdp->md.rooti;

	if (sdp->master_dir && block == sdp->master_dir->i_di.di_num.no_addr)

		return sdp->master_dir;

	for (j = 0; j < sdp->md.journals; j++)

		if (sdp->md.journal && sdp->md.journal[j] &&

		    block == sdp->md.journal[j]->i_di.di_num.no_addr)

			return sdp->md.journal[j];

	return NULL;

}

void inode_put(struct gfs2_inode **ip_in)

{

	struct gfs2_inode *ip = *ip_in;

	uint64_t block = ip->i_di.di_num.no_addr;

	struct gfs2_sbd *sdp = ip->i_sbd;

	if (ip->i_bh->b_modified) {

		gfs2_dinode_out(&ip->i_di, ip->i_bh->b_data);

		if (!ip->bh_owned && is_system_inode(sdp, block))

			fprintf(stderr, "Warning: Change made to inode "

				"were discarded.\n");

		/* This is for debugging only: a convenient place to set

		   a breakpoint. This means a system inode was modified but

		   not written.  That's not fatal: some places like

		   adjust_inode in gfs2_convert will do this on purpose.

		   It can also point out a coding problem, but we don't

		   want to raise alarm in the users either. */

	}

	if (ip->bh_owned)

		brelse(ip->i_bh);

	ip->i_bh = NULL;

	free(ip);

	*ip_in = NULL; /* make sure the memory isn't accessed again */

}

static uint64_t find_free_block(struct rgrp_tree *rgd)

{

	unsigned bm;

	uint64_t blkno = 0;

	if (rgd == NULL || rgd->rg.rg_free == 0) {

		errno = ENOSPC;

		return 0;

	}

	for (bm = 0; bm < rgd->ri.ri_length; bm++) {

		unsigned long blk = 0;

		struct gfs2_bitmap *bits = &rgd->bits[bm];

		blk = gfs2_bitfit((uint8_t *)bits->bi_bh->b_data + bits->bi_offset,

		                  bits->bi_len, blk, GFS2_BLKST_FREE);

		if (blk != BFITNOENT) {

			blkno = blk + (bits->bi_start * GFS2_NBBY) + rgd->ri.ri_data0;

			break;

		}

	}

	return blkno;

}

static int blk_alloc_in_rg(struct gfs2_sbd *sdp, unsigned state, struct rgrp_tree *rgd, uint64_t blkno, int dinode)

{

	if (blkno == 0)

		return -1;

	if (gfs2_set_bitmap(rgd, blkno, state))

		return -1;

	if (state == GFS2_BLKST_DINODE) {

		struct gfs_rgrp *gfs1rg = (struct gfs_rgrp *)&rgd->rg;

		if (dinode)

			rgd->rg.rg_dinodes++;

		else if (sdp->gfs1)

			gfs1rg->rg_usedmeta++;

	}

	rgd->rg.rg_free--;

	if (sdp->gfs1)

		gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh);

	else

		gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);

	bmodified(rgd->bits[0].bi_bh);

	sdp->blks_alloced++;

	return 0;

}

/**

 * Allocate a block in a bitmap. In order to plan ahead we look for a

 * resource group with blksreq free blocks but only allocate the one block.

 * Returns 0 on success with the allocated block number in *blkno or non-zero otherwise.

 */

static int block_alloc(struct gfs2_sbd *sdp, const uint64_t blksreq, int state, uint64_t *blkno, int dinode)

{

	int ret;

	int release = 0;

	struct rgrp_tree *rgt = NULL;

	struct osi_node *n = NULL;

	uint64_t bn = 0;

	for (n = osi_first(&sdp->rgtree); n; n = osi_next(n)) {

		rgt = (struct rgrp_tree *)n;

		if (rgt->rg.rg_free >= blksreq)

			break;

	}

	if (rgt == NULL)

		return -1;

	if (rgt->bits[0].bi_bh == NULL) {

		if (gfs2_rgrp_read(sdp, rgt))

			return -1;

		release = 1;

	}

	bn = find_free_block(rgt);

	ret = blk_alloc_in_rg(sdp, state, rgt, bn, dinode);

	if (release)

		gfs2_rgrp_relse(rgt);

	*blkno = bn;

	return ret;

}

int lgfs2_dinode_alloc(struct gfs2_sbd *sdp, const uint64_t blksreq, uint64_t *blkno)

{

	int ret = block_alloc(sdp, blksreq, GFS2_BLKST_DINODE, blkno, TRUE);

	if (ret == 0)

		sdp->dinodes_alloced++;

	return ret;

}

int lgfs2_meta_alloc(struct gfs2_inode *ip, uint64_t *blkno)

{

	int ret = block_alloc(ip->i_sbd, 1,

			      ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :

			      GFS2_BLKST_USED, blkno, FALSE);

	if (ret == 0) {

		ip->i_di.di_goal_meta = *blkno;

		bmodified(ip->i_bh);

	}

	return ret;

}

static __inline__ void buffer_clear_tail(struct gfs2_sbd *sdp,

					 struct gfs2_buffer_head *bh, int head)

{

	memset(bh->b_data + head, 0, sdp->bsize - head);

	bmodified(bh);

}

static __inline__ void

buffer_copy_tail(struct gfs2_sbd *sdp,

		 struct gfs2_buffer_head *to_bh, int to_head,

		 struct gfs2_buffer_head *from_bh, int from_head)

{

	memcpy(to_bh->b_data + to_head, from_bh->b_data + from_head,

	       sdp->bsize - from_head);

	memset(to_bh->b_data + sdp->bsize + to_head - from_head, 0,

	       from_head - to_head);

	bmodified(to_bh);

}

void unstuff_dinode(struct gfs2_inode *ip)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *bh;

	uint64_t block = 0;

	int isdir = S_ISDIR(ip->i_di.di_mode) || is_gfs_dir(&ip->i_di);

	if (ip->i_di.di_size) {

		if (lgfs2_meta_alloc(ip, &block))

			exit(1);

		if (isdir) {

			struct gfs2_meta_header mh;

			bh = bget(sdp, block);

			mh.mh_magic = GFS2_MAGIC;

			mh.mh_type = GFS2_METATYPE_JD;

			mh.mh_format = GFS2_FORMAT_JD;

			gfs2_meta_header_out(&mh, bh->b_data);

			buffer_copy_tail(sdp, bh,

					 sizeof(struct gfs2_meta_header),

					 ip->i_bh, sizeof(struct gfs2_dinode));

			bmodified(bh);

			brelse(bh);

		} else {

			bh = bget(sdp, block);

			buffer_copy_tail(sdp, bh, 0,

					 ip->i_bh, sizeof(struct gfs2_dinode));

			brelse(bh);

		}

	}

	buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));

	if (ip->i_di.di_size) {

		*(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);

		/* no need: bmodified(ip->i_bh); buffer_clear_tail does it */

		ip->i_di.di_blocks++;

	}

	ip->i_di.di_height = 1;

}

/**

 * Calculate the total number of blocks required by a file containing 'bytes' bytes of data.

 */

uint64_t lgfs2_space_for_data(const struct gfs2_sbd *sdp, const unsigned bsize, const uint64_t bytes)

{

	uint64_t blks = (bytes + bsize - 1) / bsize;

	uint64_t ptrs = blks;

	if (bytes <= bsize - sizeof(struct gfs2_dinode))

		return 1;

	while (ptrs > sdp->sd_diptrs) {

		ptrs = (ptrs + sdp->sd_inptrs - 1) / sdp->sd_inptrs;

		blks += ptrs;

	}

	return blks + 1;

}

/**

 * Allocate an extent for a file in a resource group's bitmaps.

 * rg: The resource group in which to allocate the extent

 * di_size: The size of the file in bytes

 * ip: A pointer to the inode structure, whose fields will be set appropriately.

 *     If ip->i_di.di_num.no_addr is not 0, the extent search will be skipped and

 *     the file allocated from that address.

 * flags: GFS2_DIF_* flags

 * mode: File mode flags, see creat(2)

 * Returns 0 on success with the contents of ip set accordingly, or non-zero

 * with errno set on error. If errno is ENOSPC then rg does not contain a

 * large enough free extent for the given di_size.

 */

int lgfs2_file_alloc(lgfs2_rgrp_t rg, uint64_t di_size, struct gfs2_inode *ip, uint32_t flags, unsigned mode)

{

	unsigned extlen;

	struct gfs2_dinode *di = &ip->i_di;

	struct gfs2_sbd *sdp = rg->rgrps->sdp;

	struct lgfs2_rbm rbm = { .rgd = rg, .offset = 0, .bii = 0 };

	uint32_t blocks = lgfs2_space_for_data(sdp, sdp->bsize, di_size);

	if (ip->i_di.di_num.no_addr != 0) {

		if (lgfs2_rbm_from_block(&rbm, ip->i_di.di_num.no_addr) != 0)

			return 1;

	} else if (lgfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &blocks) != 0) {

		return 1;

	}

	extlen = lgfs2_alloc_extent(&rbm, GFS2_BLKST_DINODE, blocks);

	if (extlen < blocks) {

		errno = EINVAL;

		return 1;

	}

	ip->i_sbd = sdp;

	di->di_header.mh_magic = GFS2_MAGIC;

	di->di_header.mh_type = GFS2_METATYPE_DI;

	di->di_header.mh_format = GFS2_FORMAT_DI;

	di->di_size = di_size;

	di->di_num.no_addr = lgfs2_rbm_to_block(&rbm;;

	di->di_num.no_formal_ino = sdp->md.next_inum++;

	di->di_mode = mode;

	di->di_nlink = 1;

	di->di_blocks = blocks;

	di->di_atime = di->di_mtime = di->di_ctime = sdp->time;

	di->di_goal_data = di->di_num.no_addr + di->di_blocks - 1;

	di->di_goal_meta = di->di_goal_data - ((di_size + sdp->bsize - 1) / sdp->bsize);

	di->di_height = calc_tree_height(ip, di_size);

	di->di_flags = flags;

	rg->rg.rg_free -= blocks;

	rg->rg.rg_dinodes += 1;

	sdp->dinodes_alloced++;

	sdp->blks_alloced += blocks;

	return 0;

}

unsigned int calc_tree_height(struct gfs2_inode *ip, uint64_t size)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	uint64_t *arr;

	unsigned int max, height;

	if (ip->i_di.di_size > size)

		size = ip->i_di.di_size;

	if (S_ISDIR(ip->i_di.di_mode)) {

		arr = sdp->sd_jheightsize;

		max = sdp->sd_max_jheight;

	} else {

		arr = sdp->sd_heightsize;

		max = sdp->sd_max_height;

	}

	for (height = 0; height < max; height++)

		if (arr[height] >= size)

			break;

	return height;

}

void build_height(struct gfs2_inode *ip, int height)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *bh;

	uint64_t block = 0, *bp;

	unsigned int x;

	int new_block;

	while (ip->i_di.di_height < height) {

		new_block = FALSE;

		bp = (uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode));

		for (x = 0; x < sdp->sd_diptrs; x++, bp++)

			if (*bp) {

				new_block = TRUE;

				break;

			}

		if (new_block) {

			struct gfs2_meta_header mh;

			if (lgfs2_meta_alloc(ip, &block))

				exit(1);

			bh = bget(sdp, block);

			mh.mh_magic = GFS2_MAGIC;

			mh.mh_type = GFS2_METATYPE_IN;

			mh.mh_format = GFS2_FORMAT_IN;

			gfs2_meta_header_out(&mh, bh->b_data);

			buffer_copy_tail(sdp, bh,

					 sizeof(struct gfs2_meta_header),

					 ip->i_bh, sizeof(struct gfs2_dinode));

			bmodified(bh);

			brelse(bh);

		}

		buffer_clear_tail(sdp, ip->i_bh, sizeof(struct gfs2_dinode));

		if (new_block) {

			*(uint64_t *)(ip->i_bh->b_data + sizeof(struct gfs2_dinode)) = cpu_to_be64(block);

			/* no need: bmodified(ip->i_bh);*/

			ip->i_di.di_blocks++;

		}

		ip->i_di.di_height++;

	}

}

void find_metapath(struct gfs2_inode *ip, uint64_t block, struct metapath *mp)

{

	const uint32_t inptrs = ip->i_sbd->sd_inptrs;

	unsigned int i = ip->i_di.di_height;

	memset(mp, 0, sizeof(struct metapath));

	while (i--) {

		mp->mp_list[i] = block % inptrs;

		block /= inptrs;

	}

}

void lookup_block(struct gfs2_inode *ip, struct gfs2_buffer_head *bh,

		  unsigned int height, struct metapath *mp,

		  int create, int *new, uint64_t *block)

{

	uint64_t *ptr = metapointer(bh, height, mp);

	if (*ptr) {

		*block = be64_to_cpu(*ptr);

		return;

	}

	*block = 0;

	if (!create)

		return;

	if (lgfs2_meta_alloc(ip, block))

		return;

	*ptr = cpu_to_be64(*block);

	bmodified(bh);

	ip->i_di.di_blocks++;

	bmodified(ip->i_bh);

	*new = 1;

}

void block_map(struct gfs2_inode *ip, uint64_t lblock, int *new,

	       uint64_t *dblock, uint32_t *extlen, int prealloc)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *bh;

	struct metapath mp;

	int create = *new;

	unsigned int bsize;

	unsigned int height;

	unsigned int end_of_metadata;

	unsigned int x;

	*new = 0;

	*dblock = 0;

	if (extlen)

		*extlen = 0;

	if (inode_is_stuffed(ip)) {

		if (!lblock) {

			*dblock = ip->i_di.di_num.no_addr;

			if (extlen)

				*extlen = 1;

		}

		return;

	}

	bsize = (S_ISDIR(ip->i_di.di_mode)) ? sdp->sd_jbsize : sdp->bsize;

	height = calc_tree_height(ip, (lblock + 1) * bsize);

	if (ip->i_di.di_height < height) {

		if (!create)

			return;

		build_height(ip, height);

	}

	find_metapath(ip, lblock, &mp);

	end_of_metadata = ip->i_di.di_height - 1;

	bh = ip->i_bh;

	for (x = 0; x < end_of_metadata; x++) {

		lookup_block(ip, bh, x, &mp, create, new, dblock);

		if (bh != ip->i_bh)

			brelse(bh);

		if (!*dblock)

			return;

		if (*new) {

			struct gfs2_meta_header mh;

			bh = bget(sdp, *dblock);

			mh.mh_magic = GFS2_MAGIC;

			mh.mh_type = GFS2_METATYPE_IN;

			mh.mh_format = GFS2_FORMAT_IN;

			gfs2_meta_header_out(&mh, bh->b_data);

			bmodified(bh);

		} else {

			if (*dblock == ip->i_di.di_num.no_addr)

				bh = ip->i_bh;

			else

				bh = bread(sdp, *dblock);

		}

	}

	if (!prealloc)

		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, FALSE, &tmp_new,

							 &tmp_dblock);

				if (*dblock + *extlen != tmp_dblock)

					break;

				(*extlen)++;

			}

		}

	}

	if (bh != ip->i_bh)

		brelse(bh);

}

static void

copy2mem(struct gfs2_buffer_head *bh, void **buf, unsigned int offset,

	 unsigned int size)

{

	char **p = (char **)buf;

	if (bh)

		memcpy(*p, bh->b_data + offset, size);

	else

		memset(*p, 0, size);

	*p += size;

}

int gfs2_readi(struct gfs2_inode *ip, void *buf,

			   uint64_t offset, unsigned int size)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *bh;

	uint64_t lblock, dblock;

	unsigned int o;

	uint32_t extlen = 0;

	unsigned int amount;

	int not_new = 0;

	int isdir = !!(S_ISDIR(ip->i_di.di_mode));

	int journaled = ip->i_di.di_flags & GFS2_DIF_JDATA;

	int copied = 0;

	if (offset >= ip->i_di.di_size)

		return 0;

	if ((offset + size) > ip->i_di.di_size)

		size = ip->i_di.di_size - offset;

	if (!size)

		return 0;

	if ((sdp->gfs1 && journaled) || (!sdp->gfs1 && isdir)) {

		lblock = offset;

		o = lblock % sdp->sd_jbsize;

		lblock /= sdp->sd_jbsize;

	} else {

		lblock = offset >> sdp->sd_sb.sb_bsize_shift;

		o = offset & (sdp->bsize - 1);

	}

	if (inode_is_stuffed(ip))

		o += sizeof(struct gfs2_dinode);

	else if ((sdp->gfs1 && journaled) || (!sdp->gfs1 && isdir))

		o += sizeof(struct gfs2_meta_header);

	while (copied < size) {

		amount = size - copied;

		if (amount > sdp->bsize - o)

			amount = sdp->bsize - o;

		if (!extlen) {

			if (sdp->gfs1)

				gfs1_block_map(ip, lblock, &not_new, &dblock,

					       &extlen, FALSE);

			else

				block_map(ip, lblock, &not_new, &dblock,

					  &extlen, FALSE);

		}

		if (dblock) {

			if (dblock == ip->i_di.di_num.no_addr)

				bh = ip->i_bh;

			else

				bh = bread(sdp, dblock);

			dblock++;

			extlen--;

		} else

			bh = NULL;

		copy2mem(bh, &buf, o, amount);

		if (bh && bh != ip->i_bh)

			brelse(bh);

		copied += amount;

		lblock++;

		if (sdp->gfs1)

			o = (journaled) ? sizeof(struct gfs2_meta_header) : 0;

		else

			o = (isdir) ? sizeof(struct gfs2_meta_header) : 0;

	}

	return copied;

}

static void copy_from_mem(struct gfs2_buffer_head *bh, void **buf,

			  unsigned int offset, unsigned int size)

{

	char **p = (char **)buf;

	memcpy(bh->b_data + offset, *p, size);

	bmodified(bh);

	*p += size;

}

int __gfs2_writei(struct gfs2_inode *ip, void *buf,

		  uint64_t offset, unsigned int size, int resize)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *bh;

	uint64_t lblock, dblock;

	unsigned int o;

	uint32_t extlen = 0;

	unsigned int amount;

	int new;

	int isdir = !!(S_ISDIR(ip->i_di.di_mode));

	const uint64_t start = offset;

	int copied = 0;

	if (!size)

		return 0;

	if (inode_is_stuffed(ip) &&

	    ((start + size) > (sdp->bsize - sizeof(struct gfs2_dinode))))

		unstuff_dinode(ip);

	if (isdir) {

		lblock = offset;

		o = lblock % sdp->sd_jbsize;

		lblock /= sdp->sd_jbsize;

	} else {

		lblock = offset >> sdp->sd_sb.sb_bsize_shift;

		o = offset & (sdp->bsize - 1);

	}

	if (inode_is_stuffed(ip))

		o += sizeof(struct gfs2_dinode);

	else if (isdir)

		o += sizeof(struct gfs2_meta_header);

	while (copied < size) {

		amount = size - copied;

		if (amount > sdp->bsize - o)

			amount = sdp->bsize - o;

		if (!extlen) {

			new = TRUE;

			block_map(ip, lblock, &new, &dblock, &extlen, FALSE);

		}

		if (new) {

			bh = bget(sdp, dblock);

			if (isdir) {

				struct gfs2_meta_header mh;

				mh.mh_magic = GFS2_MAGIC;

				mh.mh_type = GFS2_METATYPE_JD;

				mh.mh_format = GFS2_FORMAT_JD;

				gfs2_meta_header_out(&mh, bh->b_data);

				bmodified(bh);

			}

		} else {

			if (dblock == ip->i_di.di_num.no_addr)

				bh = ip->i_bh;

			else

				bh = bread(sdp, dblock);

		}

		copy_from_mem(bh, &buf, o, amount);

		if (bh != ip->i_bh)

			brelse(bh);

		copied += amount;

		lblock++;

		dblock++;

		extlen--;

		o = (isdir) ? sizeof(struct gfs2_meta_header) : 0;

	}

	if (resize && ip->i_di.di_size < start + copied) {

		bmodified(ip->i_bh);

		ip->i_di.di_size = start + copied;

	}

	return copied;

}

struct gfs2_buffer_head *get_file_buf(struct gfs2_inode *ip, uint64_t lbn,

				      int prealloc)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	uint64_t dbn;

	int new = TRUE;

	if (inode_is_stuffed(ip))

		unstuff_dinode(ip);

	block_map(ip, lbn, &new, &dbn, NULL, prealloc);

	if (!dbn) {

		fprintf(stderr, "get_file_buf\n");

		exit(1);

	}

	if (!prealloc && new &&

	    ip->i_di.di_size < (lbn + 1) << sdp->sd_sb.sb_bsize_shift) {

		bmodified(ip->i_bh);

		ip->i_di.di_size = (lbn + 1) << sdp->sd_sb.sb_bsize_shift;

	}

	if (dbn == ip->i_di.di_num.no_addr)

		return ip->i_bh;

	else

		return bread(sdp, dbn);

}

int gfs2_dirent_first(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,

					  struct gfs2_dirent **dent)

{

	struct gfs2_meta_header *h = (struct gfs2_meta_header *)bh->b_data;

	if (be32_to_cpu(h->mh_type) == GFS2_METATYPE_LF) {

		*dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_leaf));

		return IS_LEAF;

	} else {

		*dent = (struct gfs2_dirent *)(bh->b_data + sizeof(struct gfs2_dinode));

		return IS_DINODE;

	}

}

int gfs2_dirent_next(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,

					 struct gfs2_dirent **dent)

{

	char *bh_end;

	uint16_t cur_rec_len;

	bh_end = bh->b_data + dip->i_sbd->bsize;

	cur_rec_len = be16_to_cpu((*dent)->de_rec_len);

	if (cur_rec_len == 0 || (char *)(*dent) + cur_rec_len >= bh_end)

		return -ENOENT;

	*dent = (struct gfs2_dirent *)((char *)(*dent) + cur_rec_len);

	return 0;

}

/**

 * Allocate a gfs2 dirent

 * Returns 0 on success, with *dent_out pointing to the new dirent,

 * or -1 on failure, with errno set

 */

static int dirent_alloc(struct gfs2_inode *dip, struct gfs2_buffer_head *bh,

			int name_len, struct gfs2_dirent **dent_out)

{

	struct gfs2_dirent *dent, *new;

	unsigned int rec_len = GFS2_DIRENT_SIZE(name_len);

	unsigned int entries = 0, offset = 0;

	int type;

	type = gfs2_dirent_first(dip, bh, &dent);

	if (type == IS_LEAF) {

		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;

		entries = be16_to_cpu(leaf->lf_entries);

		offset = sizeof(struct gfs2_leaf);

	} else {

		struct gfs2_dinode *dinode = (struct gfs2_dinode *)bh->b_data;

		entries = be32_to_cpu(dinode->di_entries);

		offset = sizeof(struct gfs2_dinode);

	}

	if (!entries) {

		dent->de_rec_len = cpu_to_be16(dip->i_sbd->bsize - offset);

		dent->de_name_len = cpu_to_be16(name_len);

		bmodified(bh);

		*dent_out = dent;

		dip->i_di.di_entries++;

		bmodified(dip->i_bh);

		return 0;

	}

	do {

		uint16_t cur_rec_len;

		uint16_t cur_name_len;

		uint16_t new_rec_len;

		cur_rec_len = be16_to_cpu(dent->de_rec_len);

		cur_name_len = be16_to_cpu(dent->de_name_len);

		if ((!dent->de_inum.no_formal_ino && cur_rec_len >= rec_len) ||

		    (cur_rec_len >= GFS2_DIRENT_SIZE(cur_name_len) + rec_len)) {

			if (dent->de_inum.no_formal_ino) {

				new = (struct gfs2_dirent *)((char *)dent +

							    GFS2_DIRENT_SIZE(cur_name_len));

				memset(new, 0, sizeof(struct gfs2_dirent));

				new->de_rec_len = cpu_to_be16(cur_rec_len -

					  GFS2_DIRENT_SIZE(cur_name_len));

				new->de_name_len = cpu_to_be16(name_len);

				new_rec_len = be16_to_cpu(new->de_rec_len);

				dent->de_rec_len = cpu_to_be16(cur_rec_len - new_rec_len);

				*dent_out = new;

				bmodified(bh);

				dip->i_di.di_entries++;

				bmodified(dip->i_bh);

				return 0;

			}

			dent->de_name_len = cpu_to_be16(name_len);

			*dent_out = dent;

			bmodified(bh);

			dip->i_di.di_entries++;

			bmodified(dip->i_bh);

			return 0;

		}

	} while (gfs2_dirent_next(dip, bh, &dent) == 0);

	errno = ENOSPC;