Commit aef1ff15 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'jfs-5.19' of https://github.com/kleikamp/linux-shaggy 

Pull jfs updates from David Kleikamp:
 "One bug fix and some code cleanup"

* tag 'jfs-5.19' of https://github.com/kleikamp/linux-shaggy:
  fs/jfs: Remove dead code
  fs: jfs: fix possible NULL pointer dereference in dbFree()
parents 35cdd865 e471e594

fs/jfs/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -13,5 +13,3 @@ jfs-y := super.o file.o inode.o namei.o jfs_mount.o jfs_umount.o \ 
	    resize.o xattr.o ioctl.o



jfs-$(CONFIG_JFS_POSIX_ACL) += acl.o
 


ccflags-y := -D_JFS_4K

fs/jfs/inode.c

+0 −18
Original line number Diff line number Diff line
@@ -224,18 +224,9 @@ int jfs_get_block(struct inode *ip, sector_t lblock, 
				 * this as a hole

				 */

				goto unlock;

#ifdef _JFS_4K

			XADoffset(&xad, lblock64);

			XADlength(&xad, xlen);

			XADaddress(&xad, xaddr);

#else				/* _JFS_4K */

			/*

			 * As long as block size = 4K, this isn't a problem.

			 * We should mark the whole page not ABNR, but how

			 * will we know to mark the other blocks BH_New?

			 */

			BUG();

#endif				/* _JFS_4K */

			rc = extRecord(ip, &xad);

			if (rc)

				goto unlock;
@@ -252,7 +243,6 @@ int jfs_get_block(struct inode *ip, sector_t lblock, 
	/*

	 * Allocate a new block

	 */

#ifdef _JFS_4K

	if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad)))

		goto unlock;

	rc = extAlloc(ip, xlen, lblock64, &xad, false);
@@ -263,14 +253,6 @@ int jfs_get_block(struct inode *ip, sector_t lblock, 
	map_bh(bh_result, ip->i_sb, addressXAD(&xad));

	bh_result->b_size = lengthXAD(&xad) << ip->i_blkbits;



#else				/* _JFS_4K */

	/*

	 * We need to do whatever it takes to keep all but the last buffers

	 * in 4K pages - see jfs_write.c

	 */

	BUG();

#endif				/* _JFS_4K */



      unlock:

	/*

	 * Release lock on inode

fs/jfs/jfs_dmap.c

+2 −69
Original line number Diff line number Diff line
@@ -385,6 +385,7 @@ int dbFree(struct inode *ip, s64 blkno, s64 nblocks) 
	}



	/* write the last buffer. */

	if (mp)

		write_metapage(mp);



	IREAD_UNLOCK(ipbmap);
@@ -868,74 +869,6 @@ int dbAlloc(struct inode *ip, s64 hint, s64 nblocks, s64 * results) 
	return (rc);

}



#ifdef _NOTYET

/*

 * NAME:	dbAllocExact()

 *

 * FUNCTION:	try to allocate the requested extent;

 *

 * PARAMETERS:

 *	ip	- pointer to in-core inode;

 *	blkno	- extent address;

 *	nblocks	- extent length;

 *

 * RETURN VALUES:

 *	0	- success

 *	-ENOSPC	- insufficient disk resources

 *	-EIO	- i/o error

 */

int dbAllocExact(struct inode *ip, s64 blkno, int nblocks)

{

	int rc;

	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;

	struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap;

	struct dmap *dp;

	s64 lblkno;

	struct metapage *mp;



	IREAD_LOCK(ipbmap, RDWRLOCK_DMAP);



	/*

	 * validate extent request:

	 *

	 * note: defragfs policy:

	 *  max 64 blocks will be moved.

	 *  allocation request size must be satisfied from a single dmap.

	 */

	if (nblocks <= 0 || nblocks > BPERDMAP || blkno >= bmp->db_mapsize) {

		IREAD_UNLOCK(ipbmap);

		return -EINVAL;

	}



	if (nblocks > ((s64) 1 << bmp->db_maxfreebud)) {

		/* the free space is no longer available */

		IREAD_UNLOCK(ipbmap);

		return -ENOSPC;

	}



	/* read in the dmap covering the extent */

	lblkno = BLKTODMAP(blkno, bmp->db_l2nbperpage);

	mp = read_metapage(ipbmap, lblkno, PSIZE, 0);

	if (mp == NULL) {

		IREAD_UNLOCK(ipbmap);

		return -EIO;

	}

	dp = (struct dmap *) mp->data;



	/* try to allocate the requested extent */

	rc = dbAllocNext(bmp, dp, blkno, nblocks);



	IREAD_UNLOCK(ipbmap);



	if (rc == 0)

		mark_metapage_dirty(mp);



	release_metapage(mp);



	return (rc);

}

#endif /* _NOTYET */



/*

 * NAME:	dbReAlloc()

 *

fs/jfs/jfs_dtree.c

+0 −298
Original line number Diff line number Diff line
@@ -2423,304 +2423,6 @@ static int dtDeleteUp(tid_t tid, struct inode *ip, 
	return 0;

}



#ifdef _NOTYET

/*

 * NAME:	dtRelocate()

 *

 * FUNCTION:	relocate dtpage (internal or leaf) of directory;

 *		This function is mainly used by defragfs utility.

 */

int dtRelocate(tid_t tid, struct inode *ip, s64 lmxaddr, pxd_t * opxd,

	       s64 nxaddr)

{

	int rc = 0;

	struct metapage *mp, *pmp, *lmp, *rmp;

	dtpage_t *p, *pp, *rp = 0, *lp= 0;

	s64 bn;

	int index;

	struct btstack btstack;

	pxd_t *pxd;

	s64 oxaddr, nextbn, prevbn;

	int xlen, xsize;

	struct tlock *tlck;

	struct dt_lock *dtlck;

	struct pxd_lock *pxdlock;

	s8 *stbl;

	struct lv *lv;



	oxaddr = addressPXD(opxd);

	xlen = lengthPXD(opxd);



	jfs_info("dtRelocate: lmxaddr:%Ld xaddr:%Ld:%Ld xlen:%d",

		   (long long)lmxaddr, (long long)oxaddr, (long long)nxaddr,

		   xlen);



	/*

	 *	1. get the internal parent dtpage covering

	 *	router entry for the tartget page to be relocated;

	 */

	rc = dtSearchNode(ip, lmxaddr, opxd, &btstack);

	if (rc)

		return rc;



	/* retrieve search result */

	DT_GETSEARCH(ip, btstack.top, bn, pmp, pp, index);

	jfs_info("dtRelocate: parent router entry validated.");



	/*

	 *	2. relocate the target dtpage

	 */

	/* read in the target page from src extent */

	DT_GETPAGE(ip, oxaddr, mp, PSIZE, p, rc);

	if (rc) {

		/* release the pinned parent page */

		DT_PUTPAGE(pmp);

		return rc;

	}



	/*

	 * read in sibling pages if any to update sibling pointers;

	 */

	rmp = NULL;

	if (p->header.next) {

		nextbn = le64_to_cpu(p->header.next);

		DT_GETPAGE(ip, nextbn, rmp, PSIZE, rp, rc);

		if (rc) {

			DT_PUTPAGE(mp);

			DT_PUTPAGE(pmp);

			return (rc);

		}

	}



	lmp = NULL;

	if (p->header.prev) {

		prevbn = le64_to_cpu(p->header.prev);

		DT_GETPAGE(ip, prevbn, lmp, PSIZE, lp, rc);

		if (rc) {

			DT_PUTPAGE(mp);

			DT_PUTPAGE(pmp);

			if (rmp)

				DT_PUTPAGE(rmp);

			return (rc);

		}

	}



	/* at this point, all xtpages to be updated are in memory */



	/*

	 * update sibling pointers of sibling dtpages if any;

	 */

	if (lmp) {

		tlck = txLock(tid, ip, lmp, tlckDTREE | tlckRELINK);

		dtlck = (struct dt_lock *) & tlck->lock;

		/* linelock header */

		ASSERT(dtlck->index == 0);

		lv = & dtlck->lv[0];

		lv->offset = 0;

		lv->length = 1;

		dtlck->index++;



		lp->header.next = cpu_to_le64(nxaddr);

		DT_PUTPAGE(lmp);

	}



	if (rmp) {

		tlck = txLock(tid, ip, rmp, tlckDTREE | tlckRELINK);

		dtlck = (struct dt_lock *) & tlck->lock;

		/* linelock header */

		ASSERT(dtlck->index == 0);

		lv = & dtlck->lv[0];

		lv->offset = 0;

		lv->length = 1;

		dtlck->index++;



		rp->header.prev = cpu_to_le64(nxaddr);

		DT_PUTPAGE(rmp);

	}



	/*

	 * update the target dtpage to be relocated

	 *

	 * write LOG_REDOPAGE of LOG_NEW type for dst page

	 * for the whole target page (logredo() will apply

	 * after image and update bmap for allocation of the

	 * dst extent), and update bmap for allocation of

	 * the dst extent;

	 */

	tlck = txLock(tid, ip, mp, tlckDTREE | tlckNEW);

	dtlck = (struct dt_lock *) & tlck->lock;

	/* linelock header */

	ASSERT(dtlck->index == 0);

	lv = & dtlck->lv[0];



	/* update the self address in the dtpage header */

	pxd = &p->header.self;

	PXDaddress(pxd, nxaddr);



	/* the dst page is the same as the src page, i.e.,

	 * linelock for afterimage of the whole page;

	 */

	lv->offset = 0;

	lv->length = p->header.maxslot;

	dtlck->index++;



	/* update the buffer extent descriptor of the dtpage */

	xsize = xlen << JFS_SBI(ip->i_sb)->l2bsize;



	/* unpin the relocated page */

	DT_PUTPAGE(mp);

	jfs_info("dtRelocate: target dtpage relocated.");



	/* the moved extent is dtpage, then a LOG_NOREDOPAGE log rec

	 * needs to be written (in logredo(), the LOG_NOREDOPAGE log rec

	 * will also force a bmap update ).

	 */



	/*

	 *	3. acquire maplock for the source extent to be freed;

	 */

	/* for dtpage relocation, write a LOG_NOREDOPAGE record

	 * for the source dtpage (logredo() will init NoRedoPage

	 * filter and will also update bmap for free of the source

	 * dtpage), and upadte bmap for free of the source dtpage;

	 */

	tlck = txMaplock(tid, ip, tlckDTREE | tlckFREE);

	pxdlock = (struct pxd_lock *) & tlck->lock;

	pxdlock->flag = mlckFREEPXD;

	PXDaddress(&pxdlock->pxd, oxaddr);

	PXDlength(&pxdlock->pxd, xlen);

	pxdlock->index = 1;



	/*

	 *	4. update the parent router entry for relocation;

	 *

	 * acquire tlck for the parent entry covering the target dtpage;

	 * write LOG_REDOPAGE to apply after image only;

	 */

	jfs_info("dtRelocate: update parent router entry.");

	tlck = txLock(tid, ip, pmp, tlckDTREE | tlckENTRY);

	dtlck = (struct dt_lock *) & tlck->lock;

	lv = & dtlck->lv[dtlck->index];



	/* update the PXD with the new address */

	stbl = DT_GETSTBL(pp);

	pxd = (pxd_t *) & pp->slot[stbl[index]];

	PXDaddress(pxd, nxaddr);

	lv->offset = stbl[index];

	lv->length = 1;

	dtlck->index++;



	/* unpin the parent dtpage */

	DT_PUTPAGE(pmp);



	return rc;

}



/*

 * NAME:	dtSearchNode()

 *

 * FUNCTION:	Search for an dtpage containing a specified address

 *		This function is mainly used by defragfs utility.

 *

 * NOTE:	Search result on stack, the found page is pinned at exit.

 *		The result page must be an internal dtpage.

 *		lmxaddr give the address of the left most page of the

 *		dtree level, in which the required dtpage resides.

 */

static int dtSearchNode(struct inode *ip, s64 lmxaddr, pxd_t * kpxd,

			struct btstack * btstack)

{

	int rc = 0;

	s64 bn;

	struct metapage *mp;

	dtpage_t *p;

	int psize = 288;	/* initial in-line directory */

	s8 *stbl;

	int i;

	pxd_t *pxd;

	struct btframe *btsp;



	BT_CLR(btstack);	/* reset stack */



	/*

	 *	descend tree to the level with specified leftmost page

	 *

	 *  by convention, root bn = 0.

	 */

	for (bn = 0;;) {

		/* get/pin the page to search */

		DT_GETPAGE(ip, bn, mp, psize, p, rc);

		if (rc)

			return rc;



		/* does the xaddr of leftmost page of the levevl

		 * matches levevl search key ?

		 */

		if (p->header.flag & BT_ROOT) {

			if (lmxaddr == 0)

				break;

		} else if (addressPXD(&p->header.self) == lmxaddr)

			break;



		/*

		 * descend down to leftmost child page

		 */

		if (p->header.flag & BT_LEAF) {

			DT_PUTPAGE(mp);

			return -ESTALE;

		}



		/* get the leftmost entry */

		stbl = DT_GETSTBL(p);

		pxd = (pxd_t *) & p->slot[stbl[0]];



		/* get the child page block address */

		bn = addressPXD(pxd);

		psize = lengthPXD(pxd) << JFS_SBI(ip->i_sb)->l2bsize;

		/* unpin the parent page */

		DT_PUTPAGE(mp);

	}



	/*

	 *	search each page at the current levevl

	 */

      loop:

	stbl = DT_GETSTBL(p);

	for (i = 0; i < p->header.nextindex; i++) {

		pxd = (pxd_t *) & p->slot[stbl[i]];



		/* found the specified router entry */

		if (addressPXD(pxd) == addressPXD(kpxd) &&

		    lengthPXD(pxd) == lengthPXD(kpxd)) {

			btsp = btstack->top;

			btsp->bn = bn;

			btsp->index = i;

			btsp->mp = mp;



			return 0;

		}

	}



	/* get the right sibling page if any */

	if (p->header.next)

		bn = le64_to_cpu(p->header.next);

	else {

		DT_PUTPAGE(mp);

		return -ESTALE;

	}



	/* unpin current page */

	DT_PUTPAGE(mp);



	/* get the right sibling page */

	DT_GETPAGE(ip, bn, mp, PSIZE, p, rc);

	if (rc)

		return rc;



	goto loop;

}

#endif /* _NOTYET */



/*

 *	dtRelink()

 *

fs/jfs/jfs_extent.c

+0 −255
Original line number Diff line number Diff line
@@ -16,9 +16,6 @@ 
 * 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)))
@@ -177,162 +174,6 @@ extAlloc(struct inode *ip, s64 xlen, s64 pno, xad_t * xp, bool abnr) 
	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()

 *
@@ -423,44 +264,6 @@ int extRecord(struct inode *ip, xad_t * xp) 
	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()

 *
@@ -550,64 +353,6 @@ extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno) 
	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

 *		   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()

 *