[linux.git] / fs / jfs / jfs_extent.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Copyright (C) International Business Machines Corp., 2000-2004
 */

#include <linux/fs.h>
#include <linux/quotaops.h>
#include "jfs_incore.h"
#include "jfs_inode.h"
#include "jfs_superblock.h"
#include "jfs_dmap.h"
#include "jfs_extent.h"
#include "jfs_debug.h"

/*
 * forward references
 */
static int extBalloc(struct inode *, s64, s64 *, s64 *);
#ifdef _NOTYET
static int extBrealloc(struct inode *, s64, s64, s64 *, s64 *);
#endif
static s64 extRoundDown(s64 nb);

#define DPD(a)		(printk("(a): %d\n",(a)))
#define DPC(a)		(printk("(a): %c\n",(a)))
#define DPL1(a)					\
{						\
	if ((a) >> 32)				\
		printk("(a): %x%08x  ",(a));	\
	else					\
		printk("(a): %x  ",(a) << 32);	\
}
#define DPL(a)					\
{						\
	if ((a) >> 32)				\
		printk("(a): %x%08x\n",(a));	\
	else					\
		printk("(a): %x\n",(a) << 32);	\
}

#define DPD1(a)		(printk("(a): %d  ",(a)))
#define DPX(a)		(printk("(a): %08x\n",(a)))
#define DPX1(a)		(printk("(a): %08x  ",(a)))
#define DPS(a)		(printk("%s\n",(a)))
#define DPE(a)		(printk("\nENTERING: %s\n",(a)))
#define DPE1(a)		(printk("\nENTERING: %s",(a)))
#define DPS1(a)		(printk("  %s  ",(a)))


/*
 * NAME:	extAlloc()
 *
 * FUNCTION:	allocate an extent for a specified page range within a
 *		file.
 *
 * PARAMETERS:
 *	ip	- the inode of the file.
 *	xlen	- requested extent length.
 *	pno	- the starting page number with the file.
 *	xp	- pointer to an xad.  on entry, xad describes an
 *		  extent that is used as an allocation hint if the
 *		  xaddr of the xad is non-zero.  on successful exit,
 *		  the xad describes the newly allocated extent.
 *	abnr	- bool indicating whether the newly allocated extent
 *		  should be marked as allocated but not recorded.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
int
extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr)
{
	struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
	s64 nxlen, nxaddr, xoff, hint, xaddr = 0;
	int rc;
	int xflag;

	/* This blocks if we are low on resources */
	txBeginAnon(ip->i_sb);

	/* Avoid race with jfs_commit_inode() */
	mutex_lock(&JFS_IP(ip)->commit_mutex);

	/* validate extent length */
	if (xlen > MAXXLEN)
		xlen = MAXXLEN;

	/* get the page's starting extent offset */
	xoff = pno << sbi->l2nbperpage;

	/* check if an allocation hint was provided */
	if ((hint = addressXAD(xp))) {
		/* get the size of the extent described by the hint */
		nxlen = lengthXAD(xp);

		/* check if the hint is for the portion of the file
		 * immediately previous to the current allocation
		 * request and if hint extent has the same abnr
		 * value as the current request.  if so, we can
		 * extend the hint extent to include the current
		 * extent if we can allocate the blocks immediately
		 * following the hint extent.
		 */
		if (offsetXAD(xp) + nxlen == xoff &&
		    abnr == ((xp->flag & XAD_NOTRECORDED) ? true : false))
			xaddr = hint + nxlen;

		/* adjust the hint to the last block of the extent */
		hint += (nxlen - 1);
	}

	/* allocate the disk blocks for the extent.  initially, extBalloc()
	 * will try to allocate disk blocks for the requested size (xlen).
	 * if this fails (xlen contiguous free blocks not available), it'll
	 * try to allocate a smaller number of blocks (producing a smaller
	 * extent), with this smaller number of blocks consisting of the
	 * requested number of blocks rounded down to the next smaller
	 * power of 2 number (i.e. 16 -> 8).  it'll continue to round down
	 * and retry the allocation until the number of blocks to allocate
	 * is smaller than the number of blocks per page.
	 */
	nxlen = xlen;
	if ((rc = extBalloc(ip, hint ? hint : INOHINT(ip), &nxlen, &nxaddr))) {
		mutex_unlock(&JFS_IP(ip)->commit_mutex);
		return (rc);
	}

	/* Allocate blocks to quota. */
	rc = dquot_alloc_block(ip, nxlen);
	if (rc) {
		dbFree(ip, nxaddr, (s64) nxlen);
		mutex_unlock(&JFS_IP(ip)->commit_mutex);
		return rc;
	}

	/* determine the value of the extent flag */
	xflag = abnr ? XAD_NOTRECORDED : 0;

	/* if we can extend the hint extent to cover the current request,
	 * extend it.  otherwise, insert a new extent to
	 * cover the current request.
	 */
	if (xaddr && xaddr == nxaddr)
		rc = xtExtend(0, ip, xoff, (int) nxlen, 0);
	else
		rc = xtInsert(0, ip, xflag, xoff, (int) nxlen, &nxaddr, 0);

	/* if the extend or insert failed,
	 * free the newly allocated blocks and return the error.
	 */
	if (rc) {
		dbFree(ip, nxaddr, nxlen);
		dquot_free_block(ip, nxlen);
		mutex_unlock(&JFS_IP(ip)->commit_mutex);
		return (rc);
	}

	/* set the results of the extent allocation */
	XADaddress(xp, nxaddr);
	XADlength(xp, nxlen);
	XADoffset(xp, xoff);
	xp->flag = xflag;

	mark_inode_dirty(ip);

	mutex_unlock(&JFS_IP(ip)->commit_mutex);
	/*
	 * COMMIT_SyncList flags an anonymous tlock on page that is on
	 * sync list.
	 * We need to commit the inode to get the page written disk.
	 */
	if (test_and_clear_cflag(COMMIT_Synclist,ip))
		jfs_commit_inode(ip, 0);

	return (0);
}


#ifdef _NOTYET
/*
 * NAME:	extRealloc()
 *
 * FUNCTION:	extend the allocation of a file extent containing a
 *		partial back last page.
 *
 * PARAMETERS:
 *	ip	- the inode of the file.
 *	cp	- cbuf for the partial backed last page.
 *	xlen	- request size of the resulting extent.
 *	xp	- pointer to an xad. on successful exit, the xad
 *		  describes the newly allocated extent.
 *	abnr	- bool indicating whether the newly allocated extent
 *		  should be marked as allocated but not recorded.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
int extRealloc(struct inode *ip, s64 nxlen, xad_t * xp, bool abnr)
{
	struct super_block *sb = ip->i_sb;
	s64 xaddr, xlen, nxaddr, delta, xoff;
	s64 ntail, nextend, ninsert;
	int rc, nbperpage = JFS_SBI(sb)->nbperpage;
	int xflag;

	/* This blocks if we are low on resources */
	txBeginAnon(ip->i_sb);

	mutex_lock(&JFS_IP(ip)->commit_mutex);
	/* validate extent length */
	if (nxlen > MAXXLEN)
		nxlen = MAXXLEN;

	/* get the extend (partial) page's disk block address and
	 * number of blocks.
	 */
	xaddr = addressXAD(xp);
	xlen = lengthXAD(xp);
	xoff = offsetXAD(xp);

	/* if the extend page is abnr and if the request is for
	 * the extent to be allocated and recorded,
	 * make the page allocated and recorded.
	 */
	if ((xp->flag & XAD_NOTRECORDED) && !abnr) {
		xp->flag = 0;
		if ((rc = xtUpdate(0, ip, xp)))
			goto exit;
	}

	/* try to allocated the request number of blocks for the
	 * extent.  dbRealloc() first tries to satisfy the request
	 * by extending the allocation in place. otherwise, it will
	 * try to allocate a new set of blocks large enough for the
	 * request.  in satisfying a request, dbReAlloc() may allocate
	 * less than what was request but will always allocate enough
	 * space as to satisfy the extend page.
	 */
	if ((rc = extBrealloc(ip, xaddr, xlen, &nxlen, &nxaddr)))
		goto exit;

	/* Allocat blocks to quota. */
	rc = dquot_alloc_block(ip, nxlen);
	if (rc) {
		dbFree(ip, nxaddr, (s64) nxlen);
		mutex_unlock(&JFS_IP(ip)->commit_mutex);
		return rc;
	}

	delta = nxlen - xlen;

	/* check if the extend page is not abnr but the request is abnr
	 * and the allocated disk space is for more than one page.  if this
	 * is the case, there is a miss match of abnr between the extend page
	 * and the one or more pages following the extend page.  as a result,
	 * two extents will have to be manipulated. the first will be that
	 * of the extent of the extend page and will be manipulated thru
	 * an xtExtend() or an xtTailgate(), depending upon whether the
	 * disk allocation occurred as an inplace extension.  the second
	 * extent will be manipulated (created) through an xtInsert() and
	 * will be for the pages following the extend page.
	 */
	if (abnr && (!(xp->flag & XAD_NOTRECORDED)) && (nxlen > nbperpage)) {
		ntail = nbperpage;
		nextend = ntail - xlen;
		ninsert = nxlen - nbperpage;

		xflag = XAD_NOTRECORDED;
	} else {
		ntail = nxlen;
		nextend = delta;
		ninsert = 0;

		xflag = xp->flag;
	}

	/* if we were able to extend the disk allocation in place,
	 * extend the extent.  otherwise, move the extent to a
	 * new disk location.
	 */
	if (xaddr == nxaddr) {
		/* extend the extent */
		if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
			dbFree(ip, xaddr + xlen, delta);
			dquot_free_block(ip, nxlen);
			goto exit;
		}
	} else {
		/*
		 * move the extent to a new location:
		 *
		 * xtTailgate() accounts for relocated tail extent;
		 */
		if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
			dbFree(ip, nxaddr, nxlen);
			dquot_free_block(ip, nxlen);
			goto exit;
		}
	}


	/* check if we need to also insert a new extent */
	if (ninsert) {
		/* perform the insert.  if it fails, free the blocks
		 * to be inserted and make it appear that we only did
		 * the xtExtend() or xtTailgate() above.
		 */
		xaddr = nxaddr + ntail;
		if (xtInsert (0, ip, xflag, xoff + ntail, (int) ninsert,
			      &xaddr, 0)) {
			dbFree(ip, xaddr, (s64) ninsert);
			delta = nextend;
			nxlen = ntail;
			xflag = 0;
		}
	}

	/* set the return results */
	XADaddress(xp, nxaddr);
	XADlength(xp, nxlen);
	XADoffset(xp, xoff);
	xp->flag = xflag;

	mark_inode_dirty(ip);
exit:
	mutex_unlock(&JFS_IP(ip)->commit_mutex);
	return (rc);
}
#endif			/* _NOTYET */


/*
 * NAME:	extHint()
 *
 * FUNCTION:	produce an extent allocation hint for a file offset.
 *
 * PARAMETERS:
 *	ip	- the inode of the file.
 *	offset  - file offset for which the hint is needed.
 *	xp	- pointer to the xad that is to be filled in with
 *		  the hint.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 */
int extHint(struct inode *ip, s64 offset, xad_t * xp)
{
	struct super_block *sb = ip->i_sb;
	int nbperpage = JFS_SBI(sb)->nbperpage;
	s64 prev;
	int rc = 0;
	s64 xaddr;
	int xlen;
	int xflag;

	/* init the hint as "no hint provided" */
	XADaddress(xp, 0);

	/* determine the starting extent offset of the page previous
	 * to the page containing the offset.
	 */
	prev = ((offset & ~POFFSET) >> JFS_SBI(sb)->l2bsize) - nbperpage;

	/* if the offset is in the first page of the file, no hint provided.
	 */
	if (prev < 0)
		goto out;

	rc = xtLookup(ip, prev, nbperpage, &xflag, &xaddr, &xlen, 0);

	if ((rc == 0) && xlen) {
		if (xlen != nbperpage) {
			jfs_error(ip->i_sb, "corrupt xtree\n");
			rc = -EIO;
		}
		XADaddress(xp, xaddr);
		XADlength(xp, xlen);
		XADoffset(xp, prev);
		/*
		 * only preserve the abnr flag within the xad flags
		 * of the returned hint.
		 */
		xp->flag  = xflag & XAD_NOTRECORDED;
	} else
		rc = 0;

out:
	return (rc);
}


/*
 * NAME:	extRecord()
 *
 * FUNCTION:	change a page with a file from not recorded to recorded.
 *
 * PARAMETERS:
 *	ip	- inode of the file.
 *	cp	- cbuf of the file page.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
int extRecord(struct inode *ip, xad_t * xp)
{
	int rc;

	txBeginAnon(ip->i_sb);

	mutex_lock(&JFS_IP(ip)->commit_mutex);

	/* update the extent */
	rc = xtUpdate(0, ip, xp);

	mutex_unlock(&JFS_IP(ip)->commit_mutex);
	return rc;
}


#ifdef _NOTYET
/*
 * NAME:	extFill()
 *
 * FUNCTION:	allocate disk space for a file page that represents
 *		a file hole.
 *
 * PARAMETERS:
 *	ip	- the inode of the file.
 *	cp	- cbuf of the file page represent the hole.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
int extFill(struct inode *ip, xad_t * xp)
{
	int rc, nbperpage = JFS_SBI(ip->i_sb)->nbperpage;
	s64 blkno = offsetXAD(xp) >> ip->i_blkbits;

//	assert(ISSPARSE(ip));

	/* initialize the extent allocation hint */
	XADaddress(xp, 0);

	/* allocate an extent to fill the hole */
	if ((rc = extAlloc(ip, nbperpage, blkno, xp, false)))
		return (rc);

	assert(lengthPXD(xp) == nbperpage);

	return (0);
}
#endif			/* _NOTYET */


/*
 * NAME:	extBalloc()
 *
 * FUNCTION:	allocate disk blocks to form an extent.
 *
 *		initially, we will try to allocate disk blocks for the
 *		requested size (nblocks).  if this fails (nblocks
 *		contiguous free blocks not available), we'll try to allocate
 *		a smaller number of blocks (producing a smaller extent), with
 *		this smaller number of blocks consisting of the requested
 *		number of blocks rounded down to the next smaller power of 2
 *		number (i.e. 16 -> 8).  we'll continue to round down and
 *		retry the allocation until the number of blocks to allocate
 *		is smaller than the number of blocks per page.
 *
 * PARAMETERS:
 *	ip	 - the inode of the file.
 *	hint	 - disk block number to be used as an allocation hint.
 *	*nblocks - pointer to an s64 value.  on entry, this value specifies
 *		   the desired number of block to be allocated. on successful
 *		   exit, this value is set to the number of blocks actually
 *		   allocated.
 *	blkno	 - pointer to a block address that is filled in on successful
 *		   return with the starting block number of the newly
 *		   allocated block range.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
static int
extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno)
{
	struct jfs_inode_info *ji = JFS_IP(ip);
	struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
	s64 nb, nblks, daddr, max;
	int rc, nbperpage = sbi->nbperpage;
	struct bmap *bmp = sbi->bmap;
	int ag;

	/* get the number of blocks to initially attempt to allocate.
	 * we'll first try the number of blocks requested unless this
	 * number is greater than the maximum number of contiguous free
	 * blocks in the map. in that case, we'll start off with the
	 * maximum free.
	 */
	max = (s64) 1 << bmp->db_maxfreebud;
	if (*nblocks >= max && *nblocks > nbperpage)
		nb = nblks = (max > nbperpage) ? max : nbperpage;
	else
		nb = nblks = *nblocks;

	/* try to allocate blocks */
	while ((rc = dbAlloc(ip, hint, nb, &daddr)) != 0) {
		/* if something other than an out of space error,
		 * stop and return this error.
		 */
		if (rc != -ENOSPC)
			return (rc);

		/* decrease the allocation request size */
		nb = min(nblks, extRoundDown(nb));

		/* give up if we cannot cover a page */
		if (nb < nbperpage)
			return (rc);
	}

	*nblocks = nb;
	*blkno = daddr;

	if (S_ISREG(ip->i_mode) && (ji->fileset == FILESYSTEM_I)) {
		ag = BLKTOAG(daddr, sbi);
		spin_lock_irq(&ji->ag_lock);
		if (ji->active_ag == -1) {
			atomic_inc(&bmp->db_active[ag]);
			ji->active_ag = ag;
		} else if (ji->active_ag != ag) {
			atomic_dec(&bmp->db_active[ji->active_ag]);
			atomic_inc(&bmp->db_active[ag]);
			ji->active_ag = ag;
		}
		spin_unlock_irq(&ji->ag_lock);
	}

	return (0);
}


#ifdef _NOTYET
/*
 * NAME:	extBrealloc()
 *
 * FUNCTION:	attempt to extend an extent's allocation.
 *
 *		Initially, we will try to extend the extent's allocation
 *		in place.  If this fails, we'll try to move the extent
 *		to a new set of blocks.  If moving the extent, we initially
 *		will try to allocate disk blocks for the requested size
 *		(newnblks).  if this fails (new contiguous free blocks not
 *		available), we'll try to allocate a smaller number of
 *		blocks (producing a smaller extent), with this smaller
 *		number of blocks consisting of the requested number of
 *		blocks rounded down to the next smaller power of 2
 *		number (i.e. 16 -> 8).  We'll continue to round down and
 *		retry the allocation until the number of blocks to allocate
 *		is smaller than the number of blocks per page.
 *
 * PARAMETERS:
 *	ip	 - the inode of the file.
 *	blkno	 - starting block number of the extents current allocation.
 *	nblks	 - number of blocks within the extents current allocation.
 *	newnblks - pointer to a s64 value.  on entry, this value is the
 *		   the new desired extent size (number of blocks).  on
 *		   successful exit, this value is set to the extent's actual
 *		   new size (new number of blocks).
 *	newblkno - the starting block number of the extents new allocation.
 *
 * RETURN VALUES:
 *	0	- success
 *	-EIO	- i/o error.
 *	-ENOSPC	- insufficient disk resources.
 */
static int
extBrealloc(struct inode *ip,
	    s64 blkno, s64 nblks, s64 * newnblks, s64 * newblkno)
{
	int rc;

	/* try to extend in place */
	if ((rc = dbExtend(ip, blkno, nblks, *newnblks - nblks)) == 0) {
		*newblkno = blkno;
		return (0);
	} else {
		if (rc != -ENOSPC)
			return (rc);
	}

	/* in place extension not possible.
	 * try to move the extent to a new set of blocks.
	 */
	return (extBalloc(ip, blkno, newnblks, newblkno));
}
#endif			/* _NOTYET */


/*
 * NAME:	extRoundDown()
 *
 * FUNCTION:	round down a specified number of blocks to the next
 *		smallest power of 2 number.
 *
 * PARAMETERS:
 *	nb	- the inode of the file.
 *
 * RETURN VALUES:
 *	next smallest power of 2 number.
 */
static s64 extRoundDown(s64 nb)
{
	int i;
	u64 m, k;

	for (i = 0, m = (u64) 1 << 63; i < 64; i++, m >>= 1) {
		if (m & nb)
			break;
	}

	i = 63 - i;
	k = (u64) 1 << i;
	k = ((k - 1) & nb) ? k : k >> 1;

	return (k);
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
1da177e4 LT	3	* Copyright (C) International Business Machines Corp., 2000-2004
1da177e4 LT	4	*/
	5
	6	#include <linux/fs.h>
	7	#include <linux/quotaops.h>
	8	#include "jfs_incore.h"
1868f4aa	9	#include "jfs_inode.h"
1da177e4 LT	10	#include "jfs_superblock.h"
	11	#include "jfs_dmap.h"
	12	#include "jfs_extent.h"
	13	#include "jfs_debug.h"
	14
	15	/*
	16	* forward references
	17	*/
	18	static int extBalloc(struct inode , s64, s64 , s64 *);
	19	#ifdef _NOTYET
	20	static int extBrealloc(struct inode , s64, s64, s64 , s64 *);
	21	#endif
	22	static s64 extRoundDown(s64 nb);
	23
f720e3ba DK	24	#define DPD(a) (printk("(a): %d\n",(a)))
f720e3ba DK	25	#define DPC(a) (printk("(a): %c\n",(a)))
1da177e4 LT	26	#define DPL1(a) \
	27	{ \
	28	if ((a) >> 32) \
	29	printk("(a): %x%08x ",(a)); \
	30	else \
	31	printk("(a): %x ",(a) << 32); \
	32	}
	33	#define DPL(a) \
	34	{ \
	35	if ((a) >> 32) \
	36	printk("(a): %x%08x\n",(a)); \
	37	else \
	38	printk("(a): %x\n",(a) << 32); \
	39	}
	40
f720e3ba DK	41	#define DPD1(a) (printk("(a): %d ",(a)))
	42	#define DPX(a) (printk("(a): %08x\n",(a)))
	43	#define DPX1(a) (printk("(a): %08x ",(a)))
	44	#define DPS(a) (printk("%s\n",(a)))
	45	#define DPE(a) (printk("\nENTERING: %s\n",(a)))
	46	#define DPE1(a) (printk("\nENTERING: %s",(a)))
	47	#define DPS1(a) (printk(" %s ",(a)))
1da177e4 LT	48
	49
	50	/*
	51	* NAME: extAlloc()
	52	*
f720e3ba	53	* FUNCTION: allocate an extent for a specified page range within a
1da177e4 LT	54	* file.
	55	*
	56	* PARAMETERS:
	57	* ip - the inode of the file.
	58	* xlen - requested extent length.
	59	* pno - the starting page number with the file.
	60	* xp - pointer to an xad. on entry, xad describes an
	61	* extent that is used as an allocation hint if the
	62	* xaddr of the xad is non-zero. on successful exit,
	63	* the xad describes the newly allocated extent.
4d81715f	64	* abnr - bool indicating whether the newly allocated extent
1da177e4 LT	65	* should be marked as allocated but not recorded.
	66	*
	67	* RETURN VALUES:
f720e3ba DK	68	* 0 - success
	69	* -EIO - i/o error.
	70	* -ENOSPC - insufficient disk resources.
1da177e4 LT	71	*/
1da177e4 LT	72	int
4d81715f	73	extAlloc(struct inode ip, s64 xlen, s64 pno, xad_t xp, bool abnr)
1da177e4 LT	74	{
	75	struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
	76	s64 nxlen, nxaddr, xoff, hint, xaddr = 0;
	77	int rc;
	78	int xflag;
	79
	80	/* This blocks if we are low on resources */
	81	txBeginAnon(ip->i_sb);
	82
	83	/* Avoid race with jfs_commit_inode() */
1de87444	84	mutex_lock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	85
	86	/* validate extent length */
	87	if (xlen > MAXXLEN)
	88	xlen = MAXXLEN;
	89
	90	/* get the page's starting extent offset */
	91	xoff = pno << sbi->l2nbperpage;
	92
	93	/* check if an allocation hint was provided */
	94	if ((hint = addressXAD(xp))) {
	95	/* get the size of the extent described by the hint */
	96	nxlen = lengthXAD(xp);
	97
	98	/* check if the hint is for the portion of the file
	99	* immediately previous to the current allocation
	100	* request and if hint extent has the same abnr
	101	* value as the current request. if so, we can
	102	* extend the hint extent to include the current
	103	* extent if we can allocate the blocks immediately
	104	* following the hint extent.
	105	*/
	106	if (offsetXAD(xp) + nxlen == xoff &&
4d81715f	107	abnr == ((xp->flag & XAD_NOTRECORDED) ? true : false))
1da177e4 LT	108	xaddr = hint + nxlen;
	109
	110	/* adjust the hint to the last block of the extent */
	111	hint += (nxlen - 1);
	112	}
	113
	114	/* allocate the disk blocks for the extent. initially, extBalloc()
63f83c9f	115	* will try to allocate disk blocks for the requested size (xlen).
25985edc	116	* if this fails (xlen contiguous free blocks not available), it'll
1da177e4 LT	117	* try to allocate a smaller number of blocks (producing a smaller
	118	* extent), with this smaller number of blocks consisting of the
	119	* requested number of blocks rounded down to the next smaller
	120	* power of 2 number (i.e. 16 -> 8). it'll continue to round down
	121	* and retry the allocation until the number of blocks to allocate
	122	* is smaller than the number of blocks per page.
	123	*/
	124	nxlen = xlen;
	125	if ((rc = extBalloc(ip, hint ? hint : INOHINT(ip), &nxlen, &nxaddr))) {
1de87444	126	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	127	return (rc);
	128	}
	129
	130	/* Allocate blocks to quota. */
5dd4056d CH	131	rc = dquot_alloc_block(ip, nxlen);
5dd4056d CH	132	if (rc) {
1da177e4	133	dbFree(ip, nxaddr, (s64) nxlen);
1de87444	134	mutex_unlock(&JFS_IP(ip)->commit_mutex);
5dd4056d	135	return rc;
1da177e4 LT	136	}
	137
	138	/* determine the value of the extent flag */
4d81715f	139	xflag = abnr ? XAD_NOTRECORDED : 0;
1da177e4	140
63f83c9f	141	/* if we can extend the hint extent to cover the current request,
1da177e4 LT	142	* extend it. otherwise, insert a new extent to
	143	* cover the current request.
	144	*/
	145	if (xaddr && xaddr == nxaddr)
	146	rc = xtExtend(0, ip, xoff, (int) nxlen, 0);
	147	else
	148	rc = xtInsert(0, ip, xflag, xoff, (int) nxlen, &nxaddr, 0);
	149
63f83c9f	150	/* if the extend or insert failed,
1da177e4 LT	151	* free the newly allocated blocks and return the error.
	152	*/
	153	if (rc) {
	154	dbFree(ip, nxaddr, nxlen);
5dd4056d	155	dquot_free_block(ip, nxlen);
1de87444	156	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	157	return (rc);
	158	}
	159
	160	/* set the results of the extent allocation */
	161	XADaddress(xp, nxaddr);
	162	XADlength(xp, nxlen);
	163	XADoffset(xp, xoff);
	164	xp->flag = xflag;
	165
	166	mark_inode_dirty(ip);
	167
1de87444	168	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	169	/*
	170	* COMMIT_SyncList flags an anonymous tlock on page that is on
	171	* sync list.
	172	* We need to commit the inode to get the page written disk.
	173	*/
	174	if (test_and_clear_cflag(COMMIT_Synclist,ip))
	175	jfs_commit_inode(ip, 0);
	176
	177	return (0);
	178	}
	179
	180
	181	#ifdef _NOTYET
	182	/*
f720e3ba	183	* NAME: extRealloc()
1da177e4	184	*
f720e3ba	185	* FUNCTION: extend the allocation of a file extent containing a
1da177e4 LT	186	* partial back last page.
	187	*
	188	* PARAMETERS:
	189	* ip - the inode of the file.
	190	* cp - cbuf for the partial backed last page.
	191	* xlen - request size of the resulting extent.
	192	* xp - pointer to an xad. on successful exit, the xad
	193	* describes the newly allocated extent.
4d81715f	194	* abnr - bool indicating whether the newly allocated extent
1da177e4 LT	195	* should be marked as allocated but not recorded.
	196	*
	197	* RETURN VALUES:
f720e3ba DK	198	* 0 - success
	199	* -EIO - i/o error.
	200	* -ENOSPC - insufficient disk resources.
1da177e4	201	*/
4d81715f	202	int extRealloc(struct inode ip, s64 nxlen, xad_t xp, bool abnr)
1da177e4 LT	203	{
	204	struct super_block *sb = ip->i_sb;
	205	s64 xaddr, xlen, nxaddr, delta, xoff;
	206	s64 ntail, nextend, ninsert;
	207	int rc, nbperpage = JFS_SBI(sb)->nbperpage;
	208	int xflag;
	209
	210	/* This blocks if we are low on resources */
	211	txBeginAnon(ip->i_sb);
	212
1de87444	213	mutex_lock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	214	/* validate extent length */
	215	if (nxlen > MAXXLEN)
	216	nxlen = MAXXLEN;
	217
	218	/* get the extend (partial) page's disk block address and
	219	* number of blocks.
	220	*/
	221	xaddr = addressXAD(xp);
	222	xlen = lengthXAD(xp);
	223	xoff = offsetXAD(xp);
	224
	225	/* if the extend page is abnr and if the request is for
63f83c9f	226	* the extent to be allocated and recorded,
1da177e4 LT	227	* make the page allocated and recorded.
	228	*/
	229	if ((xp->flag & XAD_NOTRECORDED) && !abnr) {
	230	xp->flag = 0;
	231	if ((rc = xtUpdate(0, ip, xp)))
	232	goto exit;
	233	}
	234
	235	/* try to allocated the request number of blocks for the
	236	* extent. dbRealloc() first tries to satisfy the request
	237	* by extending the allocation in place. otherwise, it will
	238	* try to allocate a new set of blocks large enough for the
	239	* request. in satisfying a request, dbReAlloc() may allocate
	240	* less than what was request but will always allocate enough
	241	* space as to satisfy the extend page.
	242	*/
	243	if ((rc = extBrealloc(ip, xaddr, xlen, &nxlen, &nxaddr)))
	244	goto exit;
	245
	246	/* Allocat blocks to quota. */
5dd4056d CH	247	rc = dquot_alloc_block(ip, nxlen);
5dd4056d CH	248	if (rc) {
1da177e4	249	dbFree(ip, nxaddr, (s64) nxlen);
1de87444	250	mutex_unlock(&JFS_IP(ip)->commit_mutex);
5dd4056d	251	return rc;
1da177e4 LT	252	}
	253
	254	delta = nxlen - xlen;
	255
	256	/* check if the extend page is not abnr but the request is abnr
	257	* and the allocated disk space is for more than one page. if this
	258	* is the case, there is a miss match of abnr between the extend page
	259	* and the one or more pages following the extend page. as a result,
	260	* two extents will have to be manipulated. the first will be that
	261	* of the extent of the extend page and will be manipulated thru
	262	* an xtExtend() or an xtTailgate(), depending upon whether the
	263	* disk allocation occurred as an inplace extension. the second
	264	* extent will be manipulated (created) through an xtInsert() and
	265	* will be for the pages following the extend page.
	266	*/
	267	if (abnr && (!(xp->flag & XAD_NOTRECORDED)) && (nxlen > nbperpage)) {
	268	ntail = nbperpage;
	269	nextend = ntail - xlen;
	270	ninsert = nxlen - nbperpage;
	271
	272	xflag = XAD_NOTRECORDED;
	273	} else {
	274	ntail = nxlen;
	275	nextend = delta;
	276	ninsert = 0;
	277
	278	xflag = xp->flag;
	279	}
	280
	281	/* if we were able to extend the disk allocation in place,
	282	* extend the extent. otherwise, move the extent to a
	283	* new disk location.
	284	*/
	285	if (xaddr == nxaddr) {
	286	/* extend the extent */
	287	if ((rc = xtExtend(0, ip, xoff + xlen, (int) nextend, 0))) {
	288	dbFree(ip, xaddr + xlen, delta);
5dd4056d	289	dquot_free_block(ip, nxlen);
1da177e4 LT	290	goto exit;
	291	}
	292	} else {
	293	/*
	294	* move the extent to a new location:
	295	*
	296	* xtTailgate() accounts for relocated tail extent;
	297	*/
	298	if ((rc = xtTailgate(0, ip, xoff, (int) ntail, nxaddr, 0))) {
	299	dbFree(ip, nxaddr, nxlen);
5dd4056d	300	dquot_free_block(ip, nxlen);
1da177e4 LT	301	goto exit;
	302	}
	303	}
	304
	305
	306	/* check if we need to also insert a new extent */
	307	if (ninsert) {
	308	/* perform the insert. if it fails, free the blocks
	309	* to be inserted and make it appear that we only did
	310	* the xtExtend() or xtTailgate() above.
	311	*/
	312	xaddr = nxaddr + ntail;
	313	if (xtInsert (0, ip, xflag, xoff + ntail, (int) ninsert,
	314	&xaddr, 0)) {
	315	dbFree(ip, xaddr, (s64) ninsert);
	316	delta = nextend;
	317	nxlen = ntail;
	318	xflag = 0;
	319	}
	320	}
	321
	322	/* set the return results */
	323	XADaddress(xp, nxaddr);
	324	XADlength(xp, nxlen);
	325	XADoffset(xp, xoff);
	326	xp->flag = xflag;
	327
	328	mark_inode_dirty(ip);
	329	exit:
1de87444	330	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	331	return (rc);
	332	}
	333	#endif /* _NOTYET */
	334
	335
	336	/*
f720e3ba	337	* NAME: extHint()
1da177e4	338	*
f720e3ba	339	* FUNCTION: produce an extent allocation hint for a file offset.
1da177e4 LT	340	*
	341	* PARAMETERS:
	342	* ip - the inode of the file.
	343	* offset - file offset for which the hint is needed.
	344	* xp - pointer to the xad that is to be filled in with
	345	* the hint.
	346	*
	347	* RETURN VALUES:
f720e3ba DK	348	* 0 - success
f720e3ba DK	349	* -EIO - i/o error.
1da177e4 LT	350	*/
	351	int extHint(struct inode ip, s64 offset, xad_t xp)
	352	{
	353	struct super_block *sb = ip->i_sb;
fec1878f	354	int nbperpage = JFS_SBI(sb)->nbperpage;
1da177e4	355	s64 prev;
fec1878f DK	356	int rc = 0;
	357	s64 xaddr;
	358	int xlen;
	359	int xflag;
1da177e4 LT	360
	361	/* init the hint as "no hint provided" */
	362	XADaddress(xp, 0);
	363
	364	/* determine the starting extent offset of the page previous
	365	* to the page containing the offset.
	366	*/
	367	prev = ((offset & ~POFFSET) >> JFS_SBI(sb)->l2bsize) - nbperpage;
	368
fec1878f	369	/* if the offset is in the first page of the file, no hint provided.
1da177e4 LT	370	*/
1da177e4 LT	371	if (prev < 0)
fec1878f	372	goto out;
1da177e4	373
fec1878f	374	rc = xtLookup(ip, prev, nbperpage, &xflag, &xaddr, &xlen, 0);
1da177e4	375
fec1878f DK	376	if ((rc == 0) && xlen) {
fec1878f DK	377	if (xlen != nbperpage) {
eb8630d7	378	jfs_error(ip->i_sb, "corrupt xtree\n");
fec1878f DK	379	rc = -EIO;
	380	}
	381	XADaddress(xp, xaddr);
	382	XADlength(xp, xlen);
f7c52fd1	383	XADoffset(xp, prev);
fec1878f DK	384	/*
	385	* only preserve the abnr flag within the xad flags
	386	* of the returned hint.
	387	*/
	388	xp->flag = xflag & XAD_NOTRECORDED;
	389	} else
	390	rc = 0;
1da177e4	391
fec1878f DK	392	out:
fec1878f DK	393	return (rc);
1da177e4 LT	394	}
	395
	396
	397	/*
f720e3ba	398	* NAME: extRecord()
1da177e4	399	*
f720e3ba	400	* FUNCTION: change a page with a file from not recorded to recorded.
1da177e4 LT	401	*
	402	* PARAMETERS:
	403	* ip - inode of the file.
	404	* cp - cbuf of the file page.
	405	*
	406	* RETURN VALUES:
f720e3ba DK	407	* 0 - success
	408	* -EIO - i/o error.
	409	* -ENOSPC - insufficient disk resources.
1da177e4 LT	410	*/
	411	int extRecord(struct inode ip, xad_t xp)
	412	{
	413	int rc;
	414
	415	txBeginAnon(ip->i_sb);
	416
1de87444	417	mutex_lock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	418
	419	/* update the extent */
	420	rc = xtUpdate(0, ip, xp);
	421
1de87444	422	mutex_unlock(&JFS_IP(ip)->commit_mutex);
1da177e4 LT	423	return rc;
	424	}
	425
	426
	427	#ifdef _NOTYET
	428	/*
f720e3ba	429	* NAME: extFill()
1da177e4	430	*
f720e3ba	431	* FUNCTION: allocate disk space for a file page that represents
1da177e4 LT	432	* a file hole.
	433	*
	434	* PARAMETERS:
	435	* ip - the inode of the file.
	436	* cp - cbuf of the file page represent the hole.
	437	*
	438	* RETURN VALUES:
f720e3ba DK	439	* 0 - success
	440	* -EIO - i/o error.
	441	* -ENOSPC - insufficient disk resources.
1da177e4 LT	442	*/
	443	int extFill(struct inode ip, xad_t xp)
	444	{
	445	int rc, nbperpage = JFS_SBI(ip->i_sb)->nbperpage;
ba52de12	446	s64 blkno = offsetXAD(xp) >> ip->i_blkbits;
1da177e4	447
f720e3ba	448	// assert(ISSPARSE(ip));
1da177e4 LT	449
	450	/* initialize the extent allocation hint */
	451	XADaddress(xp, 0);
	452
	453	/* allocate an extent to fill the hole */
4d81715f	454	if ((rc = extAlloc(ip, nbperpage, blkno, xp, false)))
1da177e4 LT	455	return (rc);
	456
	457	assert(lengthPXD(xp) == nbperpage);
	458
	459	return (0);
	460	}
	461	#endif /* _NOTYET */
	462
	463
	464	/*
	465	* NAME: extBalloc()
	466	*
f720e3ba	467	* FUNCTION: allocate disk blocks to form an extent.
1da177e4 LT	468	*
1da177e4 LT	469	* initially, we will try to allocate disk blocks for the
63f83c9f	470	* requested size (nblocks). if this fails (nblocks
25985edc	471	* contiguous free blocks not available), we'll try to allocate
1da177e4 LT	472	* a smaller number of blocks (producing a smaller extent), with
	473	* this smaller number of blocks consisting of the requested
	474	* number of blocks rounded down to the next smaller power of 2
	475	* number (i.e. 16 -> 8). we'll continue to round down and
	476	* retry the allocation until the number of blocks to allocate
	477	* is smaller than the number of blocks per page.
63f83c9f	478	*
1da177e4 LT	479	* PARAMETERS:
	480	* ip - the inode of the file.
	481	* hint - disk block number to be used as an allocation hint.
	482	* *nblocks - pointer to an s64 value. on entry, this value specifies
	483	* the desired number of block to be allocated. on successful
	484	* exit, this value is set to the number of blocks actually
	485	* allocated.
	486	* blkno - pointer to a block address that is filled in on successful
63f83c9f	487	* return with the starting block number of the newly
1da177e4 LT	488	* allocated block range.
	489	*
	490	* RETURN VALUES:
f720e3ba DK	491	* 0 - success
	492	* -EIO - i/o error.
	493	* -ENOSPC - insufficient disk resources.
1da177e4 LT	494	*/
	495	static int
	496	extBalloc(struct inode ip, s64 hint, s64 nblocks, s64 * blkno)
	497	{
	498	struct jfs_inode_info *ji = JFS_IP(ip);
	499	struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb);
	500	s64 nb, nblks, daddr, max;
	501	int rc, nbperpage = sbi->nbperpage;
	502	struct bmap *bmp = sbi->bmap;
	503	int ag;
	504
	505	/* get the number of blocks to initially attempt to allocate.
	506	* we'll first try the number of blocks requested unless this
d6e05edc	507	* number is greater than the maximum number of contiguous free
63f83c9f	508	* blocks in the map. in that case, we'll start off with the
1da177e4 LT	509	* maximum free.
	510	*/
	511	max = (s64) 1 << bmp->db_maxfreebud;
	512	if (nblocks >= max && nblocks > nbperpage)
	513	nb = nblks = (max > nbperpage) ? max : nbperpage;
	514	else
	515	nb = nblks = *nblocks;
	516
	517	/* try to allocate blocks */
	518	while ((rc = dbAlloc(ip, hint, nb, &daddr)) != 0) {
	519	/* if something other than an out of space error,
	520	* stop and return this error.
	521	*/
	522	if (rc != -ENOSPC)
	523	return (rc);
	524
	525	/* decrease the allocation request size */
	526	nb = min(nblks, extRoundDown(nb));
	527
	528	/* give up if we cannot cover a page */
	529	if (nb < nbperpage)
	530	return (rc);
	531	}
	532
	533	*nblocks = nb;
	534	*blkno = daddr;
	535
	536	if (S_ISREG(ip->i_mode) && (ji->fileset == FILESYSTEM_I)) {
	537	ag = BLKTOAG(daddr, sbi);
	538	spin_lock_irq(&ji->ag_lock);
	539	if (ji->active_ag == -1) {
	540	atomic_inc(&bmp->db_active[ag]);
	541	ji->active_ag = ag;
	542	} else if (ji->active_ag != ag) {
	543	atomic_dec(&bmp->db_active[ji->active_ag]);
	544	atomic_inc(&bmp->db_active[ag]);
	545	ji->active_ag = ag;
	546	}
	547	spin_unlock_irq(&ji->ag_lock);
	548	}
	549
	550	return (0);
	551	}
	552
	553
	554	#ifdef _NOTYET
	555	/*
	556	* NAME: extBrealloc()
	557	*
f720e3ba	558	* FUNCTION: attempt to extend an extent's allocation.
1da177e4	559	*
63f83c9f DK	560	* Initially, we will try to extend the extent's allocation
	561	* in place. If this fails, we'll try to move the extent
	562	* to a new set of blocks. If moving the extent, we initially
1da177e4	563	* will try to allocate disk blocks for the requested size
63f83c9f	564	* (newnblks). if this fails (new contiguous free blocks not
25985edc	565	* available), we'll try to allocate a smaller number of
1da177e4 LT	566	* blocks (producing a smaller extent), with this smaller
	567	* number of blocks consisting of the requested number of
	568	* blocks rounded down to the next smaller power of 2
63f83c9f	569	* number (i.e. 16 -> 8). We'll continue to round down and
1da177e4 LT	570	* retry the allocation until the number of blocks to allocate
1da177e4 LT	571	* is smaller than the number of blocks per page.
63f83c9f	572	*
1da177e4 LT	573	* PARAMETERS:
1da177e4 LT	574	* ip - the inode of the file.
f720e3ba DK	575	* blkno - starting block number of the extents current allocation.
f720e3ba DK	576	* nblks - number of blocks within the extents current allocation.
1da177e4 LT	577	* newnblks - pointer to a s64 value. on entry, this value is the
	578	* the new desired extent size (number of blocks). on
	579	* successful exit, this value is set to the extent's actual
	580	* new size (new number of blocks).
	581	* newblkno - the starting block number of the extents new allocation.
	582	*
	583	* RETURN VALUES:
f720e3ba DK	584	* 0 - success
	585	* -EIO - i/o error.
	586	* -ENOSPC - insufficient disk resources.
1da177e4 LT	587	*/
	588	static int
	589	extBrealloc(struct inode *ip,
	590	s64 blkno, s64 nblks, s64 * newnblks, s64 * newblkno)
	591	{
	592	int rc;
	593
	594	/* try to extend in place */
	595	if ((rc = dbExtend(ip, blkno, nblks, *newnblks - nblks)) == 0) {
	596	*newblkno = blkno;
	597	return (0);
	598	} else {
	599	if (rc != -ENOSPC)
	600	return (rc);
	601	}
	602
63f83c9f	603	/* in place extension not possible.
1da177e4 LT	604	* try to move the extent to a new set of blocks.
	605	*/
	606	return (extBalloc(ip, blkno, newnblks, newblkno));
	607	}
	608	#endif /* _NOTYET */
	609
	610
	611	/*
f720e3ba	612	* NAME: extRoundDown()
1da177e4	613	*
f720e3ba	614	* FUNCTION: round down a specified number of blocks to the next
1da177e4 LT	615	* smallest power of 2 number.
	616	*
	617	* PARAMETERS:
	618	* nb - the inode of the file.
	619	*
	620	* RETURN VALUES:
f720e3ba	621	* next smallest power of 2 number.
1da177e4 LT	622	*/
	623	static s64 extRoundDown(s64 nb)
	624	{
	625	int i;
	626	u64 m, k;
	627
	628	for (i = 0, m = (u64) 1 << 63; i < 64; i++, m >>= 1) {
	629	if (m & nb)
	630	break;
	631	}
	632
	633	i = 63 - i;
	634	k = (u64) 1 << i;
	635	k = ((k - 1) & nb) ? k : k >> 1;
	636
	637	return (k);
	638	}