Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit cbc3d65ebcb0c494183d45cf202a53352cbf3871

Authored by Dave Kleikamp 2005-07-27 22:17:57 +0800

Exists in master and in 7 other branches

JFS: Improve sync barrier processing

Under heavy load, hot metadata pages are often locked by non-committed
transactions, making them difficult to flush to disk.  This prevents
the sync point from advancing past a transaction that had modified the
page.

There is a point during the sync barrier processing where all
outstanding transactions have been committed to disk, but no new
transaction have been allowed to proceed.  This is the best time
to write the metadata.

Signed-off-by: Dave Kleikamp <shaggy@austin.ibm.com>

Showing 4 changed files with 26 additions and 24 deletions Inline Diff

fs/jfs/jfs_logmgr.c
fs/jfs/jfs_logmgr.h
fs/jfs/jfs_txnmgr.c
fs/jfs/super.c

fs/jfs/jfs_logmgr.c

Diff comments View file @ cbc3d65

 /*
  *   Copyright (C) International Business Machines Corp., 2000-2004
  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  *   the GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 /*
  *	jfs_logmgr.c: log manager
  *
  * for related information, see transaction manager (jfs_txnmgr.c), and
  * recovery manager (jfs_logredo.c).
  *
  * note: for detail, RTFS.
  *
  *	log buffer manager:
  * special purpose buffer manager supporting log i/o requirements.
  * per log serial pageout of logpage
  * queuing i/o requests and redrive i/o at iodone
  * maintain current logpage buffer
  * no caching since append only
  * appropriate jfs buffer cache buffers as needed
  *
  *	group commit:
  * transactions which wrote COMMIT records in the same in-memory
  * log page during the pageout of previous/current log page(s) are
  * committed together by the pageout of the page.
  *
  *	TBD lazy commit:
  * transactions are committed asynchronously when the log page
  * containing it COMMIT is paged out when it becomes full;
  *
  *	serialization:
  * . a per log lock serialize log write.
  * . a per log lock serialize group commit.
  * . a per log lock serialize log open/close;
  *
  *	TBD log integrity:
  * careful-write (ping-pong) of last logpage to recover from crash
  * in overwrite.
  * detection of split (out-of-order) write of physical sectors
  * of last logpage via timestamp at end of each sector
  * with its mirror data array at trailer).
  *
  *	alternatives:
  * lsn - 64-bit monotonically increasing integer vs
  * 32-bit lspn and page eor.
  */
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>		/* for sync_blockdev() */
 #include <linux/bio.h>
 #include <linux/suspend.h>
 #include <linux/delay.h>
 #include "jfs_incore.h"
 #include "jfs_filsys.h"
 #include "jfs_metapage.h"
 #include "jfs_superblock.h"
 #include "jfs_txnmgr.h"
 #include "jfs_debug.h"
 /*
  * lbuf's ready to be redriven.  Protected by log_redrive_lock (jfsIO thread)
  */
 static struct lbuf *log_redrive_list;
 static DEFINE_SPINLOCK(log_redrive_lock);
 DECLARE_WAIT_QUEUE_HEAD(jfs_IO_thread_wait);
 /*
  *	log read/write serialization (per log)
  */
 #define LOG_LOCK_INIT(log)	init_MUTEX(&(log)->loglock)
 #define LOG_LOCK(log)		down(&((log)->loglock))
 #define LOG_UNLOCK(log)		up(&((log)->loglock))
 /*
  *	log group commit serialization (per log)
  */
 #define LOGGC_LOCK_INIT(log)	spin_lock_init(&(log)->gclock)
 #define LOGGC_LOCK(log)		spin_lock_irq(&(log)->gclock)
 #define LOGGC_UNLOCK(log)	spin_unlock_irq(&(log)->gclock)
 #define LOGGC_WAKEUP(tblk)	wake_up_all(&(tblk)->gcwait)
 /*
  *	log sync serialization (per log)
  */
 #define	LOGSYNC_DELTA(logsize)		min((logsize)/8, 128*LOGPSIZE)
 #define	LOGSYNC_BARRIER(logsize)	((logsize)/4)
 /*
 #define	LOGSYNC_DELTA(logsize)		min((logsize)/4, 256*LOGPSIZE)
 #define	LOGSYNC_BARRIER(logsize)	((logsize)/2)
 */
 /*
  *	log buffer cache synchronization
  */
 static DEFINE_SPINLOCK(jfsLCacheLock);
 #define	LCACHE_LOCK(flags)	spin_lock_irqsave(&jfsLCacheLock, flags)
 #define	LCACHE_UNLOCK(flags)	spin_unlock_irqrestore(&jfsLCacheLock, flags)
 /*
  * See __SLEEP_COND in jfs_locks.h
  */
 #define LCACHE_SLEEP_COND(wq, cond, flags)	\
 do {						\
 	if (cond)				\
 		break;				\
 	__SLEEP_COND(wq, cond, LCACHE_LOCK(flags), LCACHE_UNLOCK(flags)); \
 } while (0)
 #define	LCACHE_WAKEUP(event)	wake_up(event)
 /*
  *	lbuf buffer cache (lCache) control
  */
 /* log buffer manager pageout control (cumulative, inclusive) */
 #define	lbmREAD		0x0001
 #define	lbmWRITE	0x0002	/* enqueue at tail of write queue;
 				 * init pageout if at head of queue;
 				 */
 #define	lbmRELEASE	0x0004	/* remove from write queue
 				 * at completion of pageout;
 				 * do not free/recycle it yet:
 				 * caller will free it;
 				 */
 #define	lbmSYNC		0x0008	/* do not return to freelist
 				 * when removed from write queue;
 				 */
 #define lbmFREE		0x0010	/* return to freelist
 				 * at completion of pageout;
 				 * the buffer may be recycled;
 				 */
 #define	lbmDONE		0x0020
 #define	lbmERROR	0x0040
 #define lbmGC		0x0080	/* lbmIODone to perform post-GC processing
 				 * of log page
 				 */
 #define lbmDIRECT	0x0100
 /*
  * Global list of active external journals
  */
 static LIST_HEAD(jfs_external_logs);
 static struct jfs_log *dummy_log = NULL;
 static DECLARE_MUTEX(jfs_log_sem);
 /*
  * forward references
  */
 static int lmWriteRecord(struct jfs_log * log, struct tblock * tblk,
 			 struct lrd * lrd, struct tlock * tlck);
 static int lmNextPage(struct jfs_log * log);
 static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
 			   int activate);
 static int open_inline_log(struct super_block *sb);
 static int open_dummy_log(struct super_block *sb);
 static int lbmLogInit(struct jfs_log * log);
 static void lbmLogShutdown(struct jfs_log * log);
 static struct lbuf *lbmAllocate(struct jfs_log * log, int);
 static void lbmFree(struct lbuf * bp);
 static void lbmfree(struct lbuf * bp);
 static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp);
 static void lbmWrite(struct jfs_log * log, struct lbuf * bp, int flag, int cant_block);
 static void lbmDirectWrite(struct jfs_log * log, struct lbuf * bp, int flag);
 static int lbmIOWait(struct lbuf * bp, int flag);
 static bio_end_io_t lbmIODone;
 static void lbmStartIO(struct lbuf * bp);
 static void lmGCwrite(struct jfs_log * log, int cant_block);
-static int lmLogSync(struct jfs_log * log, int nosyncwait);
+static int lmLogSync(struct jfs_log * log, int hard_sync);
 /*
  *	statistics
  */
 #ifdef CONFIG_JFS_STATISTICS
 static struct lmStat {
 	uint commit;		/* # of commit */
 	uint pagedone;		/* # of page written */
 	uint submitted;		/* # of pages submitted */
 	uint full_page;		/* # of full pages submitted */
 	uint partial_page;	/* # of partial pages submitted */
 } lmStat;
 #endif
 /*
  * NAME:	lmLog()
  *
  * FUNCTION:	write a log record;
  *
  * PARAMETER:
  *
  * RETURN:	lsn - offset to the next log record to write (end-of-log);
  *		-1  - error;
  *
  * note: todo: log error handler
  */
 int lmLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	  struct tlock * tlck)
 {
 	int lsn;
 	int diffp, difft;
 	struct metapage *mp = NULL;
 	unsigned long flags;
 	jfs_info("lmLog: log:0x%p tblk:0x%p, lrd:0x%p tlck:0x%p",
 		 log, tblk, lrd, tlck);
 	LOG_LOCK(log);
 	/* log by (out-of-transaction) JFS ? */
 	if (tblk == NULL)
 		goto writeRecord;
 	/* log from page ? */
 	if (tlck == NULL ||
 	    tlck->type & tlckBTROOT || (mp = tlck->mp) == NULL)
 		goto writeRecord;
 	/*
 	 *      initialize/update page/transaction recovery lsn
 	 */
 	lsn = log->lsn;
 	LOGSYNC_LOCK(log, flags);
 	/*
 	 * initialize page lsn if first log write of the page
 	 */
 	if (mp->lsn == 0) {
 		mp->log = log;
 		mp->lsn = lsn;
 		log->count++;
 		/* insert page at tail of logsynclist */
 		list_add_tail(&mp->synclist, &log->synclist);
 	}
 	/*
 	 *      initialize/update lsn of tblock of the page
 	 *
 	 * transaction inherits oldest lsn of pages associated
 	 * with allocation/deallocation of resources (their
 	 * log records are used to reconstruct allocation map
 	 * at recovery time: inode for inode allocation map,
 	 * B+-tree index of extent descriptors for block
 	 * allocation map);
 	 * allocation map pages inherit transaction lsn at
 	 * commit time to allow forwarding log syncpt past log
 	 * records associated with allocation/deallocation of
 	 * resources only after persistent map of these map pages
 	 * have been updated and propagated to home.
 	 */
 	/*
 	 * initialize transaction lsn:
 	 */
 	if (tblk->lsn == 0) {
 		/* inherit lsn of its first page logged */
 		tblk->lsn = mp->lsn;
 		log->count++;
 		/* insert tblock after the page on logsynclist */
 		list_add(&tblk->synclist, &mp->synclist);
 	}
 	/*
 	 * update transaction lsn:
 	 */
 	else {
 		/* inherit oldest/smallest lsn of page */
 		logdiff(diffp, mp->lsn, log);
 		logdiff(difft, tblk->lsn, log);
 		if (diffp < difft) {
 			/* update tblock lsn with page lsn */
 			tblk->lsn = mp->lsn;
 			/* move tblock after page on logsynclist */
 			list_move(&tblk->synclist, &mp->synclist);
 		}
 	}
 	LOGSYNC_UNLOCK(log, flags);
 	/*
 	 *      write the log record
 	 */
       writeRecord:
 	lsn = lmWriteRecord(log, tblk, lrd, tlck);
 	/*
 	 * forward log syncpt if log reached next syncpt trigger
 	 */
 	logdiff(diffp, lsn, log);
 	if (diffp >= log->nextsync)
 		lsn = lmLogSync(log, 0);
 	/* update end-of-log lsn */
 	log->lsn = lsn;
 	LOG_UNLOCK(log);
 	/* return end-of-log address */
 	return lsn;
 }
 /*
  * NAME:	lmWriteRecord()
  *
  * FUNCTION:	move the log record to current log page
  *
  * PARAMETER:	cd	- commit descriptor
  *
  * RETURN:	end-of-log address
  *
  * serialization: LOG_LOCK() held on entry/exit
  */
 static int
 lmWriteRecord(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	      struct tlock * tlck)
 {
 	int lsn = 0;		/* end-of-log address */
 	struct lbuf *bp;	/* dst log page buffer */
 	struct logpage *lp;	/* dst log page */
 	caddr_t dst;		/* destination address in log page */
 	int dstoffset;		/* end-of-log offset in log page */
 	int freespace;		/* free space in log page */
 	caddr_t p;		/* src meta-data page */
 	caddr_t src;
 	int srclen;
 	int nbytes;		/* number of bytes to move */
 	int i;
 	int len;
 	struct linelock *linelock;
 	struct lv *lv;
 	struct lvd *lvd;
 	int l2linesize;
 	len = 0;
 	/* retrieve destination log page to write */
 	bp = (struct lbuf *) log->bp;
 	lp = (struct logpage *) bp->l_ldata;
 	dstoffset = log->eor;
 	/* any log data to write ? */
 	if (tlck == NULL)
 		goto moveLrd;
 	/*
 	 *      move log record data
 	 */
 	/* retrieve source meta-data page to log */
 	if (tlck->flag & tlckPAGELOCK) {
 		p = (caddr_t) (tlck->mp->data);
 		linelock = (struct linelock *) & tlck->lock;
 	}
 	/* retrieve source in-memory inode to log */
 	else if (tlck->flag & tlckINODELOCK) {
 		if (tlck->type & tlckDTREE)
 			p = (caddr_t) &JFS_IP(tlck->ip)->i_dtroot;
 		else
 			p = (caddr_t) &JFS_IP(tlck->ip)->i_xtroot;
 		linelock = (struct linelock *) & tlck->lock;
 	}
 #ifdef	_JFS_WIP
 	else if (tlck->flag & tlckINLINELOCK) {
 		inlinelock = (struct inlinelock *) & tlck;
 		p = (caddr_t) & inlinelock->pxd;
 		linelock = (struct linelock *) & tlck;
 	}
 #endif				/* _JFS_WIP */
 	else {
 		jfs_err("lmWriteRecord: UFO tlck:0x%p", tlck);
 		return 0;	/* Probably should trap */
 	}
 	l2linesize = linelock->l2linesize;
       moveData:
 	ASSERT(linelock->index <= linelock->maxcnt);
 	lv = linelock->lv;
 	for (i = 0; i < linelock->index; i++, lv++) {
 		if (lv->length == 0)
 			continue;
 		/* is page full ? */
 		if (dstoffset >= LOGPSIZE - LOGPTLRSIZE) {
 			/* page become full: move on to next page */
 			lmNextPage(log);
 			bp = log->bp;
 			lp = (struct logpage *) bp->l_ldata;
 			dstoffset = LOGPHDRSIZE;
 		}
 		/*
 		 * move log vector data
 		 */
 		src = (u8 *) p + (lv->offset << l2linesize);
 		srclen = lv->length << l2linesize;
 		len += srclen;
 		while (srclen > 0) {
 			freespace = (LOGPSIZE - LOGPTLRSIZE) - dstoffset;
 			nbytes = min(freespace, srclen);
 			dst = (caddr_t) lp + dstoffset;
 			memcpy(dst, src, nbytes);
 			dstoffset += nbytes;
 			/* is page not full ? */
 			if (dstoffset < LOGPSIZE - LOGPTLRSIZE)
 				break;
 			/* page become full: move on to next page */
 			lmNextPage(log);
 			bp = (struct lbuf *) log->bp;
 			lp = (struct logpage *) bp->l_ldata;
 			dstoffset = LOGPHDRSIZE;
 			srclen -= nbytes;
 			src += nbytes;
 		}
 		/*
 		 * move log vector descriptor
 		 */
 		len += 4;
 		lvd = (struct lvd *) ((caddr_t) lp + dstoffset);
 		lvd->offset = cpu_to_le16(lv->offset);
 		lvd->length = cpu_to_le16(lv->length);
 		dstoffset += 4;
 		jfs_info("lmWriteRecord: lv offset:%d length:%d",
 			 lv->offset, lv->length);
 	}
 	if ((i = linelock->next)) {
 		linelock = (struct linelock *) lid_to_tlock(i);
 		goto moveData;
 	}
 	/*
 	 *      move log record descriptor
 	 */
       moveLrd:
 	lrd->length = cpu_to_le16(len);
 	src = (caddr_t) lrd;
 	srclen = LOGRDSIZE;
 	while (srclen > 0) {
 		freespace = (LOGPSIZE - LOGPTLRSIZE) - dstoffset;
 		nbytes = min(freespace, srclen);
 		dst = (caddr_t) lp + dstoffset;
 		memcpy(dst, src, nbytes);
 		dstoffset += nbytes;
 		srclen -= nbytes;
 		/* are there more to move than freespace of page ? */
 		if (srclen)
 			goto pageFull;
 		/*
 		 * end of log record descriptor
 		 */
 		/* update last log record eor */
 		log->eor = dstoffset;
 		bp->l_eor = dstoffset;
 		lsn = (log->page << L2LOGPSIZE) + dstoffset;
 		if (lrd->type & cpu_to_le16(LOG_COMMIT)) {
 			tblk->clsn = lsn;
 			jfs_info("wr: tclsn:0x%x, beor:0x%x", tblk->clsn,
 				 bp->l_eor);
 			INCREMENT(lmStat.commit);	/* # of commit */
 			/*
 			 * enqueue tblock for group commit:
 			 *
 			 * enqueue tblock of non-trivial/synchronous COMMIT
 			 * at tail of group commit queue
 			 * (trivial/asynchronous COMMITs are ignored by
 			 * group commit.)
 			 */
 			LOGGC_LOCK(log);
 			/* init tblock gc state */
 			tblk->flag = tblkGC_QUEUE;
 			tblk->bp = log->bp;
 			tblk->pn = log->page;
 			tblk->eor = log->eor;
 			/* enqueue transaction to commit queue */
 			list_add_tail(&tblk->cqueue, &log->cqueue);
 			LOGGC_UNLOCK(log);
 		}
 		jfs_info("lmWriteRecord: lrd:0x%04x bp:0x%p pn:%d eor:0x%x",
 			le16_to_cpu(lrd->type), log->bp, log->page, dstoffset);
 		/* page not full ? */
 		if (dstoffset < LOGPSIZE - LOGPTLRSIZE)
 			return lsn;
 	      pageFull:
 		/* page become full: move on to next page */
 		lmNextPage(log);
 		bp = (struct lbuf *) log->bp;
 		lp = (struct logpage *) bp->l_ldata;
 		dstoffset = LOGPHDRSIZE;
 		src += nbytes;
 	}
 	return lsn;
 }
 /*
  * NAME:	lmNextPage()
  *
  * FUNCTION:	write current page and allocate next page.
  *
  * PARAMETER:	log
  *
  * RETURN:	0
  *
  * serialization: LOG_LOCK() held on entry/exit
  */
 static int lmNextPage(struct jfs_log * log)
 {
 	struct logpage *lp;
 	int lspn;		/* log sequence page number */
 	int pn;			/* current page number */
 	struct lbuf *bp;
 	struct lbuf *nextbp;
 	struct tblock *tblk;
 	/* get current log page number and log sequence page number */
 	pn = log->page;
 	bp = log->bp;
 	lp = (struct logpage *) bp->l_ldata;
 	lspn = le32_to_cpu(lp->h.page);
 	LOGGC_LOCK(log);
 	/*
 	 *      write or queue the full page at the tail of write queue
 	 */
 	/* get the tail tblk on commit queue */
 	if (list_empty(&log->cqueue))
 		tblk = NULL;
 	else
 		tblk = list_entry(log->cqueue.prev, struct tblock, cqueue);
 	/* every tblk who has COMMIT record on the current page,
 	 * and has not been committed, must be on commit queue
 	 * since tblk is queued at commit queueu at the time
 	 * of writing its COMMIT record on the page before
 	 * page becomes full (even though the tblk thread
 	 * who wrote COMMIT record may have been suspended
 	 * currently);
 	 */
 	/* is page bound with outstanding tail tblk ? */
 	if (tblk && tblk->pn == pn) {
 		/* mark tblk for end-of-page */
 		tblk->flag |= tblkGC_EOP;
 		if (log->cflag & logGC_PAGEOUT) {
 			/* if page is not already on write queue,
 			 * just enqueue (no lbmWRITE to prevent redrive)
 			 * buffer to wqueue to ensure correct serial order
 			 * of the pages since log pages will be added
 			 * continuously
 			 */
 			if (bp->l_wqnext == NULL)
 				lbmWrite(log, bp, 0, 0);
 		} else {
 			/*
 			 * No current GC leader, initiate group commit
 			 */
 			log->cflag |= logGC_PAGEOUT;
 			lmGCwrite(log, 0);
 		}
 	}
 	/* page is not bound with outstanding tblk:
 	 * init write or mark it to be redriven (lbmWRITE)
 	 */
 	else {
 		/* finalize the page */
 		bp->l_ceor = bp->l_eor;
 		lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
 		lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmFREE, 0);
 	}
 	LOGGC_UNLOCK(log);
 	/*
 	 *      allocate/initialize next page
 	 */
 	/* if log wraps, the first data page of log is 2
 	 * (0 never used, 1 is superblock).
 	 */
 	log->page = (pn == log->size - 1) ? 2 : pn + 1;
 	log->eor = LOGPHDRSIZE;	/* ? valid page empty/full at logRedo() */
 	/* allocate/initialize next log page buffer */
 	nextbp = lbmAllocate(log, log->page);
 	nextbp->l_eor = log->eor;
 	log->bp = nextbp;
 	/* initialize next log page */
 	lp = (struct logpage *) nextbp->l_ldata;
 	lp->h.page = lp->t.page = cpu_to_le32(lspn + 1);
 	lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE);
 	return 0;
 }
 /*
  * NAME:	lmGroupCommit()
  *
  * FUNCTION:	group commit
  *	initiate pageout of the pages with COMMIT in the order of
  *	page number - redrive pageout of the page at the head of
  *	pageout queue until full page has been written.
  *
  * RETURN:
  *
  * NOTE:
  *	LOGGC_LOCK serializes log group commit queue, and
  *	transaction blocks on the commit queue.
  *	N.B. LOG_LOCK is NOT held during lmGroupCommit().
  */
 int lmGroupCommit(struct jfs_log * log, struct tblock * tblk)
 {
 	int rc = 0;
 	LOGGC_LOCK(log);
 	/* group committed already ? */
 	if (tblk->flag & tblkGC_COMMITTED) {
 		if (tblk->flag & tblkGC_ERROR)
 			rc = -EIO;
 		LOGGC_UNLOCK(log);
 		return rc;
 	}
 	jfs_info("lmGroup Commit: tblk = 0x%p, gcrtc = %d", tblk, log->gcrtc);
 	if (tblk->xflag & COMMIT_LAZY)
 		tblk->flag |= tblkGC_LAZY;
 	if ((!(log->cflag & logGC_PAGEOUT)) && (!list_empty(&log->cqueue)) &&
 	    (!(tblk->xflag & COMMIT_LAZY) || test_bit(log_FLUSH, &log->flag)
 	     || jfs_tlocks_low)) {
 		/*
 		 * No pageout in progress
 		 *
 		 * start group commit as its group leader.
 		 */
 		log->cflag |= logGC_PAGEOUT;
 		lmGCwrite(log, 0);
 	}
 	if (tblk->xflag & COMMIT_LAZY) {
 		/*
 		 * Lazy transactions can leave now
 		 */
 		LOGGC_UNLOCK(log);
 		return 0;
 	}
 	/* lmGCwrite gives up LOGGC_LOCK, check again */
 	if (tblk->flag & tblkGC_COMMITTED) {
 		if (tblk->flag & tblkGC_ERROR)
 			rc = -EIO;
 		LOGGC_UNLOCK(log);
 		return rc;
 	}
 	/* upcount transaction waiting for completion
 	 */
 	log->gcrtc++;
 	tblk->flag |= tblkGC_READY;
 	__SLEEP_COND(tblk->gcwait, (tblk->flag & tblkGC_COMMITTED),
 		     LOGGC_LOCK(log), LOGGC_UNLOCK(log));
 	/* removed from commit queue */
 	if (tblk->flag & tblkGC_ERROR)
 		rc = -EIO;
 	LOGGC_UNLOCK(log);
 	return rc;
 }
 /*
  * NAME:	lmGCwrite()
  *
  * FUNCTION:	group commit write
  *	initiate write of log page, building a group of all transactions
  *	with commit records on that page.
  *
  * RETURN:	None
  *
  * NOTE:
  *	LOGGC_LOCK must be held by caller.
  *	N.B. LOG_LOCK is NOT held during lmGroupCommit().
  */
 static void lmGCwrite(struct jfs_log * log, int cant_write)
 {
 	struct lbuf *bp;
 	struct logpage *lp;
 	int gcpn;		/* group commit page number */
 	struct tblock *tblk;
 	struct tblock *xtblk = NULL;
 	/*
 	 * build the commit group of a log page
 	 *
 	 * scan commit queue and make a commit group of all
 	 * transactions with COMMIT records on the same log page.
 	 */
 	/* get the head tblk on the commit queue */
 	gcpn = list_entry(log->cqueue.next, struct tblock, cqueue)->pn;
 	list_for_each_entry(tblk, &log->cqueue, cqueue) {
 		if (tblk->pn != gcpn)
 			break;
 		xtblk = tblk;
 		/* state transition: (QUEUE, READY) -> COMMIT */
 		tblk->flag |= tblkGC_COMMIT;
 	}
 	tblk = xtblk;		/* last tblk of the page */
 	/*
 	 * pageout to commit transactions on the log page.
 	 */
 	bp = (struct lbuf *) tblk->bp;
 	lp = (struct logpage *) bp->l_ldata;
 	/* is page already full ? */
 	if (tblk->flag & tblkGC_EOP) {
 		/* mark page to free at end of group commit of the page */
 		tblk->flag &= ~tblkGC_EOP;
 		tblk->flag |= tblkGC_FREE;
 		bp->l_ceor = bp->l_eor;
 		lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
 		lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmGC,
 			 cant_write);
 		INCREMENT(lmStat.full_page);
 	}
 	/* page is not yet full */
 	else {
 		bp->l_ceor = tblk->eor;	/* ? bp->l_ceor = bp->l_eor; */
 		lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
 		lbmWrite(log, bp, lbmWRITE | lbmGC, cant_write);
 		INCREMENT(lmStat.partial_page);
 	}
 }
 /*
  * NAME:	lmPostGC()
  *
  * FUNCTION:	group commit post-processing
  *	Processes transactions after their commit records have been written
  *	to disk, redriving log I/O if necessary.
  *
  * RETURN:	None
  *
  * NOTE:
  *	This routine is called a interrupt time by lbmIODone
  */
 static void lmPostGC(struct lbuf * bp)
 {
 	unsigned long flags;
 	struct jfs_log *log = bp->l_log;
 	struct logpage *lp;
 	struct tblock *tblk, *temp;
 	//LOGGC_LOCK(log);
 	spin_lock_irqsave(&log->gclock, flags);
 	/*
 	 * current pageout of group commit completed.
 	 *
 	 * remove/wakeup transactions from commit queue who were
 	 * group committed with the current log page
 	 */
 	list_for_each_entry_safe(tblk, temp, &log->cqueue, cqueue) {
 		if (!(tblk->flag & tblkGC_COMMIT))
 			break;
 		/* if transaction was marked GC_COMMIT then
 		 * it has been shipped in the current pageout
 		 * and made it to disk - it is committed.
 		 */
 		if (bp->l_flag & lbmERROR)
 			tblk->flag |= tblkGC_ERROR;
 		/* remove it from the commit queue */
 		list_del(&tblk->cqueue);
 		tblk->flag &= ~tblkGC_QUEUE;
 		if (tblk == log->flush_tblk) {
 			/* we can stop flushing the log now */
 			clear_bit(log_FLUSH, &log->flag);
 			log->flush_tblk = NULL;
 		}
 		jfs_info("lmPostGC: tblk = 0x%p, flag = 0x%x", tblk,
 			 tblk->flag);
 		if (!(tblk->xflag & COMMIT_FORCE))
 			/*
 			 * Hand tblk over to lazy commit thread
 			 */
 			txLazyUnlock(tblk);
 		else {
 			/* state transition: COMMIT -> COMMITTED */
 			tblk->flag |= tblkGC_COMMITTED;
 			if (tblk->flag & tblkGC_READY)
 				log->gcrtc--;
 			LOGGC_WAKEUP(tblk);
 		}
 		/* was page full before pageout ?
 		 * (and this is the last tblk bound with the page)
 		 */
 		if (tblk->flag & tblkGC_FREE)
 			lbmFree(bp);
 		/* did page become full after pageout ?
 		 * (and this is the last tblk bound with the page)
 		 */
 		else if (tblk->flag & tblkGC_EOP) {
 			/* finalize the page */
 			lp = (struct logpage *) bp->l_ldata;
 			bp->l_ceor = bp->l_eor;
 			lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
 			jfs_info("lmPostGC: calling lbmWrite");
 			lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmFREE,
 				 1);
 		}
 	}
 	/* are there any transactions who have entered lnGroupCommit()
 	 * (whose COMMITs are after that of the last log page written.
 	 * They are waiting for new group commit (above at (SLEEP 1))
 	 * or lazy transactions are on a full (queued) log page,
 	 * select the latest ready transaction as new group leader and
 	 * wake her up to lead her group.
 	 */
 	if ((!list_empty(&log->cqueue)) &&
 	    ((log->gcrtc > 0) || (tblk->bp->l_wqnext != NULL) ||
 	     test_bit(log_FLUSH, &log->flag) || jfs_tlocks_low))
 		/*
 		 * Call lmGCwrite with new group leader
 		 */
 		lmGCwrite(log, 1);
 	/* no transaction are ready yet (transactions are only just
 	 * queued (GC_QUEUE) and not entered for group commit yet).
 	 * the first transaction entering group commit
 	 * will elect herself as new group leader.
 	 */
 	else
 		log->cflag &= ~logGC_PAGEOUT;
 	//LOGGC_UNLOCK(log);
 	spin_unlock_irqrestore(&log->gclock, flags);
 	return;
 }
 /*
  * NAME:	lmLogSync()
  *
  * FUNCTION:	write log SYNCPT record for specified log
  *	if new sync address is available
  *	(normally the case if sync() is executed by back-ground
  *	process).
- *	if not, explicitly run jfs_blogsync() to initiate
- *	getting of new sync address.
  *	calculate new value of i_nextsync which determines when
  *	this code is called again.
  *
  * PARAMETERS:	log	- log structure
- * 		nosyncwait - 1 if called asynchronously
+ * 		hard_sync - 1 to force all metadata to be written
  *
  * RETURN:	0
  *
  * serialization: LOG_LOCK() held on entry/exit
  */
-static int lmLogSync(struct jfs_log * log, int nosyncwait)
+static int lmLogSync(struct jfs_log * log, int hard_sync)
 {
 	int logsize;
 	int written;		/* written since last syncpt */
 	int free;		/* free space left available */
 	int delta;		/* additional delta to write normally */
 	int more;		/* additional write granted */
 	struct lrd lrd;
 	int lsn;
 	struct logsyncblk *lp;
 	struct jfs_sb_info *sbi;
 	unsigned long flags;
 	/* push dirty metapages out to disk */
-	list_for_each_entry(sbi, &log->sb_list, log_list) {
+	if (hard_sync)
-		filemap_flush(sbi->ipbmap->i_mapping);
+		list_for_each_entry(sbi, &log->sb_list, log_list) {
-		filemap_flush(sbi->ipimap->i_mapping);
+			filemap_fdatawrite(sbi->ipbmap->i_mapping);
-		filemap_flush(sbi->direct_inode->i_mapping);
+			filemap_fdatawrite(sbi->ipimap->i_mapping);
-	}
+			filemap_fdatawrite(sbi->direct_inode->i_mapping);
+		}
+	else
+		list_for_each_entry(sbi, &log->sb_list, log_list) {
+			filemap_flush(sbi->ipbmap->i_mapping);
+			filemap_flush(sbi->ipimap->i_mapping);
+			filemap_flush(sbi->direct_inode->i_mapping);
+		}
 	/*
 	 *      forward syncpt
 	 */
 	/* if last sync is same as last syncpt,
 	 * invoke sync point forward processing to update sync.
 	 */
 	if (log->sync == log->syncpt) {
 		LOGSYNC_LOCK(log, flags);
 		if (list_empty(&log->synclist))
 			log->sync = log->lsn;
 		else {
 			lp = list_entry(log->synclist.next,
 					struct logsyncblk, synclist);
 			log->sync = lp->lsn;
 		}
 		LOGSYNC_UNLOCK(log, flags);
 	}
 	/* if sync is different from last syncpt,
 	 * write a SYNCPT record with syncpt = sync.
 	 * reset syncpt = sync
 	 */
 	if (log->sync != log->syncpt) {
 		lrd.logtid = 0;
 		lrd.backchain = 0;
 		lrd.type = cpu_to_le16(LOG_SYNCPT);
 		lrd.length = 0;
 		lrd.log.syncpt.sync = cpu_to_le32(log->sync);
 		lsn = lmWriteRecord(log, NULL, &lrd, NULL);
 		log->syncpt = log->sync;
 	} else
 		lsn = log->lsn;
 	/*
 	 *      setup next syncpt trigger (SWAG)
 	 */
 	logsize = log->logsize;
 	logdiff(written, lsn, log);
 	free = logsize - written;
 	delta = LOGSYNC_DELTA(logsize);
 	more = min(free / 2, delta);
 	if (more < 2 * LOGPSIZE) {
 		jfs_warn("\n ... Log Wrap ... Log Wrap ... Log Wrap ...\n");
 		/*
 		 *      log wrapping
 		 *
 		 * option 1 - panic ? No.!
 		 * option 2 - shutdown file systems
 		 *            associated with log ?
 		 * option 3 - extend log ?
 		 */
 		/*
 		 * option 4 - second chance
 		 *
 		 * mark log wrapped, and continue.
 		 * when all active transactions are completed,
 		 * mark log vaild for recovery.
 		 * if crashed during invalid state, log state
 		 * implies invald log, forcing fsck().
 		 */
 		/* mark log state log wrap in log superblock */
 		/* log->state = LOGWRAP; */
 		/* reset sync point computation */
 		log->syncpt = log->sync = lsn;
 		log->nextsync = delta;
 	} else
 		/* next syncpt trigger = written + more */
 		log->nextsync = written + more;
-	/* return if lmLogSync() from outside of transaction, e.g., sync() */
-	if (nosyncwait)
-		return lsn;
 	/* if number of bytes written from last sync point is more
 	 * than 1/4 of the log size, stop new transactions from
 	 * starting until all current transactions are completed
 	 * by setting syncbarrier flag.
 	 */
 	if (!test_bit(log_SYNCBARRIER, &log->flag) &&
 	    (written > LOGSYNC_BARRIER(logsize)) && log->active) {
 		set_bit(log_SYNCBARRIER, &log->flag);
 		jfs_info("log barrier on: lsn=0x%x syncpt=0x%x", lsn,
 			 log->syncpt);
 		/*
 		 * We may have to initiate group commit
 		 */
 		jfs_flush_journal(log, 0);
 	}
 	return lsn;
 }
 /*
  * NAME:	jfs_syncpt
  *
  * FUNCTION:	write log SYNCPT record for specified log
  *
- * PARAMETERS:	log	- log structure
+ * PARAMETERS:	log	  - log structure
+ * 		hard_sync - set to 1 to force metadata to be written
  */
-void jfs_syncpt(struct jfs_log *log)
+void jfs_syncpt(struct jfs_log *log, int hard_sync)
 {	LOG_LOCK(log);
-	lmLogSync(log, 1);
+	lmLogSync(log, hard_sync);
 	LOG_UNLOCK(log);
 }
 /*
  * NAME:	lmLogOpen()
  *
  * FUNCTION:    open the log on first open;
  *	insert filesystem in the active list of the log.
  *
  * PARAMETER:	ipmnt	- file system mount inode
  *		iplog 	- log inode (out)
  *
  * RETURN:
  *
  * serialization:
  */
 int lmLogOpen(struct super_block *sb)
 {
 	int rc;
 	struct block_device *bdev;
 	struct jfs_log *log;
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	if (sbi->flag & JFS_NOINTEGRITY)
 		return open_dummy_log(sb);
 	if (sbi->mntflag & JFS_INLINELOG)
 		return open_inline_log(sb);
 	down(&jfs_log_sem);
 	list_for_each_entry(log, &jfs_external_logs, journal_list) {
 		if (log->bdev->bd_dev == sbi->logdev) {
 			if (memcmp(log->uuid, sbi->loguuid,
 				   sizeof(log->uuid))) {
 				jfs_warn("wrong uuid on JFS journal\n");
 				up(&jfs_log_sem);
 				return -EINVAL;
 			}
 			/*
 			 * add file system to log active file system list
 			 */
 			if ((rc = lmLogFileSystem(log, sbi, 1))) {
 				up(&jfs_log_sem);
 				return rc;
 			}
 			goto journal_found;
 		}
 	}
 	if (!(log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL))) {
 		up(&jfs_log_sem);
 		return -ENOMEM;
 	}
 	memset(log, 0, sizeof(struct jfs_log));
 	INIT_LIST_HEAD(&log->sb_list);
 	init_waitqueue_head(&log->syncwait);
 	/*
 	 *      external log as separate logical volume
 	 *
 	 * file systems to log may have n-to-1 relationship;
 	 */
 	bdev = open_by_devnum(sbi->logdev, FMODE_READ|FMODE_WRITE);
 	if (IS_ERR(bdev)) {
 		rc = -PTR_ERR(bdev);
 		goto free;
 	}
 	if ((rc = bd_claim(bdev, log))) {
 		goto close;
 	}
 	log->bdev = bdev;
 	memcpy(log->uuid, sbi->loguuid, sizeof(log->uuid));
 	/*
 	 * initialize log:
 	 */
 	if ((rc = lmLogInit(log)))
 		goto unclaim;
 	list_add(&log->journal_list, &jfs_external_logs);
 	/*
 	 * add file system to log active file system list
 	 */
 	if ((rc = lmLogFileSystem(log, sbi, 1)))
 		goto shutdown;
 journal_found:
 	LOG_LOCK(log);
 	list_add(&sbi->log_list, &log->sb_list);
 	sbi->log = log;
 	LOG_UNLOCK(log);
 	up(&jfs_log_sem);
 	return 0;
 	/*
 	 *      unwind on error
 	 */
       shutdown:		/* unwind lbmLogInit() */
 	list_del(&log->journal_list);
 	lbmLogShutdown(log);
       unclaim:
 	bd_release(bdev);
       close:		/* close external log device */
 	blkdev_put(bdev);
       free:		/* free log descriptor */
 	up(&jfs_log_sem);
 	kfree(log);
 	jfs_warn("lmLogOpen: exit(%d)", rc);
 	return rc;
 }
 static int open_inline_log(struct super_block *sb)
 {
 	struct jfs_log *log;
 	int rc;
 	if (!(log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL)))
 		return -ENOMEM;
 	memset(log, 0, sizeof(struct jfs_log));
 	INIT_LIST_HEAD(&log->sb_list);
 	init_waitqueue_head(&log->syncwait);
 	set_bit(log_INLINELOG, &log->flag);
 	log->bdev = sb->s_bdev;
 	log->base = addressPXD(&JFS_SBI(sb)->logpxd);
 	log->size = lengthPXD(&JFS_SBI(sb)->logpxd) >>
 	    (L2LOGPSIZE - sb->s_blocksize_bits);
 	log->l2bsize = sb->s_blocksize_bits;
 	ASSERT(L2LOGPSIZE >= sb->s_blocksize_bits);
 	/*
 	 * initialize log.
 	 */
 	if ((rc = lmLogInit(log))) {
 		kfree(log);
 		jfs_warn("lmLogOpen: exit(%d)", rc);
 		return rc;
 	}
 	list_add(&JFS_SBI(sb)->log_list, &log->sb_list);
 	JFS_SBI(sb)->log = log;
 	return rc;
 }
 static int open_dummy_log(struct super_block *sb)
 {
 	int rc;
 	down(&jfs_log_sem);
 	if (!dummy_log) {
 		dummy_log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL);
 		if (!dummy_log) {
 			up(&jfs_log_sem);
 			return -ENOMEM;
 		}
 		memset(dummy_log, 0, sizeof(struct jfs_log));
 		INIT_LIST_HEAD(&dummy_log->sb_list);
 		init_waitqueue_head(&dummy_log->syncwait);
 		dummy_log->no_integrity = 1;
 		/* Make up some stuff */
 		dummy_log->base = 0;
 		dummy_log->size = 1024;
 		rc = lmLogInit(dummy_log);
 		if (rc) {
 			kfree(dummy_log);
 			dummy_log = NULL;
 			up(&jfs_log_sem);
 			return rc;
 		}
 	}
 	LOG_LOCK(dummy_log);
 	list_add(&JFS_SBI(sb)->log_list, &dummy_log->sb_list);
 	JFS_SBI(sb)->log = dummy_log;
 	LOG_UNLOCK(dummy_log);
 	up(&jfs_log_sem);
 	return 0;
 }
 /*
  * NAME:	lmLogInit()
  *
  * FUNCTION:	log initialization at first log open.
  *
  *	logredo() (or logformat()) should have been run previously.
  *	initialize the log from log superblock.
  *	set the log state in the superblock to LOGMOUNT and
  *	write SYNCPT log record.
  *
  * PARAMETER:	log	- log structure
  *
  * RETURN:	0	- if ok
  *		-EINVAL	- bad log magic number or superblock dirty
  *		error returned from logwait()
  *
  * serialization: single first open thread
  */
 int lmLogInit(struct jfs_log * log)
 {
 	int rc = 0;
 	struct lrd lrd;
 	struct logsuper *logsuper;
 	struct lbuf *bpsuper;
 	struct lbuf *bp;
 	struct logpage *lp;
 	int lsn = 0;
 	jfs_info("lmLogInit: log:0x%p", log);
 	/* initialize the group commit serialization lock */
 	LOGGC_LOCK_INIT(log);
 	/* allocate/initialize the log write serialization lock */
 	LOG_LOCK_INIT(log);
 	LOGSYNC_LOCK_INIT(log);
 	INIT_LIST_HEAD(&log->synclist);
 	INIT_LIST_HEAD(&log->cqueue);
 	log->flush_tblk = NULL;
 	log->count = 0;
 	/*
 	 * initialize log i/o
 	 */
 	if ((rc = lbmLogInit(log)))
 		return rc;
 	if (!test_bit(log_INLINELOG, &log->flag))
 		log->l2bsize = L2LOGPSIZE;
 	/* check for disabled journaling to disk */
 	if (log->no_integrity) {
 		/*
 		 * Journal pages will still be filled.  When the time comes
 		 * to actually do the I/O, the write is not done, and the
 		 * endio routine is called directly.
 		 */
 		bp = lbmAllocate(log , 0);
 		log->bp = bp;
 		bp->l_pn = bp->l_eor = 0;
 	} else {
 		/*
 		 * validate log superblock
 		 */
 		if ((rc = lbmRead(log, 1, &bpsuper)))
 			goto errout10;
 		logsuper = (struct logsuper *) bpsuper->l_ldata;
 		if (logsuper->magic != cpu_to_le32(LOGMAGIC)) {
 			jfs_warn("*** Log Format Error ! ***");
 			rc = -EINVAL;
 			goto errout20;
 		}
 		/* logredo() should have been run successfully. */
 		if (logsuper->state != cpu_to_le32(LOGREDONE)) {
 			jfs_warn("*** Log Is Dirty ! ***");
 			rc = -EINVAL;
 			goto errout20;
 		}
 		/* initialize log from log superblock */
 		if (test_bit(log_INLINELOG,&log->flag)) {
 			if (log->size != le32_to_cpu(logsuper->size)) {
 				rc = -EINVAL;
 				goto errout20;
 			}
 			jfs_info("lmLogInit: inline log:0x%p base:0x%Lx "
 				 "size:0x%x", log,
 				 (unsigned long long) log->base, log->size);
 		} else {
 			if (memcmp(logsuper->uuid, log->uuid, 16)) {
 				jfs_warn("wrong uuid on JFS log device");
 				goto errout20;
 			}
 			log->size = le32_to_cpu(logsuper->size);
 			log->l2bsize = le32_to_cpu(logsuper->l2bsize);
 			jfs_info("lmLogInit: external log:0x%p base:0x%Lx "
 				 "size:0x%x", log,
 				 (unsigned long long) log->base, log->size);
 		}
 		log->page = le32_to_cpu(logsuper->end) / LOGPSIZE;
 		log->eor = le32_to_cpu(logsuper->end) - (LOGPSIZE * log->page);
 		/*
 		 * initialize for log append write mode
 		 */
 		/* establish current/end-of-log page/buffer */
 		if ((rc = lbmRead(log, log->page, &bp)))
 			goto errout20;
 		lp = (struct logpage *) bp->l_ldata;
 		jfs_info("lmLogInit: lsn:0x%x page:%d eor:%d:%d",
 			 le32_to_cpu(logsuper->end), log->page, log->eor,
 			 le16_to_cpu(lp->h.eor));
 		log->bp = bp;
 		bp->l_pn = log->page;
 		bp->l_eor = log->eor;
 		/* if current page is full, move on to next page */
 		if (log->eor >= LOGPSIZE - LOGPTLRSIZE)
 			lmNextPage(log);
 		/*
 		 * initialize log syncpoint
 		 */
 		/*
 		 * write the first SYNCPT record with syncpoint = 0
 		 * (i.e., log redo up to HERE !);
 		 * remove current page from lbm write queue at end of pageout
 		 * (to write log superblock update), but do not release to
 		 * freelist;
 		 */
 		lrd.logtid = 0;
 		lrd.backchain = 0;
 		lrd.type = cpu_to_le16(LOG_SYNCPT);
 		lrd.length = 0;
 		lrd.log.syncpt.sync = 0;
 		lsn = lmWriteRecord(log, NULL, &lrd, NULL);
 		bp = log->bp;
 		bp->l_ceor = bp->l_eor;
 		lp = (struct logpage *) bp->l_ldata;
 		lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
 		lbmWrite(log, bp, lbmWRITE | lbmSYNC, 0);
 		if ((rc = lbmIOWait(bp, 0)))
 			goto errout30;
 		/*
 		 * update/write superblock
 		 */
 		logsuper->state = cpu_to_le32(LOGMOUNT);
 		log->serial = le32_to_cpu(logsuper->serial) + 1;
 		logsuper->serial = cpu_to_le32(log->serial);
 		lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
 		if ((rc = lbmIOWait(bpsuper, lbmFREE)))
 			goto errout30;
 	}
 	/* initialize logsync parameters */
 	log->logsize = (log->size - 2) << L2LOGPSIZE;
 	log->lsn = lsn;
 	log->syncpt = lsn;
 	log->sync = log->syncpt;
 	log->nextsync = LOGSYNC_DELTA(log->logsize);
 	jfs_info("lmLogInit: lsn:0x%x syncpt:0x%x sync:0x%x",
 		 log->lsn, log->syncpt, log->sync);
 	/*
 	 * initialize for lazy/group commit
 	 */
 	log->clsn = lsn;
 	return 0;
 	/*
 	 *      unwind on error
 	 */
       errout30:		/* release log page */
 	log->wqueue = NULL;
 	bp->l_wqnext = NULL;
 	lbmFree(bp);
       errout20:		/* release log superblock */
 	lbmFree(bpsuper);
       errout10:		/* unwind lbmLogInit() */
 	lbmLogShutdown(log);
 	jfs_warn("lmLogInit: exit(%d)", rc);
 	return rc;
 }
 /*
  * NAME:	lmLogClose()
  *
  * FUNCTION:	remove file system <ipmnt> from active list of log <iplog>
  *		and close it on last close.
  *
  * PARAMETER:	sb	- superblock
  *
  * RETURN:	errors from subroutines
  *
  * serialization:
  */
 int lmLogClose(struct super_block *sb)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	struct jfs_log *log = sbi->log;
 	struct block_device *bdev;
 	int rc = 0;
 	jfs_info("lmLogClose: log:0x%p", log);
 	down(&jfs_log_sem);
 	LOG_LOCK(log);
 	list_del(&sbi->log_list);
 	LOG_UNLOCK(log);
 	sbi->log = NULL;
 	/*
 	 * We need to make sure all of the "written" metapages
 	 * actually make it to disk
 	 */
 	sync_blockdev(sb->s_bdev);
 	if (test_bit(log_INLINELOG, &log->flag)) {
 		/*
 		 *      in-line log in host file system
 		 */
 		rc = lmLogShutdown(log);
 		kfree(log);
 		goto out;
 	}
 	if (!log->no_integrity)
 		lmLogFileSystem(log, sbi, 0);
 	if (!list_empty(&log->sb_list))
 		goto out;
 	/*
 	 * TODO: ensure that the dummy_log is in a state to allow
 	 * lbmLogShutdown to deallocate all the buffers and call
 	 * kfree against dummy_log.  For now, leave dummy_log & its
 	 * buffers in memory, and resuse if another no-integrity mount
 	 * is requested.
 	 */
 	if (log->no_integrity)
 		goto out;
 	/*
 	 *      external log as separate logical volume
 	 */
 	list_del(&log->journal_list);
 	bdev = log->bdev;
 	rc = lmLogShutdown(log);
 	bd_release(bdev);
 	blkdev_put(bdev);
 	kfree(log);
       out:
 	up(&jfs_log_sem);
 	jfs_info("lmLogClose: exit(%d)", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_flush_journal()
  *
  * FUNCTION:	initiate write of any outstanding transactions to the journal
  *		and optionally wait until they are all written to disk
  *
  *		wait == 0  flush until latest txn is committed, don't wait
  *		wait == 1  flush until latest txn is committed, wait
  *		wait > 1   flush until all txn's are complete, wait
  */
 void jfs_flush_journal(struct jfs_log *log, int wait)
 {
 	int i;
 	struct tblock *target = NULL;
 	struct jfs_sb_info *sbi;
 	/* jfs_write_inode may call us during read-only mount */
 	if (!log)
 		return;
 	jfs_info("jfs_flush_journal: log:0x%p wait=%d", log, wait);
 	LOGGC_LOCK(log);
 	if (!list_empty(&log->cqueue)) {
 		/*
 		 * This ensures that we will keep writing to the journal as long
 		 * as there are unwritten commit records
 		 */
 		target = list_entry(log->cqueue.prev, struct tblock, cqueue);
 		if (test_bit(log_FLUSH, &log->flag)) {
 			/*
 			 * We're already flushing.
 			 * if flush_tblk is NULL, we are flushing everything,
 			 * so leave it that way.  Otherwise, update it to the
 			 * latest transaction
 			 */
 			if (log->flush_tblk)
 				log->flush_tblk = target;
 		} else {
 			/* Only flush until latest transaction is committed */
 			log->flush_tblk = target;
 			set_bit(log_FLUSH, &log->flag);
 			/*
 			 * Initiate I/O on outstanding transactions
 			 */
 			if (!(log->cflag & logGC_PAGEOUT)) {
 				log->cflag |= logGC_PAGEOUT;
 				lmGCwrite(log, 0);
 			}
 		}
 	}
 	if ((wait > 1) || test_bit(log_SYNCBARRIER, &log->flag)) {
 		/* Flush until all activity complete */
 		set_bit(log_FLUSH, &log->flag);
 		log->flush_tblk = NULL;
 	}
 	if (wait && target && !(target->flag & tblkGC_COMMITTED)) {
 		DECLARE_WAITQUEUE(__wait, current);
 		add_wait_queue(&target->gcwait, &__wait);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		LOGGC_UNLOCK(log);
 		schedule();
 		current->state = TASK_RUNNING;
 		LOGGC_LOCK(log);
 		remove_wait_queue(&target->gcwait, &__wait);
 	}
 	LOGGC_UNLOCK(log);
 	if (wait < 2)
 		return;
 	list_for_each_entry(sbi, &log->sb_list, log_list) {
 		filemap_fdatawrite(sbi->ipbmap->i_mapping);
 		filemap_fdatawrite(sbi->ipimap->i_mapping);
 		filemap_fdatawrite(sbi->direct_inode->i_mapping);
 	}
 	/*
 	 * If there was recent activity, we may need to wait
 	 * for the lazycommit thread to catch up
 	 */
 	if ((!list_empty(&log->cqueue)) || !list_empty(&log->synclist)) {
 		for (i = 0; i < 200; i++) {	/* Too much? */
 			msleep(250);
 			if (list_empty(&log->cqueue) &&
 			    list_empty(&log->synclist))
 				break;
 		}
 	}
 	assert(list_empty(&log->cqueue));
 #ifdef CONFIG_JFS_DEBUG
 	if (!list_empty(&log->synclist)) {
 		struct logsyncblk *lp;
 		list_for_each_entry(lp, &log->synclist, synclist) {
 			if (lp->xflag & COMMIT_PAGE) {
 				struct metapage *mp = (struct metapage *)lp;
 				dump_mem("orphan metapage", lp,
 					 sizeof(struct metapage));
 				dump_mem("page", mp->page, sizeof(struct page));
 			}
 			else
 				dump_mem("orphan tblock", lp,
 					 sizeof(struct tblock));
 		}
 	}
 #endif
 	//assert(list_empty(&log->synclist));
 	clear_bit(log_FLUSH, &log->flag);
 }
 /*
  * NAME:	lmLogShutdown()
  *
  * FUNCTION:	log shutdown at last LogClose().
  *
  *		write log syncpt record.
  *		update super block to set redone flag to 0.
  *
  * PARAMETER:	log	- log inode
  *
  * RETURN:	0	- success
  *
  * serialization: single last close thread
  */
 int lmLogShutdown(struct jfs_log * log)
 {
 	int rc;
 	struct lrd lrd;
 	int lsn;
 	struct logsuper *logsuper;
 	struct lbuf *bpsuper;
 	struct lbuf *bp;
 	struct logpage *lp;
 	jfs_info("lmLogShutdown: log:0x%p", log);
 	jfs_flush_journal(log, 2);
 	/*
 	 * write the last SYNCPT record with syncpoint = 0
 	 * (i.e., log redo up to HERE !)
 	 */
 	lrd.logtid = 0;
 	lrd.backchain = 0;
 	lrd.type = cpu_to_le16(LOG_SYNCPT);
 	lrd.length = 0;
 	lrd.log.syncpt.sync = 0;
 	lsn = lmWriteRecord(log, NULL, &lrd, NULL);
 	bp = log->bp;
 	lp = (struct logpage *) bp->l_ldata;
 	lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
 	lbmWrite(log, log->bp, lbmWRITE | lbmRELEASE | lbmSYNC, 0);
 	lbmIOWait(log->bp, lbmFREE);
 	log->bp = NULL;
 	/*
 	 * synchronous update log superblock
 	 * mark log state as shutdown cleanly
 	 * (i.e., Log does not need to be replayed).
 	 */
 	if ((rc = lbmRead(log, 1, &bpsuper)))
 		goto out;
 	logsuper = (struct logsuper *) bpsuper->l_ldata;
 	logsuper->state = cpu_to_le32(LOGREDONE);
 	logsuper->end = cpu_to_le32(lsn);
 	lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
 	rc = lbmIOWait(bpsuper, lbmFREE);
 	jfs_info("lmLogShutdown: lsn:0x%x page:%d eor:%d",
 		 lsn, log->page, log->eor);
       out:
 	/*
 	 * shutdown per log i/o
 	 */
 	lbmLogShutdown(log);
 	if (rc) {
 		jfs_warn("lmLogShutdown: exit(%d)", rc);
 	}
 	return rc;
 }
 /*
  * NAME:	lmLogFileSystem()
  *
  * FUNCTION:	insert (<activate> = true)/remove (<activate> = false)
  *	file system into/from log active file system list.
  *
  * PARAMETE:	log	- pointer to logs inode.
  *		fsdev	- kdev_t of filesystem.
  *		serial  - pointer to returned log serial number
  *		activate - insert/remove device from active list.
  *
  * RETURN:	0	- success
  *		errors returned by vms_iowait().
  */
 static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
 			   int activate)
 {
 	int rc = 0;
 	int i;
 	struct logsuper *logsuper;
 	struct lbuf *bpsuper;
 	char *uuid = sbi->uuid;
 	/*
 	 * insert/remove file system device to log active file system list.
 	 */
 	if ((rc = lbmRead(log, 1, &bpsuper)))
 		return rc;
 	logsuper = (struct logsuper *) bpsuper->l_ldata;
 	if (activate) {
 		for (i = 0; i < MAX_ACTIVE; i++)
 			if (!memcmp(logsuper->active[i].uuid, NULL_UUID, 16)) {
 				memcpy(logsuper->active[i].uuid, uuid, 16);
 				sbi->aggregate = i;
 				break;
 			}
 		if (i == MAX_ACTIVE) {
 			jfs_warn("Too many file systems sharing journal!");
 			lbmFree(bpsuper);
 			return -EMFILE;	/* Is there a better rc? */
 		}
 	} else {
 		for (i = 0; i < MAX_ACTIVE; i++)
 			if (!memcmp(logsuper->active[i].uuid, uuid, 16)) {
 				memcpy(logsuper->active[i].uuid, NULL_UUID, 16);
 				break;
 			}
 		if (i == MAX_ACTIVE) {
 			jfs_warn("Somebody stomped on the journal!");
 			lbmFree(bpsuper);
 			return -EIO;
 		}
 	}
 	/*
 	 * synchronous write log superblock:
 	 *
 	 * write sidestream bypassing write queue:
 	 * at file system mount, log super block is updated for
 	 * activation of the file system before any log record
 	 * (MOUNT record) of the file system, and at file system
 	 * unmount, all meta data for the file system has been
 	 * flushed before log super block is updated for deactivation
 	 * of the file system.
 	 */
 	lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
 	rc = lbmIOWait(bpsuper, lbmFREE);
 	return rc;
 }
 /*
  *		log buffer manager (lbm)
  *		------------------------
  *
  * special purpose buffer manager supporting log i/o requirements.
  *
  * per log write queue:
  * log pageout occurs in serial order by fifo write queue and
  * restricting to a single i/o in pregress at any one time.
  * a circular singly-linked list
  * (log->wrqueue points to the tail, and buffers are linked via
  * bp->wrqueue field), and
  * maintains log page in pageout ot waiting for pageout in serial pageout.
  */
 /*
  *	lbmLogInit()
  *
  * initialize per log I/O setup at lmLogInit()
  */
 static int lbmLogInit(struct jfs_log * log)
 {				/* log inode */
 	int i;
 	struct lbuf *lbuf;
 	jfs_info("lbmLogInit: log:0x%p", log);
 	/* initialize current buffer cursor */
 	log->bp = NULL;
 	/* initialize log device write queue */
 	log->wqueue = NULL;
 	/*
 	 * Each log has its own buffer pages allocated to it.  These are
 	 * not managed by the page cache.  This ensures that a transaction
 	 * writing to the log does not block trying to allocate a page from
 	 * the page cache (for the log).  This would be bad, since page
 	 * allocation waits on the kswapd thread that may be committing inodes
 	 * which would cause log activity.  Was that clear?  I'm trying to
 	 * avoid deadlock here.
 	 */
 	init_waitqueue_head(&log->free_wait);
 	log->lbuf_free = NULL;
 	for (i = 0; i < LOGPAGES;) {
 		char *buffer;
 		uint offset;
 		struct page *page;
 		buffer = (char *) get_zeroed_page(GFP_KERNEL);
 		if (buffer == NULL)
 			goto error;
 		page = virt_to_page(buffer);
 		for (offset = 0; offset < PAGE_SIZE; offset += LOGPSIZE) {
 			lbuf = kmalloc(sizeof(struct lbuf), GFP_KERNEL);
 			if (lbuf == NULL) {
 				if (offset == 0)
 					free_page((unsigned long) buffer);
 				goto error;
 			}
 			if (offset) /* we already have one reference */
 				get_page(page);
 			lbuf->l_offset = offset;
 			lbuf->l_ldata = buffer + offset;
 			lbuf->l_page = page;
 			lbuf->l_log = log;
 			init_waitqueue_head(&lbuf->l_ioevent);
 			lbuf->l_freelist = log->lbuf_free;
 			log->lbuf_free = lbuf;
 			i++;
 		}
 	}
 	return (0);
       error:
 	lbmLogShutdown(log);
 	return -ENOMEM;
 }
 /*
  *	lbmLogShutdown()
  *
  * finalize per log I/O setup at lmLogShutdown()
  */
 static void lbmLogShutdown(struct jfs_log * log)
 {
 	struct lbuf *lbuf;
 	jfs_info("lbmLogShutdown: log:0x%p", log);
 	lbuf = log->lbuf_free;
 	while (lbuf) {
 		struct lbuf *next = lbuf->l_freelist;
 		__free_page(lbuf->l_page);
 		kfree(lbuf);
 		lbuf = next;
 	}
 }
 /*
  *	lbmAllocate()
  *
  * allocate an empty log buffer
  */
 static struct lbuf *lbmAllocate(struct jfs_log * log, int pn)
 {
 	struct lbuf *bp;
 	unsigned long flags;
 	/*
 	 * recycle from log buffer freelist if any
 	 */
 	LCACHE_LOCK(flags);
 	LCACHE_SLEEP_COND(log->free_wait, (bp = log->lbuf_free), flags);
 	log->lbuf_free = bp->l_freelist;
 	LCACHE_UNLOCK(flags);
 	bp->l_flag = 0;
 	bp->l_wqnext = NULL;
 	bp->l_freelist = NULL;
 	bp->l_pn = pn;
 	bp->l_blkno = log->base + (pn << (L2LOGPSIZE - log->l2bsize));
 	bp->l_ceor = 0;
 	return bp;
 }
 /*
  *	lbmFree()
  *
  * release a log buffer to freelist
  */
 static void lbmFree(struct lbuf * bp)
 {
 	unsigned long flags;
 	LCACHE_LOCK(flags);
 	lbmfree(bp);
 	LCACHE_UNLOCK(flags);
 }
 static void lbmfree(struct lbuf * bp)
 {
 	struct jfs_log *log = bp->l_log;
 	assert(bp->l_wqnext == NULL);
 	/*
 	 * return the buffer to head of freelist
 	 */
 	bp->l_freelist = log->lbuf_free;
 	log->lbuf_free = bp;
 	wake_up(&log->free_wait);
 	return;
 }
 /*
  * NAME:	lbmRedrive
  *
  * FUNCTION:	add a log buffer to the the log redrive list
  *
  * PARAMETER:
  *     bp	- log buffer
  *
  * NOTES:
  *	Takes log_redrive_lock.
  */
 static inline void lbmRedrive(struct lbuf *bp)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&log_redrive_lock, flags);
 	bp->l_redrive_next = log_redrive_list;
 	log_redrive_list = bp;
 	spin_unlock_irqrestore(&log_redrive_lock, flags);
 	wake_up(&jfs_IO_thread_wait);
 }
 /*
  *	lbmRead()
  */
 static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp)
 {
 	struct bio *bio;
 	struct lbuf *bp;
 	/*
 	 * allocate a log buffer
 	 */
 	*bpp = bp = lbmAllocate(log, pn);
 	jfs_info("lbmRead: bp:0x%p pn:0x%x", bp, pn);
 	bp->l_flag |= lbmREAD;
 	bio = bio_alloc(GFP_NOFS, 1);
 	bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
 	bio->bi_bdev = log->bdev;
 	bio->bi_io_vec[0].bv_page = bp->l_page;
 	bio->bi_io_vec[0].bv_len = LOGPSIZE;
 	bio->bi_io_vec[0].bv_offset = bp->l_offset;
 	bio->bi_vcnt = 1;
 	bio->bi_idx = 0;
 	bio->bi_size = LOGPSIZE;
 	bio->bi_end_io = lbmIODone;
 	bio->bi_private = bp;
 	submit_bio(READ_SYNC, bio);
 	wait_event(bp->l_ioevent, (bp->l_flag != lbmREAD));
 	return 0;
 }
 /*
  *	lbmWrite()
  *
  * buffer at head of pageout queue stays after completion of
  * partial-page pageout and redriven by explicit initiation of
  * pageout by caller until full-page pageout is completed and
  * released.
  *
  * device driver i/o done redrives pageout of new buffer at
  * head of pageout queue when current buffer at head of pageout
  * queue is released at the completion of its full-page pageout.
  *
  * LOGGC_LOCK() serializes lbmWrite() by lmNextPage() and lmGroupCommit().
  * LCACHE_LOCK() serializes xflag between lbmWrite() and lbmIODone()
  */
 static void lbmWrite(struct jfs_log * log, struct lbuf * bp, int flag,
 		     int cant_block)
 {
 	struct lbuf *tail;
 	unsigned long flags;
 	jfs_info("lbmWrite: bp:0x%p flag:0x%x pn:0x%x", bp, flag, bp->l_pn);
 	/* map the logical block address to physical block address */
 	bp->l_blkno =
 	    log->base + (bp->l_pn << (L2LOGPSIZE - log->l2bsize));
 	LCACHE_LOCK(flags);		/* disable+lock */
 	/*
 	 * initialize buffer for device driver
 	 */
 	bp->l_flag = flag;
 	/*
 	 *      insert bp at tail of write queue associated with log
 	 *
 	 * (request is either for bp already/currently at head of queue
 	 * or new bp to be inserted at tail)
 	 */
 	tail = log->wqueue;
 	/* is buffer not already on write queue ? */
 	if (bp->l_wqnext == NULL) {
 		/* insert at tail of wqueue */
 		if (tail == NULL) {
 			log->wqueue = bp;
 			bp->l_wqnext = bp;
 		} else {
 			log->wqueue = bp;
 			bp->l_wqnext = tail->l_wqnext;
 			tail->l_wqnext = bp;
 		}
 		tail = bp;
 	}
 	/* is buffer at head of wqueue and for write ? */
 	if ((bp != tail->l_wqnext) || !(flag & lbmWRITE)) {
 		LCACHE_UNLOCK(flags);	/* unlock+enable */
 		return;
 	}
 	LCACHE_UNLOCK(flags);	/* unlock+enable */
 	if (cant_block)
 		lbmRedrive(bp);
 	else if (flag & lbmSYNC)
 		lbmStartIO(bp);
 	else {
 		LOGGC_UNLOCK(log);
 		lbmStartIO(bp);
 		LOGGC_LOCK(log);
 	}
 }
 /*
  *	lbmDirectWrite()
  *
  * initiate pageout bypassing write queue for sidestream
  * (e.g., log superblock) write;
  */
 static void lbmDirectWrite(struct jfs_log * log, struct lbuf * bp, int flag)
 {
 	jfs_info("lbmDirectWrite: bp:0x%p flag:0x%x pn:0x%x",
 		 bp, flag, bp->l_pn);
 	/*
 	 * initialize buffer for device driver
 	 */
 	bp->l_flag = flag | lbmDIRECT;
 	/* map the logical block address to physical block address */
 	bp->l_blkno =
 	    log->base + (bp->l_pn << (L2LOGPSIZE - log->l2bsize));
 	/*
 	 *      initiate pageout of the page
 	 */
 	lbmStartIO(bp);
 }
 /*
  * NAME:	lbmStartIO()
  *
  * FUNCTION:	Interface to DD strategy routine
  *
  * RETURN:      none
  *
  * serialization: LCACHE_LOCK() is NOT held during log i/o;
  */
 static void lbmStartIO(struct lbuf * bp)
 {
 	struct bio *bio;
 	struct jfs_log *log = bp->l_log;
 	jfs_info("lbmStartIO\n");
 	bio = bio_alloc(GFP_NOFS, 1);
 	bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
 	bio->bi_bdev = log->bdev;
 	bio->bi_io_vec[0].bv_page = bp->l_page;
 	bio->bi_io_vec[0].bv_len = LOGPSIZE;
 	bio->bi_io_vec[0].bv_offset = bp->l_offset;
 	bio->bi_vcnt = 1;
 	bio->bi_idx = 0;
 	bio->bi_size = LOGPSIZE;
 	bio->bi_end_io = lbmIODone;
 	bio->bi_private = bp;
 	/* check if journaling to disk has been disabled */
 	if (log->no_integrity) {
 		bio->bi_size = 0;
 		lbmIODone(bio, 0, 0);
 	} else {
 		submit_bio(WRITE_SYNC, bio);
 		INCREMENT(lmStat.submitted);
 	}
 }
 /*
  *	lbmIOWait()
  */
 static int lbmIOWait(struct lbuf * bp, int flag)
 {
 	unsigned long flags;
 	int rc = 0;
 	jfs_info("lbmIOWait1: bp:0x%p flag:0x%x:0x%x", bp, bp->l_flag, flag);
 	LCACHE_LOCK(flags);		/* disable+lock */
 	LCACHE_SLEEP_COND(bp->l_ioevent, (bp->l_flag & lbmDONE), flags);
 	rc = (bp->l_flag & lbmERROR) ? -EIO : 0;
 	if (flag & lbmFREE)
 		lbmfree(bp);
 	LCACHE_UNLOCK(flags);	/* unlock+enable */
 	jfs_info("lbmIOWait2: bp:0x%p flag:0x%x:0x%x", bp, bp->l_flag, flag);
 	return rc;
 }
 /*
  *	lbmIODone()
  *
  * executed at INTIODONE level
  */
 static int lbmIODone(struct bio *bio, unsigned int bytes_done, int error)
 {
 	struct lbuf *bp = bio->bi_private;
 	struct lbuf *nextbp, *tail;
 	struct jfs_log *log;
 	unsigned long flags;
 	if (bio->bi_size)
 		return 1;
 	/*
 	 * get back jfs buffer bound to the i/o buffer
 	 */
 	jfs_info("lbmIODone: bp:0x%p flag:0x%x", bp, bp->l_flag);
 	LCACHE_LOCK(flags);		/* disable+lock */
 	bp->l_flag |= lbmDONE;
 	if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
 		bp->l_flag |= lbmERROR;
 		jfs_err("lbmIODone: I/O error in JFS log");
 	}
 	bio_put(bio);
 	/*
 	 *      pagein completion
 	 */
 	if (bp->l_flag & lbmREAD) {
 		bp->l_flag &= ~lbmREAD;
 		LCACHE_UNLOCK(flags);	/* unlock+enable */
 		/* wakeup I/O initiator */
 		LCACHE_WAKEUP(&bp->l_ioevent);
 		return 0;
 	}
 	/*
 	 *      pageout completion
 	 *
 	 * the bp at the head of write queue has completed pageout.
 	 *
 	 * if single-commit/full-page pageout, remove the current buffer
 	 * from head of pageout queue, and redrive pageout with
 	 * the new buffer at head of pageout queue;
 	 * otherwise, the partial-page pageout buffer stays at
 	 * the head of pageout queue to be redriven for pageout
 	 * by lmGroupCommit() until full-page pageout is completed.
 	 */
 	bp->l_flag &= ~lbmWRITE;
 	INCREMENT(lmStat.pagedone);
 	/* update committed lsn */
 	log = bp->l_log;
 	log->clsn = (bp->l_pn << L2LOGPSIZE) + bp->l_ceor;
 	if (bp->l_flag & lbmDIRECT) {
 		LCACHE_WAKEUP(&bp->l_ioevent);
 		LCACHE_UNLOCK(flags);
 		return 0;
 	}
 	tail = log->wqueue;
 	/* single element queue */
 	if (bp == tail) {
 		/* remove head buffer of full-page pageout
 		 * from log device write queue
 		 */
 		if (bp->l_flag & lbmRELEASE) {
 			log->wqueue = NULL;
 			bp->l_wqnext = NULL;
 		}
 	}
 	/* multi element queue */
 	else {
 		/* remove head buffer of full-page pageout
 		 * from log device write queue
 		 */
 		if (bp->l_flag & lbmRELEASE) {
 			nextbp = tail->l_wqnext = bp->l_wqnext;
 			bp->l_wqnext = NULL;
 			/*
 			 * redrive pageout of next page at head of write queue:
 			 * redrive next page without any bound tblk
 			 * (i.e., page w/o any COMMIT records), or
 			 * first page of new group commit which has been
 			 * queued after current page (subsequent pageout
 			 * is performed synchronously, except page without
 			 * any COMMITs) by lmGroupCommit() as indicated
 			 * by lbmWRITE flag;
 			 */
 			if (nextbp->l_flag & lbmWRITE) {
 				/*
 				 * We can't do the I/O at interrupt time.
 				 * The jfsIO thread can do it
 				 */
 				lbmRedrive(nextbp);
 			}
 		}
 	}
 	/*
 	 *      synchronous pageout:
 	 *
 	 * buffer has not necessarily been removed from write queue
 	 * (e.g., synchronous write of partial-page with COMMIT):
 	 * leave buffer for i/o initiator to dispose
 	 */
 	if (bp->l_flag & lbmSYNC) {
 		LCACHE_UNLOCK(flags);	/* unlock+enable */
 		/* wakeup I/O initiator */
 		LCACHE_WAKEUP(&bp->l_ioevent);
 	}
 	/*
 	 *      Group Commit pageout:
 	 */
 	else if (bp->l_flag & lbmGC) {
 		LCACHE_UNLOCK(flags);
 		lmPostGC(bp);
 	}
 	/*
 	 *      asynchronous pageout:
 	 *
 	 * buffer must have been removed from write queue:
 	 * insert buffer at head of freelist where it can be recycled
 	 */
 	else {
 		assert(bp->l_flag & lbmRELEASE);
 		assert(bp->l_flag & lbmFREE);
 		lbmfree(bp);
 		LCACHE_UNLOCK(flags);	/* unlock+enable */
 	}
 	return 0;
 }
 int jfsIOWait(void *arg)
 {
 	struct lbuf *bp;
 	daemonize("jfsIO");
 	complete(&jfsIOwait);
 	do {
 		DECLARE_WAITQUEUE(wq, current);
 		spin_lock_irq(&log_redrive_lock);
 		while ((bp = log_redrive_list) != 0) {
 			log_redrive_list = bp->l_redrive_next;
 			bp->l_redrive_next = NULL;
 			spin_unlock_irq(&log_redrive_lock);
 			lbmStartIO(bp);
 			spin_lock_irq(&log_redrive_lock);
 		}
 		if (freezing(current)) {
 			spin_unlock_irq(&log_redrive_lock);
 			refrigerator();
 		} else {
 			add_wait_queue(&jfs_IO_thread_wait, &wq);
 			set_current_state(TASK_INTERRUPTIBLE);
 			spin_unlock_irq(&log_redrive_lock);
 			schedule();
 			current->state = TASK_RUNNING;
 			remove_wait_queue(&jfs_IO_thread_wait, &wq);
 		}
 	} while (!jfs_stop_threads);
 	jfs_info("jfsIOWait being killed!");
 	complete_and_exit(&jfsIOwait, 0);
 }
 /*
  * NAME:	lmLogFormat()/jfs_logform()
  *
  * FUNCTION:	format file system log
  *
  * PARAMETERS:
  *      log	- volume log
  *	logAddress - start address of log space in FS block
  *	logSize	- length of log space in FS block;
  *
  * RETURN:	0	- success
  *		-EIO	- i/o error
  *
  * XXX: We're synchronously writing one page at a time.  This needs to
  *	be improved by writing multiple pages at once.
  */
 int lmLogFormat(struct jfs_log *log, s64 logAddress, int logSize)
 {
 	int rc = -EIO;
 	struct jfs_sb_info *sbi;
 	struct logsuper *logsuper;
 	struct logpage *lp;
 	int lspn;		/* log sequence page number */
 	struct lrd *lrd_ptr;
 	int npages = 0;
 	struct lbuf *bp;
 	jfs_info("lmLogFormat: logAddress:%Ld logSize:%d",
 		 (long long)logAddress, logSize);
 	sbi = list_entry(log->sb_list.next, struct jfs_sb_info, log_list);
 	/* allocate a log buffer */
 	bp = lbmAllocate(log, 1);
 	npages = logSize >> sbi->l2nbperpage;
 	/*
 	 *      log space:
 	 *
 	 * page 0 - reserved;
 	 * page 1 - log superblock;
 	 * page 2 - log data page: A SYNC log record is written
 	 *          into this page at logform time;
 	 * pages 3-N - log data page: set to empty log data pages;
 	 */
 	/*
 	 *      init log superblock: log page 1
 	 */
 	logsuper = (struct logsuper *) bp->l_ldata;
 	logsuper->magic = cpu_to_le32(LOGMAGIC);
 	logsuper->version = cpu_to_le32(LOGVERSION);
 	logsuper->state = cpu_to_le32(LOGREDONE);
 	logsuper->flag = cpu_to_le32(sbi->mntflag);	/* ? */
 	logsuper->size = cpu_to_le32(npages);
 	logsuper->bsize = cpu_to_le32(sbi->bsize);
 	logsuper->l2bsize = cpu_to_le32(sbi->l2bsize);
 	logsuper->end = cpu_to_le32(2 * LOGPSIZE + LOGPHDRSIZE + LOGRDSIZE);
 	bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
 	bp->l_blkno = logAddress + sbi->nbperpage;
 	lbmStartIO(bp);
 	if ((rc = lbmIOWait(bp, 0)))
 		goto exit;
 	/*
 	 *      init pages 2 to npages-1 as log data pages:
 	 *
 	 * log page sequence number (lpsn) initialization:
 	 *
 	 * pn:   0     1     2     3                 n-1
 	 *       +-----+-----+=====+=====+===.....===+=====+
 	 * lspn:             N-1   0     1           N-2
 	 *                   <--- N page circular file ---->
 	 *
 	 * the N (= npages-2) data pages of the log is maintained as
 	 * a circular file for the log records;
 	 * lpsn grows by 1 monotonically as each log page is written
 	 * to the circular file of the log;
 	 * and setLogpage() will not reset the page number even if
 	 * the eor is equal to LOGPHDRSIZE. In order for binary search
 	 * still work in find log end process, we have to simulate the
 	 * log wrap situation at the log format time.
 	 * The 1st log page written will have the highest lpsn. Then
 	 * the succeeding log pages will have ascending order of
 	 * the lspn starting from 0, ... (N-2)
 	 */
 	lp = (struct logpage *) bp->l_ldata;
 	/*
 	 * initialize 1st log page to be written: lpsn = N - 1,
 	 * write a SYNCPT log record is written to this page
 	 */
 	lp->h.page = lp->t.page = cpu_to_le32(npages - 3);
 	lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE + LOGRDSIZE);
 	lrd_ptr = (struct lrd *) &lp->data;
 	lrd_ptr->logtid = 0;
 	lrd_ptr->backchain = 0;
 	lrd_ptr->type = cpu_to_le16(LOG_SYNCPT);
 	lrd_ptr->length = 0;
 	lrd_ptr->log.syncpt.sync = 0;
 	bp->l_blkno += sbi->nbperpage;
 	bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
 	lbmStartIO(bp);
 	if ((rc = lbmIOWait(bp, 0)))
 		goto exit;
 	/*
 	 *      initialize succeeding log pages: lpsn = 0, 1, ..., (N-2)
 	 */
 	for (lspn = 0; lspn < npages - 3; lspn++) {
 		lp->h.page = lp->t.page = cpu_to_le32(lspn);
 		lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE);
 		bp->l_blkno += sbi->nbperpage;
 		bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
 		lbmStartIO(bp);
 		if ((rc = lbmIOWait(bp, 0)))
 			goto exit;
 	}
 	rc = 0;
 exit:
 	/*
 	 *      finalize log
 	 */
 	/* release the buffer */
 	lbmFree(bp);
 	return rc;
 }
 #ifdef CONFIG_JFS_STATISTICS
 int jfs_lmstats_read(char *buffer, char **start, off_t offset, int length,
 		      int *eof, void *data)
 {
 	int len = 0;
 	off_t begin;
 	len += sprintf(buffer,
 		       "JFS Logmgr stats\n"
 		       "================\n"
 		       "commits = %d\n"
 		       "writes submitted = %d\n"
 		       "writes completed = %d\n"
 		       "full pages submitted = %d\n"
 		       "partial pages submitted = %d\n",
 		       lmStat.commit,
 		       lmStat.submitted,
 		       lmStat.pagedone,
 		       lmStat.full_page,
 		       lmStat.partial_page);
 	begin = offset;
 	*start = buffer + begin;
 	len -= begin;
 	if (len > length)
 		len = length;
 	else
 		*eof = 1;
 	if (len < 0)

fs/jfs/jfs_logmgr.h

Diff comments View file @ cbc3d65

fs/jfs/jfs_txnmgr.c

Diff comments View file @ cbc3d65

 /*
  *   Copyright (C) International Business Machines Corp., 2000-2005
  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  *   the GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 /*
  *      jfs_txnmgr.c: transaction manager
  *
  * notes:
  * transaction starts with txBegin() and ends with txCommit()
  * or txAbort().
  *
  * tlock is acquired at the time of update;
  * (obviate scan at commit time for xtree and dtree)
  * tlock and mp points to each other;
  * (no hashlist for mp -> tlock).
  *
  * special cases:
  * tlock on in-memory inode:
  * in-place tlock in the in-memory inode itself;
  * converted to page lock by iWrite() at commit time.
  *
  * tlock during write()/mmap() under anonymous transaction (tid = 0):
  * transferred (?) to transaction at commit time.
  *
  * use the page itself to update allocation maps
  * (obviate intermediate replication of allocation/deallocation data)
  * hold on to mp+lock thru update of maps
  */
 #include <linux/fs.h>
 #include <linux/vmalloc.h>
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/suspend.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include "jfs_incore.h"
 #include "jfs_inode.h"
 #include "jfs_filsys.h"
 #include "jfs_metapage.h"
 #include "jfs_dinode.h"
 #include "jfs_imap.h"
 #include "jfs_dmap.h"
 #include "jfs_superblock.h"
 #include "jfs_debug.h"
 /*
  *      transaction management structures
  */
 static struct {
 	int freetid;		/* index of a free tid structure */
 	int freelock;		/* index first free lock word */
 	wait_queue_head_t freewait;	/* eventlist of free tblock */
 	wait_queue_head_t freelockwait;	/* eventlist of free tlock */
 	wait_queue_head_t lowlockwait;	/* eventlist of ample tlocks */
 	int tlocksInUse;	/* Number of tlocks in use */
 	spinlock_t LazyLock;	/* synchronize sync_queue & unlock_queue */
 /*	struct tblock *sync_queue; * Transactions waiting for data sync */
 	struct list_head unlock_queue;	/* Txns waiting to be released */
 	struct list_head anon_list;	/* inodes having anonymous txns */
 	struct list_head anon_list2;	/* inodes having anonymous txns
 					   that couldn't be sync'ed */
 } TxAnchor;
 int jfs_tlocks_low;		/* Indicates low number of available tlocks */
 #ifdef CONFIG_JFS_STATISTICS
 static struct {
 	uint txBegin;
 	uint txBegin_barrier;
 	uint txBegin_lockslow;
 	uint txBegin_freetid;
 	uint txBeginAnon;
 	uint txBeginAnon_barrier;
 	uint txBeginAnon_lockslow;
 	uint txLockAlloc;
 	uint txLockAlloc_freelock;
 } TxStat;
 #endif
 static int nTxBlock = -1;	/* number of transaction blocks */
 module_param(nTxBlock, int, 0);
 MODULE_PARM_DESC(nTxBlock,
 		 "Number of transaction blocks (max:65536)");
 static int nTxLock = -1;	/* number of transaction locks */
 module_param(nTxLock, int, 0);
 MODULE_PARM_DESC(nTxLock,
 		 "Number of transaction locks (max:65536)");
 struct tblock *TxBlock;	        /* transaction block table */
 static int TxLockLWM;		/* Low water mark for number of txLocks used */
 static int TxLockHWM;		/* High water mark for number of txLocks used */
 static int TxLockVHWM;		/* Very High water mark */
 struct tlock *TxLock;           /* transaction lock table */
 /*
  *      transaction management lock
  */
 static DEFINE_SPINLOCK(jfsTxnLock);
 #define TXN_LOCK()              spin_lock(&jfsTxnLock)
 #define TXN_UNLOCK()            spin_unlock(&jfsTxnLock)
 #define LAZY_LOCK_INIT()	spin_lock_init(&TxAnchor.LazyLock);
 #define LAZY_LOCK(flags)	spin_lock_irqsave(&TxAnchor.LazyLock, flags)
 #define LAZY_UNLOCK(flags) spin_unlock_irqrestore(&TxAnchor.LazyLock, flags)
 DECLARE_WAIT_QUEUE_HEAD(jfs_sync_thread_wait);
 DECLARE_WAIT_QUEUE_HEAD(jfs_commit_thread_wait);
 static int jfs_commit_thread_waking;
 /*
  * Retry logic exist outside these macros to protect from spurrious wakeups.
  */
 static inline void TXN_SLEEP_DROP_LOCK(wait_queue_head_t * event)
 {
 	DECLARE_WAITQUEUE(wait, current);
 	add_wait_queue(event, &wait);
 	set_current_state(TASK_UNINTERRUPTIBLE);
 	TXN_UNLOCK();
 	schedule();
 	current->state = TASK_RUNNING;
 	remove_wait_queue(event, &wait);
 }
 #define TXN_SLEEP(event)\
 {\
 	TXN_SLEEP_DROP_LOCK(event);\
 	TXN_LOCK();\
 }
 #define TXN_WAKEUP(event) wake_up_all(event)
 /*
  *      statistics
  */
 static struct {
 	tid_t maxtid;		/* 4: biggest tid ever used */
 	lid_t maxlid;		/* 4: biggest lid ever used */
 	int ntid;		/* 4: # of transactions performed */
 	int nlid;		/* 4: # of tlocks acquired */
 	int waitlock;		/* 4: # of tlock wait */
 } stattx;
 /*
  * forward references
  */
 static int diLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 		struct tlock * tlck, struct commit * cd);
 static int dataLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 		struct tlock * tlck);
 static void dtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 		struct tlock * tlck);
 static void mapLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 		struct tlock * tlck);
 static void txAllocPMap(struct inode *ip, struct maplock * maplock,
 		struct tblock * tblk);
 static void txForce(struct tblock * tblk);
 static int txLog(struct jfs_log * log, struct tblock * tblk,
 		struct commit * cd);
 static void txUpdateMap(struct tblock * tblk);
 static void txRelease(struct tblock * tblk);
 static void xtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	   struct tlock * tlck);
 static void LogSyncRelease(struct metapage * mp);
 /*
  *              transaction block/lock management
  *              ---------------------------------
  */
 /*
  * Get a transaction lock from the free list.  If the number in use is
  * greater than the high water mark, wake up the sync daemon.  This should
  * free some anonymous transaction locks.  (TXN_LOCK must be held.)
  */
 static lid_t txLockAlloc(void)
 {
 	lid_t lid;
 	INCREMENT(TxStat.txLockAlloc);
 	if (!TxAnchor.freelock) {
 		INCREMENT(TxStat.txLockAlloc_freelock);
 	}
 	while (!(lid = TxAnchor.freelock))
 		TXN_SLEEP(&TxAnchor.freelockwait);
 	TxAnchor.freelock = TxLock[lid].next;
 	HIGHWATERMARK(stattx.maxlid, lid);
 	if ((++TxAnchor.tlocksInUse > TxLockHWM) && (jfs_tlocks_low == 0)) {
 		jfs_info("txLockAlloc tlocks low");
 		jfs_tlocks_low = 1;
 		wake_up(&jfs_sync_thread_wait);
 	}
 	return lid;
 }
 static void txLockFree(lid_t lid)
 {
 	TxLock[lid].tid = 0;
 	TxLock[lid].next = TxAnchor.freelock;
 	TxAnchor.freelock = lid;
 	TxAnchor.tlocksInUse--;
 	if (jfs_tlocks_low && (TxAnchor.tlocksInUse < TxLockLWM)) {
 		jfs_info("txLockFree jfs_tlocks_low no more");
 		jfs_tlocks_low = 0;
 		TXN_WAKEUP(&TxAnchor.lowlockwait);
 	}
 	TXN_WAKEUP(&TxAnchor.freelockwait);
 }
 /*
  * NAME:        txInit()
  *
  * FUNCTION:    initialize transaction management structures
  *
  * RETURN:
  *
  * serialization: single thread at jfs_init()
  */
 int txInit(void)
 {
 	int k, size;
 	struct sysinfo si;
 	/* Set defaults for nTxLock and nTxBlock if unset */
 	if (nTxLock == -1) {
 		if (nTxBlock == -1) {
 			/* Base default on memory size */
 			si_meminfo(&si);
 			if (si.totalram > (256 * 1024)) /* 1 GB */
 				nTxLock = 64 * 1024;
 			else
 				nTxLock = si.totalram >> 2;
 		} else if (nTxBlock > (8 * 1024))
 			nTxLock = 64 * 1024;
 		else
 			nTxLock = nTxBlock << 3;
 	}
 	if (nTxBlock == -1)
 		nTxBlock = nTxLock >> 3;
 	/* Verify tunable parameters */
 	if (nTxBlock < 16)
 		nTxBlock = 16;	/* No one should set it this low */
 	if (nTxBlock > 65536)
 		nTxBlock = 65536;
 	if (nTxLock < 256)
 		nTxLock = 256;	/* No one should set it this low */
 	if (nTxLock > 65536)
 		nTxLock = 65536;
 	printk(KERN_INFO "JFS: nTxBlock = %d, nTxLock = %d\n",
 	       nTxBlock, nTxLock);
 	/*
 	 * initialize transaction block (tblock) table
 	 *
 	 * transaction id (tid) = tblock index
 	 * tid = 0 is reserved.
 	 */
 	TxLockLWM = (nTxLock * 4) / 10;
 	TxLockHWM = (nTxLock * 7) / 10;
 	TxLockVHWM = (nTxLock * 8) / 10;
 	size = sizeof(struct tblock) * nTxBlock;
 	TxBlock = (struct tblock *) vmalloc(size);
 	if (TxBlock == NULL)
 		return -ENOMEM;
 	for (k = 1; k < nTxBlock - 1; k++) {
 		TxBlock[k].next = k + 1;
 		init_waitqueue_head(&TxBlock[k].gcwait);
 		init_waitqueue_head(&TxBlock[k].waitor);
 	}
 	TxBlock[k].next = 0;
 	init_waitqueue_head(&TxBlock[k].gcwait);
 	init_waitqueue_head(&TxBlock[k].waitor);
 	TxAnchor.freetid = 1;
 	init_waitqueue_head(&TxAnchor.freewait);
 	stattx.maxtid = 1;	/* statistics */
 	/*
 	 * initialize transaction lock (tlock) table
 	 *
 	 * transaction lock id = tlock index
 	 * tlock id = 0 is reserved.
 	 */
 	size = sizeof(struct tlock) * nTxLock;
 	TxLock = (struct tlock *) vmalloc(size);
 	if (TxLock == NULL) {
 		vfree(TxBlock);
 		return -ENOMEM;
 	}
 	/* initialize tlock table */
 	for (k = 1; k < nTxLock - 1; k++)
 		TxLock[k].next = k + 1;
 	TxLock[k].next = 0;
 	init_waitqueue_head(&TxAnchor.freelockwait);
 	init_waitqueue_head(&TxAnchor.lowlockwait);
 	TxAnchor.freelock = 1;
 	TxAnchor.tlocksInUse = 0;
 	INIT_LIST_HEAD(&TxAnchor.anon_list);
 	INIT_LIST_HEAD(&TxAnchor.anon_list2);
 	LAZY_LOCK_INIT();
 	INIT_LIST_HEAD(&TxAnchor.unlock_queue);
 	stattx.maxlid = 1;	/* statistics */
 	return 0;
 }
 /*
  * NAME:        txExit()
  *
  * FUNCTION:    clean up when module is unloaded
  */
 void txExit(void)
 {
 	vfree(TxLock);
 	TxLock = NULL;
 	vfree(TxBlock);
 	TxBlock = NULL;
 }
 /*
  * NAME:        txBegin()
  *
  * FUNCTION:    start a transaction.
  *
  * PARAMETER:   sb	- superblock
  *              flag	- force for nested tx;
  *
  * RETURN:	tid	- transaction id
  *
  * note: flag force allows to start tx for nested tx
  * to prevent deadlock on logsync barrier;
  */
 tid_t txBegin(struct super_block *sb, int flag)
 {
 	tid_t t;
 	struct tblock *tblk;
 	struct jfs_log *log;
 	jfs_info("txBegin: flag = 0x%x", flag);
 	log = JFS_SBI(sb)->log;
 	TXN_LOCK();
 	INCREMENT(TxStat.txBegin);
       retry:
 	if (!(flag & COMMIT_FORCE)) {
 		/*
 		 * synchronize with logsync barrier
 		 */
 		if (test_bit(log_SYNCBARRIER, &log->flag) ||
 		    test_bit(log_QUIESCE, &log->flag)) {
 			INCREMENT(TxStat.txBegin_barrier);
 			TXN_SLEEP(&log->syncwait);
 			goto retry;
 		}
 	}
 	if (flag == 0) {
 		/*
 		 * Don't begin transaction if we're getting starved for tlocks
 		 * unless COMMIT_FORCE or COMMIT_INODE (which may ultimately
 		 * free tlocks)
 		 */
 		if (TxAnchor.tlocksInUse > TxLockVHWM) {
 			INCREMENT(TxStat.txBegin_lockslow);
 			TXN_SLEEP(&TxAnchor.lowlockwait);
 			goto retry;
 		}
 	}
 	/*
 	 * allocate transaction id/block
 	 */
 	if ((t = TxAnchor.freetid) == 0) {
 		jfs_info("txBegin: waiting for free tid");
 		INCREMENT(TxStat.txBegin_freetid);
 		TXN_SLEEP(&TxAnchor.freewait);
 		goto retry;
 	}
 	tblk = tid_to_tblock(t);
 	if ((tblk->next == 0) && !(flag & COMMIT_FORCE)) {
 		/* Don't let a non-forced transaction take the last tblk */
 		jfs_info("txBegin: waiting for free tid");
 		INCREMENT(TxStat.txBegin_freetid);
 		TXN_SLEEP(&TxAnchor.freewait);
 		goto retry;
 	}
 	TxAnchor.freetid = tblk->next;
 	/*
 	 * initialize transaction
 	 */
 	/*
 	 * We can't zero the whole thing or we screw up another thread being
 	 * awakened after sleeping on tblk->waitor
 	 *
 	 * memset(tblk, 0, sizeof(struct tblock));
 	 */
 	tblk->next = tblk->last = tblk->xflag = tblk->flag = tblk->lsn = 0;
 	tblk->sb = sb;
 	++log->logtid;
 	tblk->logtid = log->logtid;
 	++log->active;
 	HIGHWATERMARK(stattx.maxtid, t);	/* statistics */
 	INCREMENT(stattx.ntid);	/* statistics */
 	TXN_UNLOCK();
 	jfs_info("txBegin: returning tid = %d", t);
 	return t;
 }
 /*
  * NAME:        txBeginAnon()
  *
  * FUNCTION:    start an anonymous transaction.
  *		Blocks if logsync or available tlocks are low to prevent
  *		anonymous tlocks from depleting supply.
  *
  * PARAMETER:   sb	- superblock
  *
  * RETURN:	none
  */
 void txBeginAnon(struct super_block *sb)
 {
 	struct jfs_log *log;
 	log = JFS_SBI(sb)->log;
 	TXN_LOCK();
 	INCREMENT(TxStat.txBeginAnon);
       retry:
 	/*
 	 * synchronize with logsync barrier
 	 */
 	if (test_bit(log_SYNCBARRIER, &log->flag) ||
 	    test_bit(log_QUIESCE, &log->flag)) {
 		INCREMENT(TxStat.txBeginAnon_barrier);
 		TXN_SLEEP(&log->syncwait);
 		goto retry;
 	}
 	/*
 	 * Don't begin transaction if we're getting starved for tlocks
 	 */
 	if (TxAnchor.tlocksInUse > TxLockVHWM) {
 		INCREMENT(TxStat.txBeginAnon_lockslow);
 		TXN_SLEEP(&TxAnchor.lowlockwait);
 		goto retry;
 	}
 	TXN_UNLOCK();
 }
 /*
  *      txEnd()
  *
  * function: free specified transaction block.
  *
  *      logsync barrier processing:
  *
  * serialization:
  */
 void txEnd(tid_t tid)
 {
 	struct tblock *tblk = tid_to_tblock(tid);
 	struct jfs_log *log;
 	jfs_info("txEnd: tid = %d", tid);
 	TXN_LOCK();
 	/*
 	 * wakeup transactions waiting on the page locked
 	 * by the current transaction
 	 */
 	TXN_WAKEUP(&tblk->waitor);
 	log = JFS_SBI(tblk->sb)->log;
 	/*
 	 * Lazy commit thread can't free this guy until we mark it UNLOCKED,
 	 * otherwise, we would be left with a transaction that may have been
 	 * reused.
 	 *
 	 * Lazy commit thread will turn off tblkGC_LAZY before calling this
 	 * routine.
 	 */
 	if (tblk->flag & tblkGC_LAZY) {
 		jfs_info("txEnd called w/lazy tid: %d, tblk = 0x%p", tid, tblk);
 		TXN_UNLOCK();
 		spin_lock_irq(&log->gclock);	// LOGGC_LOCK
 		tblk->flag |= tblkGC_UNLOCKED;
 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
 		return;
 	}
 	jfs_info("txEnd: tid: %d, tblk = 0x%p", tid, tblk);
 	assert(tblk->next == 0);
 	/*
 	 * insert tblock back on freelist
 	 */
 	tblk->next = TxAnchor.freetid;
 	TxAnchor.freetid = tid;
 	/*
 	 * mark the tblock not active
 	 */
 	if (--log->active == 0) {
 		clear_bit(log_FLUSH, &log->flag);
 		/*
 		 * synchronize with logsync barrier
 		 */
 		if (test_bit(log_SYNCBARRIER, &log->flag)) {
+			TXN_UNLOCK();
+			/* write dirty metadata & forward log syncpt */
+			jfs_syncpt(log, 1);
 			jfs_info("log barrier off: 0x%x", log->lsn);
 			/* enable new transactions start */
 			clear_bit(log_SYNCBARRIER, &log->flag);
 			/* wakeup all waitors for logsync barrier */
 			TXN_WAKEUP(&log->syncwait);
-			TXN_UNLOCK();
-			/* forward log syncpt */
-			jfs_syncpt(log);
 			goto wakeup;
 		}
 	}
 	TXN_UNLOCK();
 wakeup:
 	/*
 	 * wakeup all waitors for a free tblock
 	 */
 	TXN_WAKEUP(&TxAnchor.freewait);
 }
 /*
  *      txLock()
  *
  * function: acquire a transaction lock on the specified <mp>
  *
  * parameter:
  *
  * return:      transaction lock id
  *
  * serialization:
  */
 struct tlock *txLock(tid_t tid, struct inode *ip, struct metapage * mp,
 		     int type)
 {
 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
 	int dir_xtree = 0;
 	lid_t lid;
 	tid_t xtid;
 	struct tlock *tlck;
 	struct xtlock *xtlck;
 	struct linelock *linelock;
 	xtpage_t *p;
 	struct tblock *tblk;
 	TXN_LOCK();
 	if (S_ISDIR(ip->i_mode) && (type & tlckXTREE) &&
 	    !(mp->xflag & COMMIT_PAGE)) {
 		/*
 		 * Directory inode is special.  It can have both an xtree tlock
 		 * and a dtree tlock associated with it.
 		 */
 		dir_xtree = 1;
 		lid = jfs_ip->xtlid;
 	} else
 		lid = mp->lid;
 	/* is page not locked by a transaction ? */
 	if (lid == 0)
 		goto allocateLock;
 	jfs_info("txLock: tid:%d ip:0x%p mp:0x%p lid:%d", tid, ip, mp, lid);
 	/* is page locked by the requester transaction ? */
 	tlck = lid_to_tlock(lid);
 	if ((xtid = tlck->tid) == tid) {
 		TXN_UNLOCK();
 		goto grantLock;
 	}
 	/*
 	 * is page locked by anonymous transaction/lock ?
 	 *
 	 * (page update without transaction (i.e., file write) is
 	 * locked under anonymous transaction tid = 0:
 	 * anonymous tlocks maintained on anonymous tlock list of
 	 * the inode of the page and available to all anonymous
 	 * transactions until txCommit() time at which point
 	 * they are transferred to the transaction tlock list of
 	 * the commiting transaction of the inode)
 	 */
 	if (xtid == 0) {
 		tlck->tid = tid;
 		TXN_UNLOCK();
 		tblk = tid_to_tblock(tid);
 		/*
 		 * The order of the tlocks in the transaction is important
 		 * (during truncate, child xtree pages must be freed before
 		 * parent's tlocks change the working map).
 		 * Take tlock off anonymous list and add to tail of
 		 * transaction list
 		 *
 		 * Note:  We really need to get rid of the tid & lid and
 		 * use list_head's.  This code is getting UGLY!
 		 */
 		if (jfs_ip->atlhead == lid) {
 			if (jfs_ip->atltail == lid) {
 				/* only anonymous txn.
 				 * Remove from anon_list
 				 */
 				list_del_init(&jfs_ip->anon_inode_list);
 			}
 			jfs_ip->atlhead = tlck->next;
 		} else {
 			lid_t last;
 			for (last = jfs_ip->atlhead;
 			     lid_to_tlock(last)->next != lid;
 			     last = lid_to_tlock(last)->next) {
 				assert(last);
 			}
 			lid_to_tlock(last)->next = tlck->next;
 			if (jfs_ip->atltail == lid)
 				jfs_ip->atltail = last;
 		}
 		/* insert the tlock at tail of transaction tlock list */
 		if (tblk->next)
 			lid_to_tlock(tblk->last)->next = lid;
 		else
 			tblk->next = lid;
 		tlck->next = 0;
 		tblk->last = lid;
 		goto grantLock;
 	}
 	goto waitLock;
 	/*
 	 * allocate a tlock
 	 */
       allocateLock:
 	lid = txLockAlloc();
 	tlck = lid_to_tlock(lid);
 	/*
 	 * initialize tlock
 	 */
 	tlck->tid = tid;
 	TXN_UNLOCK();
 	/* mark tlock for meta-data page */
 	if (mp->xflag & COMMIT_PAGE) {
 		tlck->flag = tlckPAGELOCK;
 		/* mark the page dirty and nohomeok */
 		metapage_nohomeok(mp);
 		jfs_info("locking mp = 0x%p, nohomeok = %d tid = %d tlck = 0x%p",
 			 mp, mp->nohomeok, tid, tlck);
 		/* if anonymous transaction, and buffer is on the group
 		 * commit synclist, mark inode to show this.  This will
 		 * prevent the buffer from being marked nohomeok for too
 		 * long a time.
 		 */
 		if ((tid == 0) && mp->lsn)
 			set_cflag(COMMIT_Synclist, ip);
 	}
 	/* mark tlock for in-memory inode */
 	else
 		tlck->flag = tlckINODELOCK;
 	tlck->type = 0;
 	/* bind the tlock and the page */
 	tlck->ip = ip;
 	tlck->mp = mp;
 	if (dir_xtree)
 		jfs_ip->xtlid = lid;
 	else
 		mp->lid = lid;
 	/*
 	 * enqueue transaction lock to transaction/inode
 	 */
 	/* insert the tlock at tail of transaction tlock list */
 	if (tid) {
 		tblk = tid_to_tblock(tid);
 		if (tblk->next)
 			lid_to_tlock(tblk->last)->next = lid;
 		else
 			tblk->next = lid;
 		tlck->next = 0;
 		tblk->last = lid;
 	}
 	/* anonymous transaction:
 	 * insert the tlock at head of inode anonymous tlock list
 	 */
 	else {
 		tlck->next = jfs_ip->atlhead;
 		jfs_ip->atlhead = lid;
 		if (tlck->next == 0) {
 			/* This inode's first anonymous transaction */
 			jfs_ip->atltail = lid;
 			TXN_LOCK();
 			list_add_tail(&jfs_ip->anon_inode_list,
 				      &TxAnchor.anon_list);
 			TXN_UNLOCK();
 		}
 	}
 	/* initialize type dependent area for linelock */
 	linelock = (struct linelock *) & tlck->lock;
 	linelock->next = 0;
 	linelock->flag = tlckLINELOCK;
 	linelock->maxcnt = TLOCKSHORT;
 	linelock->index = 0;
 	switch (type & tlckTYPE) {
 	case tlckDTREE:
 		linelock->l2linesize = L2DTSLOTSIZE;
 		break;
 	case tlckXTREE:
 		linelock->l2linesize = L2XTSLOTSIZE;
 		xtlck = (struct xtlock *) linelock;
 		xtlck->header.offset = 0;
 		xtlck->header.length = 2;
 		if (type & tlckNEW) {
 			xtlck->lwm.offset = XTENTRYSTART;
 		} else {
 			if (mp->xflag & COMMIT_PAGE)
 				p = (xtpage_t *) mp->data;
 			else
 				p = &jfs_ip->i_xtroot;
 			xtlck->lwm.offset =
 			    le16_to_cpu(p->header.nextindex);
 		}
 		xtlck->lwm.length = 0;	/* ! */
 		xtlck->twm.offset = 0;
 		xtlck->hwm.offset = 0;
 		xtlck->index = 2;
 		break;
 	case tlckINODE:
 		linelock->l2linesize = L2INODESLOTSIZE;
 		break;
 	case tlckDATA:
 		linelock->l2linesize = L2DATASLOTSIZE;
 		break;
 	default:
 		jfs_err("UFO tlock:0x%p", tlck);
 	}
 	/*
 	 * update tlock vector
 	 */
       grantLock:
 	tlck->type |= type;
 	return tlck;
 	/*
 	 * page is being locked by another transaction:
 	 */
       waitLock:
 	/* Only locks on ipimap or ipaimap should reach here */
 	/* assert(jfs_ip->fileset == AGGREGATE_I); */
 	if (jfs_ip->fileset != AGGREGATE_I) {
 		jfs_err("txLock: trying to lock locked page!");
 		dump_mem("ip", ip, sizeof(struct inode));
 		dump_mem("mp", mp, sizeof(struct metapage));
 		dump_mem("Locker's tblk", tid_to_tblock(tid),
 			 sizeof(struct tblock));
 		dump_mem("Tlock", tlck, sizeof(struct tlock));
 		BUG();
 	}
 	INCREMENT(stattx.waitlock);	/* statistics */
 	TXN_UNLOCK();
 	release_metapage(mp);
 	TXN_LOCK();
 	xtid = tlck->tid;	/* reaquire after dropping TXN_LOCK */
 	jfs_info("txLock: in waitLock, tid = %d, xtid = %d, lid = %d",
 		 tid, xtid, lid);
 	/* Recheck everything since dropping TXN_LOCK */
 	if (xtid && (tlck->mp == mp) && (mp->lid == lid))
 		TXN_SLEEP_DROP_LOCK(&tid_to_tblock(xtid)->waitor);
 	else
 		TXN_UNLOCK();
 	jfs_info("txLock: awakened     tid = %d, lid = %d", tid, lid);
 	return NULL;
 }
 /*
  * NAME:        txRelease()
  *
  * FUNCTION:    Release buffers associated with transaction locks, but don't
  *		mark homeok yet.  The allows other transactions to modify
  *		buffers, but won't let them go to disk until commit record
  *		actually gets written.
  *
  * PARAMETER:
  *              tblk    -
  *
  * RETURN:      Errors from subroutines.
  */
 static void txRelease(struct tblock * tblk)
 {
 	struct metapage *mp;
 	lid_t lid;
 	struct tlock *tlck;
 	TXN_LOCK();
 	for (lid = tblk->next; lid; lid = tlck->next) {
 		tlck = lid_to_tlock(lid);
 		if ((mp = tlck->mp) != NULL &&
 		    (tlck->type & tlckBTROOT) == 0) {
 			assert(mp->xflag & COMMIT_PAGE);
 			mp->lid = 0;
 		}
 	}
 	/*
 	 * wakeup transactions waiting on a page locked
 	 * by the current transaction
 	 */
 	TXN_WAKEUP(&tblk->waitor);
 	TXN_UNLOCK();
 }
 /*
  * NAME:        txUnlock()
  *
  * FUNCTION:    Initiates pageout of pages modified by tid in journalled
  *              objects and frees their lockwords.
  */
 static void txUnlock(struct tblock * tblk)
 {
 	struct tlock *tlck;
 	struct linelock *linelock;
 	lid_t lid, next, llid, k;
 	struct metapage *mp;
 	struct jfs_log *log;
 	int difft, diffp;
 	unsigned long flags;
 	jfs_info("txUnlock: tblk = 0x%p", tblk);
 	log = JFS_SBI(tblk->sb)->log;
 	/*
 	 * mark page under tlock homeok (its log has been written):
 	 */
 	for (lid = tblk->next; lid; lid = next) {
 		tlck = lid_to_tlock(lid);
 		next = tlck->next;
 		jfs_info("unlocking lid = %d, tlck = 0x%p", lid, tlck);
 		/* unbind page from tlock */
 		if ((mp = tlck->mp) != NULL &&
 		    (tlck->type & tlckBTROOT) == 0) {
 			assert(mp->xflag & COMMIT_PAGE);
 			/* hold buffer
 			 */
 			hold_metapage(mp);
 			assert(mp->nohomeok > 0);
 			_metapage_homeok(mp);
 			/* inherit younger/larger clsn */
 			LOGSYNC_LOCK(log, flags);
 			if (mp->clsn) {
 				logdiff(difft, tblk->clsn, log);
 				logdiff(diffp, mp->clsn, log);
 				if (difft > diffp)
 					mp->clsn = tblk->clsn;
 			} else
 				mp->clsn = tblk->clsn;
 			LOGSYNC_UNLOCK(log, flags);
 			assert(!(tlck->flag & tlckFREEPAGE));
 			put_metapage(mp);
 		}
 		/* insert tlock, and linelock(s) of the tlock if any,
 		 * at head of freelist
 		 */
 		TXN_LOCK();
 		llid = ((struct linelock *) & tlck->lock)->next;
 		while (llid) {
 			linelock = (struct linelock *) lid_to_tlock(llid);
 			k = linelock->next;
 			txLockFree(llid);
 			llid = k;
 		}
 		txLockFree(lid);
 		TXN_UNLOCK();
 	}
 	tblk->next = tblk->last = 0;
 	/*
 	 * remove tblock from logsynclist
 	 * (allocation map pages inherited lsn of tblk and
 	 * has been inserted in logsync list at txUpdateMap())
 	 */
 	if (tblk->lsn) {
 		LOGSYNC_LOCK(log, flags);
 		log->count--;
 		list_del(&tblk->synclist);
 		LOGSYNC_UNLOCK(log, flags);
 	}
 }
 /*
  *      txMaplock()
  *
  * function: allocate a transaction lock for freed page/entry;
  *      for freed page, maplock is used as xtlock/dtlock type;
  */
 struct tlock *txMaplock(tid_t tid, struct inode *ip, int type)
 {
 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
 	lid_t lid;
 	struct tblock *tblk;
 	struct tlock *tlck;
 	struct maplock *maplock;
 	TXN_LOCK();
 	/*
 	 * allocate a tlock
 	 */
 	lid = txLockAlloc();
 	tlck = lid_to_tlock(lid);
 	/*
 	 * initialize tlock
 	 */
 	tlck->tid = tid;
 	/* bind the tlock and the object */
 	tlck->flag = tlckINODELOCK;
 	tlck->ip = ip;
 	tlck->mp = NULL;
 	tlck->type = type;
 	/*
 	 * enqueue transaction lock to transaction/inode
 	 */
 	/* insert the tlock at tail of transaction tlock list */
 	if (tid) {
 		tblk = tid_to_tblock(tid);
 		if (tblk->next)
 			lid_to_tlock(tblk->last)->next = lid;
 		else
 			tblk->next = lid;
 		tlck->next = 0;
 		tblk->last = lid;
 	}
 	/* anonymous transaction:
 	 * insert the tlock at head of inode anonymous tlock list
 	 */
 	else {
 		tlck->next = jfs_ip->atlhead;
 		jfs_ip->atlhead = lid;
 		if (tlck->next == 0) {
 			/* This inode's first anonymous transaction */
 			jfs_ip->atltail = lid;
 			list_add_tail(&jfs_ip->anon_inode_list,
 				      &TxAnchor.anon_list);
 		}
 	}
 	TXN_UNLOCK();
 	/* initialize type dependent area for maplock */
 	maplock = (struct maplock *) & tlck->lock;
 	maplock->next = 0;
 	maplock->maxcnt = 0;
 	maplock->index = 0;
 	return tlck;
 }
 /*
  *      txLinelock()
  *
  * function: allocate a transaction lock for log vector list
  */
 struct linelock *txLinelock(struct linelock * tlock)
 {
 	lid_t lid;
 	struct tlock *tlck;
 	struct linelock *linelock;
 	TXN_LOCK();
 	/* allocate a TxLock structure */
 	lid = txLockAlloc();
 	tlck = lid_to_tlock(lid);
 	TXN_UNLOCK();
 	/* initialize linelock */
 	linelock = (struct linelock *) tlck;
 	linelock->next = 0;
 	linelock->flag = tlckLINELOCK;
 	linelock->maxcnt = TLOCKLONG;
 	linelock->index = 0;
 	/* append linelock after tlock */
 	linelock->next = tlock->next;
 	tlock->next = lid;
 	return linelock;
 }
 /*
  *              transaction commit management
  *              -----------------------------
  */
 /*
  * NAME:        txCommit()
  *
  * FUNCTION:    commit the changes to the objects specified in
  *              clist.  For journalled segments only the
  *              changes of the caller are committed, ie by tid.
  *              for non-journalled segments the data are flushed to
  *              disk and then the change to the disk inode and indirect
  *              blocks committed (so blocks newly allocated to the
  *              segment will be made a part of the segment atomically).
  *
  *              all of the segments specified in clist must be in
  *              one file system. no more than 6 segments are needed
  *              to handle all unix svcs.
  *
  *              if the i_nlink field (i.e. disk inode link count)
  *              is zero, and the type of inode is a regular file or
  *              directory, or symbolic link , the inode is truncated
  *              to zero length. the truncation is committed but the
  *              VM resources are unaffected until it is closed (see
  *              iput and iclose).
  *
  * PARAMETER:
  *
  * RETURN:
  *
  * serialization:
  *              on entry the inode lock on each segment is assumed
  *              to be held.
  *
  * i/o error:
  */
 int txCommit(tid_t tid,		/* transaction identifier */
 	     int nip,		/* number of inodes to commit */
 	     struct inode **iplist,	/* list of inode to commit */
 	     int flag)
 {
 	int rc = 0;
 	struct commit cd;
 	struct jfs_log *log;
 	struct tblock *tblk;
 	struct lrd *lrd;
 	int lsn;
 	struct inode *ip;
 	struct jfs_inode_info *jfs_ip;
 	int k, n;
 	ino_t top;
 	struct super_block *sb;
 	jfs_info("txCommit, tid = %d, flag = %d", tid, flag);
 	/* is read-only file system ? */
 	if (isReadOnly(iplist[0])) {
 		rc = -EROFS;
 		goto TheEnd;
 	}
 	sb = cd.sb = iplist[0]->i_sb;
 	cd.tid = tid;
 	if (tid == 0)
 		tid = txBegin(sb, 0);
 	tblk = tid_to_tblock(tid);
 	/*
 	 * initialize commit structure
 	 */
 	log = JFS_SBI(sb)->log;
 	cd.log = log;
 	/* initialize log record descriptor in commit */
 	lrd = &cd.lrd;
 	lrd->logtid = cpu_to_le32(tblk->logtid);
 	lrd->backchain = 0;
 	tblk->xflag |= flag;
 	if ((flag & (COMMIT_FORCE | COMMIT_SYNC)) == 0)
 		tblk->xflag |= COMMIT_LAZY;
 	/*
 	 *      prepare non-journaled objects for commit
 	 *
 	 * flush data pages of non-journaled file
 	 * to prevent the file getting non-initialized disk blocks
 	 * in case of crash.
 	 * (new blocks - )
 	 */
 	cd.iplist = iplist;
 	cd.nip = nip;
 	/*
 	 *      acquire transaction lock on (on-disk) inodes
 	 *
 	 * update on-disk inode from in-memory inode
 	 * acquiring transaction locks for AFTER records
 	 * on the on-disk inode of file object
 	 *
 	 * sort the inodes array by inode number in descending order
 	 * to prevent deadlock when acquiring transaction lock
 	 * of on-disk inodes on multiple on-disk inode pages by
 	 * multiple concurrent transactions
 	 */
 	for (k = 0; k < cd.nip; k++) {
 		top = (cd.iplist[k])->i_ino;
 		for (n = k + 1; n < cd.nip; n++) {
 			ip = cd.iplist[n];
 			if (ip->i_ino > top) {
 				top = ip->i_ino;
 				cd.iplist[n] = cd.iplist[k];
 				cd.iplist[k] = ip;
 			}
 		}
 		ip = cd.iplist[k];
 		jfs_ip = JFS_IP(ip);
 		/*
 		 * BUGBUG - This code has temporarily been removed.  The
 		 * intent is to ensure that any file data is written before
 		 * the metadata is committed to the journal.  This prevents
 		 * uninitialized data from appearing in a file after the
 		 * journal has been replayed.  (The uninitialized data
 		 * could be sensitive data removed by another user.)
 		 *
 		 * The problem now is that we are holding the IWRITELOCK
 		 * on the inode, and calling filemap_fdatawrite on an
 		 * unmapped page will cause a deadlock in jfs_get_block.
 		 *
 		 * The long term solution is to pare down the use of
 		 * IWRITELOCK.  We are currently holding it too long.
 		 * We could also be smarter about which data pages need
 		 * to be written before the transaction is committed and
 		 * when we don't need to worry about it at all.
 		 *
 		 * if ((!S_ISDIR(ip->i_mode))
 		 *    && (tblk->flag & COMMIT_DELETE) == 0) {
 		 *	filemap_fdatawrite(ip->i_mapping);
 		 *	filemap_fdatawait(ip->i_mapping);
 		 * }
 		 */
 		/*
 		 * Mark inode as not dirty.  It will still be on the dirty
 		 * inode list, but we'll know not to commit it again unless
 		 * it gets marked dirty again
 		 */
 		clear_cflag(COMMIT_Dirty, ip);
 		/* inherit anonymous tlock(s) of inode */
 		if (jfs_ip->atlhead) {
 			lid_to_tlock(jfs_ip->atltail)->next = tblk->next;
 			tblk->next = jfs_ip->atlhead;
 			if (!tblk->last)
 				tblk->last = jfs_ip->atltail;
 			jfs_ip->atlhead = jfs_ip->atltail = 0;
 			TXN_LOCK();
 			list_del_init(&jfs_ip->anon_inode_list);
 			TXN_UNLOCK();
 		}
 		/*
 		 * acquire transaction lock on on-disk inode page
 		 * (become first tlock of the tblk's tlock list)
 		 */
 		if (((rc = diWrite(tid, ip))))
 			goto out;
 	}
 	/*
 	 *      write log records from transaction locks
 	 *
 	 * txUpdateMap() resets XAD_NEW in XAD.
 	 */
 	if ((rc = txLog(log, tblk, &cd)))
 		goto TheEnd;
 	/*
 	 * Ensure that inode isn't reused before
 	 * lazy commit thread finishes processing
 	 */
 	if (tblk->xflag & COMMIT_DELETE) {
 		atomic_inc(&tblk->u.ip->i_count);
 		/*
 		 * Avoid a rare deadlock
 		 *
 		 * If the inode is locked, we may be blocked in
 		 * jfs_commit_inode.  If so, we don't want the
 		 * lazy_commit thread doing the last iput() on the inode
 		 * since that may block on the locked inode.  Instead,
 		 * commit the transaction synchronously, so the last iput
 		 * will be done by the calling thread (or later)
 		 */
 		if (tblk->u.ip->i_state & I_LOCK)
 			tblk->xflag &= ~COMMIT_LAZY;
 	}
 	ASSERT((!(tblk->xflag & COMMIT_DELETE)) ||
 	       ((tblk->u.ip->i_nlink == 0) &&
 		!test_cflag(COMMIT_Nolink, tblk->u.ip)));
 	/*
 	 *      write COMMIT log record
 	 */
 	lrd->type = cpu_to_le16(LOG_COMMIT);
 	lrd->length = 0;
 	lsn = lmLog(log, tblk, lrd, NULL);
 	lmGroupCommit(log, tblk);
 	/*
 	 *      - transaction is now committed -
 	 */
 	/*
 	 * force pages in careful update
 	 * (imap addressing structure update)
 	 */
 	if (flag & COMMIT_FORCE)
 		txForce(tblk);
 	/*
 	 *      update allocation map.
 	 *
 	 * update inode allocation map and inode:
 	 * free pager lock on memory object of inode if any.
 	 * update  block allocation map.
 	 *
 	 * txUpdateMap() resets XAD_NEW in XAD.
 	 */
 	if (tblk->xflag & COMMIT_FORCE)
 		txUpdateMap(tblk);
 	/*
 	 *      free transaction locks and pageout/free pages
 	 */
 	txRelease(tblk);
 	if ((tblk->flag & tblkGC_LAZY) == 0)
 		txUnlock(tblk);
 	/*
 	 *      reset in-memory object state
 	 */
 	for (k = 0; k < cd.nip; k++) {
 		ip = cd.iplist[k];
 		jfs_ip = JFS_IP(ip);
 		/*
 		 * reset in-memory inode state
 		 */
 		jfs_ip->bxflag = 0;
 		jfs_ip->blid = 0;
 	}
       out:
 	if (rc != 0)
 		txAbort(tid, 1);
       TheEnd:
 	jfs_info("txCommit: tid = %d, returning %d", tid, rc);
 	return rc;
 }
 /*
  * NAME:        txLog()
  *
  * FUNCTION:    Writes AFTER log records for all lines modified
  *              by tid for segments specified by inodes in comdata.
  *              Code assumes only WRITELOCKS are recorded in lockwords.
  *
  * PARAMETERS:
  *
  * RETURN :
  */
 static int txLog(struct jfs_log * log, struct tblock * tblk, struct commit * cd)
 {
 	int rc = 0;
 	struct inode *ip;
 	lid_t lid;
 	struct tlock *tlck;
 	struct lrd *lrd = &cd->lrd;
 	/*
 	 * write log record(s) for each tlock of transaction,
 	 */
 	for (lid = tblk->next; lid; lid = tlck->next) {
 		tlck = lid_to_tlock(lid);
 		tlck->flag |= tlckLOG;
 		/* initialize lrd common */
 		ip = tlck->ip;
 		lrd->aggregate = cpu_to_le32(JFS_SBI(ip->i_sb)->aggregate);
 		lrd->log.redopage.fileset = cpu_to_le32(JFS_IP(ip)->fileset);
 		lrd->log.redopage.inode = cpu_to_le32(ip->i_ino);
 		/* write log record of page from the tlock */
 		switch (tlck->type & tlckTYPE) {
 		case tlckXTREE:
 			xtLog(log, tblk, lrd, tlck);
 			break;
 		case tlckDTREE:
 			dtLog(log, tblk, lrd, tlck);
 			break;
 		case tlckINODE:
 			diLog(log, tblk, lrd, tlck, cd);
 			break;
 		case tlckMAP:
 			mapLog(log, tblk, lrd, tlck);
 			break;
 		case tlckDATA:
 			dataLog(log, tblk, lrd, tlck);
 			break;
 		default:
 			jfs_err("UFO tlock:0x%p", tlck);
 		}
 	}
 	return rc;
 }
 /*
  *      diLog()
  *
  * function:    log inode tlock and format maplock to update bmap;
  */
 static int diLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	  struct tlock * tlck, struct commit * cd)
 {
 	int rc = 0;
 	struct metapage *mp;
 	pxd_t *pxd;
 	struct pxd_lock *pxdlock;
 	mp = tlck->mp;
 	/* initialize as REDOPAGE record format */
 	lrd->log.redopage.type = cpu_to_le16(LOG_INODE);
 	lrd->log.redopage.l2linesize = cpu_to_le16(L2INODESLOTSIZE);
 	pxd = &lrd->log.redopage.pxd;
 	/*
 	 *      inode after image
 	 */
 	if (tlck->type & tlckENTRY) {
 		/* log after-image for logredo(): */
 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
 		PXDaddress(pxd, mp->index);
 		PXDlength(pxd,
 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 	} else if (tlck->type & tlckFREE) {
 		/*
 		 *      free inode extent
 		 *
 		 * (pages of the freed inode extent have been invalidated and
 		 * a maplock for free of the extent has been formatted at
 		 * txLock() time);
 		 *
 		 * the tlock had been acquired on the inode allocation map page
 		 * (iag) that specifies the freed extent, even though the map
 		 * page is not itself logged, to prevent pageout of the map
 		 * page before the log;
 		 */
 		/* log LOG_NOREDOINOEXT of the freed inode extent for
 		 * logredo() to start NoRedoPage filters, and to update
 		 * imap and bmap for free of the extent;
 		 */
 		lrd->type = cpu_to_le16(LOG_NOREDOINOEXT);
 		/*
 		 * For the LOG_NOREDOINOEXT record, we need
 		 * to pass the IAG number and inode extent
 		 * index (within that IAG) from which the
 		 * the extent being released.  These have been
 		 * passed to us in the iplist[1] and iplist[2].
 		 */
 		lrd->log.noredoinoext.iagnum =
 		    cpu_to_le32((u32) (size_t) cd->iplist[1]);
 		lrd->log.noredoinoext.inoext_idx =
 		    cpu_to_le32((u32) (size_t) cd->iplist[2]);
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		*pxd = pxdlock->pxd;
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		/* update bmap */
 		tlck->flag |= tlckUPDATEMAP;
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 	} else
 		jfs_err("diLog: UFO type tlck:0x%p", tlck);
 #ifdef  _JFS_WIP
 	/*
 	 *      alloc/free external EA extent
 	 *
 	 * a maplock for txUpdateMap() to update bPWMAP for alloc/free
 	 * of the extent has been formatted at txLock() time;
 	 */
 	else {
 		assert(tlck->type & tlckEA);
 		/* log LOG_UPDATEMAP for logredo() to update bmap for
 		 * alloc of new (and free of old) external EA extent;
 		 */
 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		nlock = pxdlock->index;
 		for (i = 0; i < nlock; i++, pxdlock++) {
 			if (pxdlock->flag & mlckALLOCPXD)
 				lrd->log.updatemap.type =
 				    cpu_to_le16(LOG_ALLOCPXD);
 			else
 				lrd->log.updatemap.type =
 				    cpu_to_le16(LOG_FREEPXD);
 			lrd->log.updatemap.nxd = cpu_to_le16(1);
 			lrd->log.updatemap.pxd = pxdlock->pxd;
 			lrd->backchain =
 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		}
 		/* update bmap */
 		tlck->flag |= tlckUPDATEMAP;
 	}
 #endif				/* _JFS_WIP */
 	return rc;
 }
 /*
  *      dataLog()
  *
  * function:    log data tlock
  */
 static int dataLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	    struct tlock * tlck)
 {
 	struct metapage *mp;
 	pxd_t *pxd;
 	mp = tlck->mp;
 	/* initialize as REDOPAGE record format */
 	lrd->log.redopage.type = cpu_to_le16(LOG_DATA);
 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DATASLOTSIZE);
 	pxd = &lrd->log.redopage.pxd;
 	/* log after-image for logredo(): */
 	lrd->type = cpu_to_le16(LOG_REDOPAGE);
 	if (jfs_dirtable_inline(tlck->ip)) {
 		/*
 		 * The table has been truncated, we've must have deleted
 		 * the last entry, so don't bother logging this
 		 */
 		mp->lid = 0;
 		grab_metapage(mp);
 		metapage_homeok(mp);
 		discard_metapage(mp);
 		tlck->mp = NULL;
 		return 0;
 	}
 	PXDaddress(pxd, mp->index);
 	PXDlength(pxd, mp->logical_size >> tblk->sb->s_blocksize_bits);
 	lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 	/* mark page as homeward bound */
 	tlck->flag |= tlckWRITEPAGE;
 	return 0;
 }
 /*
  *      dtLog()
  *
  * function:    log dtree tlock and format maplock to update bmap;
  */
 static void dtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	   struct tlock * tlck)
 {
 	struct metapage *mp;
 	struct pxd_lock *pxdlock;
 	pxd_t *pxd;
 	mp = tlck->mp;
 	/* initialize as REDOPAGE/NOREDOPAGE record format */
 	lrd->log.redopage.type = cpu_to_le16(LOG_DTREE);
 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DTSLOTSIZE);
 	pxd = &lrd->log.redopage.pxd;
 	if (tlck->type & tlckBTROOT)
 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
 	/*
 	 *      page extension via relocation: entry insertion;
 	 *      page extension in-place: entry insertion;
 	 *      new right page from page split, reinitialized in-line
 	 *      root from root page split: entry insertion;
 	 */
 	if (tlck->type & (tlckNEW | tlckEXTEND)) {
 		/* log after-image of the new page for logredo():
 		 * mark log (LOG_NEW) for logredo() to initialize
 		 * freelist and update bmap for alloc of the new page;
 		 */
 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
 		if (tlck->type & tlckEXTEND)
 			lrd->log.redopage.type |= cpu_to_le16(LOG_EXTEND);
 		else
 			lrd->log.redopage.type |= cpu_to_le16(LOG_NEW);
 		PXDaddress(pxd, mp->index);
 		PXDlength(pxd,
 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/* format a maplock for txUpdateMap() to update bPMAP for
 		 * alloc of the new page;
 		 */
 		if (tlck->type & tlckBTROOT)
 			return;
 		tlck->flag |= tlckUPDATEMAP;
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		pxdlock->flag = mlckALLOCPXD;
 		pxdlock->pxd = *pxd;
 		pxdlock->index = 1;
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 		return;
 	}
 	/*
 	 *      entry insertion/deletion,
 	 *      sibling page link update (old right page before split);
 	 */
 	if (tlck->type & (tlckENTRY | tlckRELINK)) {
 		/* log after-image for logredo(): */
 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
 		PXDaddress(pxd, mp->index);
 		PXDlength(pxd,
 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 		return;
 	}
 	/*
 	 *      page deletion: page has been invalidated
 	 *      page relocation: source extent
 	 *
 	 *      a maplock for free of the page has been formatted
 	 *      at txLock() time);
 	 */
 	if (tlck->type & (tlckFREE | tlckRELOCATE)) {
 		/* log LOG_NOREDOPAGE of the deleted page for logredo()
 		 * to start NoRedoPage filter and to update bmap for free
 		 * of the deletd page
 		 */
 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		*pxd = pxdlock->pxd;
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		/* a maplock for txUpdateMap() for free of the page
 		 * has been formatted at txLock() time;
 		 */
 		tlck->flag |= tlckUPDATEMAP;
 	}
 	return;
 }
 /*
  *      xtLog()
  *
  * function:    log xtree tlock and format maplock to update bmap;
  */
 static void xtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	   struct tlock * tlck)
 {
 	struct inode *ip;
 	struct metapage *mp;
 	xtpage_t *p;
 	struct xtlock *xtlck;
 	struct maplock *maplock;
 	struct xdlistlock *xadlock;
 	struct pxd_lock *pxdlock;
 	pxd_t *page_pxd;
 	int next, lwm, hwm;
 	ip = tlck->ip;
 	mp = tlck->mp;
 	/* initialize as REDOPAGE/NOREDOPAGE record format */
 	lrd->log.redopage.type = cpu_to_le16(LOG_XTREE);
 	lrd->log.redopage.l2linesize = cpu_to_le16(L2XTSLOTSIZE);
 	page_pxd = &lrd->log.redopage.pxd;
 	if (tlck->type & tlckBTROOT) {
 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
 		p = &JFS_IP(ip)->i_xtroot;
 		if (S_ISDIR(ip->i_mode))
 			lrd->log.redopage.type |=
 			    cpu_to_le16(LOG_DIR_XTREE);
 	} else
 		p = (xtpage_t *) mp->data;
 	next = le16_to_cpu(p->header.nextindex);
 	xtlck = (struct xtlock *) & tlck->lock;
 	maplock = (struct maplock *) & tlck->lock;
 	xadlock = (struct xdlistlock *) maplock;
 	/*
 	 *      entry insertion/extension;
 	 *      sibling page link update (old right page before split);
 	 */
 	if (tlck->type & (tlckNEW | tlckGROW | tlckRELINK)) {
 		/* log after-image for logredo():
 		 * logredo() will update bmap for alloc of new/extended
 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
 		 * after-image of XADlist;
 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
 		 * applying the after-image to the meta-data page.
 		 */
 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
 		PXDaddress(page_pxd, mp->index);
 		PXDlength(page_pxd,
 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/* format a maplock for txUpdateMap() to update bPMAP
 		 * for alloc of new/extended extents of XAD[lwm:next)
 		 * from the page itself;
 		 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
 		 */
 		lwm = xtlck->lwm.offset;
 		if (lwm == 0)
 			lwm = XTPAGEMAXSLOT;
 		if (lwm == next)
 			goto out;
 		if (lwm > next) {
 			jfs_err("xtLog: lwm > next\n");
 			goto out;
 		}
 		tlck->flag |= tlckUPDATEMAP;
 		xadlock->flag = mlckALLOCXADLIST;
 		xadlock->count = next - lwm;
 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
 			int i;
 			pxd_t *pxd;
 			/*
 			 * Lazy commit may allow xtree to be modified before
 			 * txUpdateMap runs.  Copy xad into linelock to
 			 * preserve correct data.
 			 *
 			 * We can fit twice as may pxd's as xads in the lock
 			 */
 			xadlock->flag = mlckALLOCPXDLIST;
 			pxd = xadlock->xdlist = &xtlck->pxdlock;
 			for (i = 0; i < xadlock->count; i++) {
 				PXDaddress(pxd, addressXAD(&p->xad[lwm + i]));
 				PXDlength(pxd, lengthXAD(&p->xad[lwm + i]));
 				p->xad[lwm + i].flag &=
 				    ~(XAD_NEW | XAD_EXTENDED);
 				pxd++;
 			}
 		} else {
 			/*
 			 * xdlist will point to into inode's xtree, ensure
 			 * that transaction is not committed lazily.
 			 */
 			xadlock->flag = mlckALLOCXADLIST;
 			xadlock->xdlist = &p->xad[lwm];
 			tblk->xflag &= ~COMMIT_LAZY;
 		}
 		jfs_info("xtLog: alloc ip:0x%p mp:0x%p tlck:0x%p lwm:%d "
 			 "count:%d", tlck->ip, mp, tlck, lwm, xadlock->count);
 		maplock->index = 1;
 	      out:
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 		return;
 	}
 	/*
 	 *      page deletion: file deletion/truncation (ref. xtTruncate())
 	 *
 	 * (page will be invalidated after log is written and bmap
 	 * is updated from the page);
 	 */
 	if (tlck->type & tlckFREE) {
 		/* LOG_NOREDOPAGE log for NoRedoPage filter:
 		 * if page free from file delete, NoRedoFile filter from
 		 * inode image of zero link count will subsume NoRedoPage
 		 * filters for each page;
 		 * if page free from file truncattion, write NoRedoPage
 		 * filter;
 		 *
 		 * upadte of block allocation map for the page itself:
 		 * if page free from deletion and truncation, LOG_UPDATEMAP
 		 * log for the page itself is generated from processing
 		 * its parent page xad entries;
 		 */
 		/* if page free from file truncation, log LOG_NOREDOPAGE
 		 * of the deleted page for logredo() to start NoRedoPage
 		 * filter for the page;
 		 */
 		if (tblk->xflag & COMMIT_TRUNCATE) {
 			/* write NOREDOPAGE for the page */
 			lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
 			PXDaddress(page_pxd, mp->index);
 			PXDlength(page_pxd,
 				  mp->logical_size >> tblk->sb->
 				  s_blocksize_bits);
 			lrd->backchain =
 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 			if (tlck->type & tlckBTROOT) {
 				/* Empty xtree must be logged */
 				lrd->type = cpu_to_le16(LOG_REDOPAGE);
 				lrd->backchain =
 				    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 			}
 		}
 		/* init LOG_UPDATEMAP of the freed extents
 		 * XAD[XTENTRYSTART:hwm) from the deleted page itself
 		 * for logredo() to update bmap;
 		 */
 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEXADLIST);
 		xtlck = (struct xtlock *) & tlck->lock;
 		hwm = xtlck->hwm.offset;
 		lrd->log.updatemap.nxd =
 		    cpu_to_le16(hwm - XTENTRYSTART + 1);
 		/* reformat linelock for lmLog() */
 		xtlck->header.offset = XTENTRYSTART;
 		xtlck->header.length = hwm - XTENTRYSTART + 1;
 		xtlck->index = 1;
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/* format a maplock for txUpdateMap() to update bmap
 		 * to free extents of XAD[XTENTRYSTART:hwm) from the
 		 * deleted page itself;
 		 */
 		tlck->flag |= tlckUPDATEMAP;
 		xadlock->count = hwm - XTENTRYSTART + 1;
 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
 			int i;
 			pxd_t *pxd;
 			/*
 			 * Lazy commit may allow xtree to be modified before
 			 * txUpdateMap runs.  Copy xad into linelock to
 			 * preserve correct data.
 			 *
 			 * We can fit twice as may pxd's as xads in the lock
 			 */
 			xadlock->flag = mlckFREEPXDLIST;
 			pxd = xadlock->xdlist = &xtlck->pxdlock;
 			for (i = 0; i < xadlock->count; i++) {
 				PXDaddress(pxd,
 					addressXAD(&p->xad[XTENTRYSTART + i]));
 				PXDlength(pxd,
 					lengthXAD(&p->xad[XTENTRYSTART + i]));
 				pxd++;
 			}
 		} else {
 			/*
 			 * xdlist will point to into inode's xtree, ensure
 			 * that transaction is not committed lazily.
 			 */
 			xadlock->flag = mlckFREEXADLIST;
 			xadlock->xdlist = &p->xad[XTENTRYSTART];
 			tblk->xflag &= ~COMMIT_LAZY;
 		}
 		jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d lwm:2",
 			 tlck->ip, mp, xadlock->count);
 		maplock->index = 1;
 		/* mark page as invalid */
 		if (((tblk->xflag & COMMIT_PWMAP) || S_ISDIR(ip->i_mode))
 		    && !(tlck->type & tlckBTROOT))
 			tlck->flag |= tlckFREEPAGE;
 		/*
 		   else (tblk->xflag & COMMIT_PMAP)
 		   ? release the page;
 		 */
 		return;
 	}
 	/*
 	 *      page/entry truncation: file truncation (ref. xtTruncate())
 	 *
 	 *     |----------+------+------+---------------|
 	 *                |      |      |
 	 *                |      |     hwm - hwm before truncation
 	 *                |     next - truncation point
 	 *               lwm - lwm before truncation
 	 * header ?
 	 */
 	if (tlck->type & tlckTRUNCATE) {
 		pxd_t pxd;	/* truncated extent of xad */
 		int twm;
 		/*
 		 * For truncation the entire linelock may be used, so it would
 		 * be difficult to store xad list in linelock itself.
 		 * Therefore, we'll just force transaction to be committed
 		 * synchronously, so that xtree pages won't be changed before
 		 * txUpdateMap runs.
 		 */
 		tblk->xflag &= ~COMMIT_LAZY;
 		lwm = xtlck->lwm.offset;
 		if (lwm == 0)
 			lwm = XTPAGEMAXSLOT;
 		hwm = xtlck->hwm.offset;
 		twm = xtlck->twm.offset;
 		/*
 		 *      write log records
 		 */
 		/* log after-image for logredo():
 		 *
 		 * logredo() will update bmap for alloc of new/extended
 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
 		 * after-image of XADlist;
 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
 		 * applying the after-image to the meta-data page.
 		 */
 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
 		PXDaddress(page_pxd, mp->index);
 		PXDlength(page_pxd,
 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		/*
 		 * truncate entry XAD[twm == next - 1]:
 		 */
 		if (twm == next - 1) {
 			/* init LOG_UPDATEMAP for logredo() to update bmap for
 			 * free of truncated delta extent of the truncated
 			 * entry XAD[next - 1]:
 			 * (xtlck->pxdlock = truncated delta extent);
 			 */
 			pxdlock = (struct pxd_lock *) & xtlck->pxdlock;
 			/* assert(pxdlock->type & tlckTRUNCATE); */
 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 			lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
 			lrd->log.updatemap.nxd = cpu_to_le16(1);
 			lrd->log.updatemap.pxd = pxdlock->pxd;
 			pxd = pxdlock->pxd;	/* save to format maplock */
 			lrd->backchain =
 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		}
 		/*
 		 * free entries XAD[next:hwm]:
 		 */
 		if (hwm >= next) {
 			/* init LOG_UPDATEMAP of the freed extents
 			 * XAD[next:hwm] from the deleted page itself
 			 * for logredo() to update bmap;
 			 */
 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 			lrd->log.updatemap.type =
 			    cpu_to_le16(LOG_FREEXADLIST);
 			xtlck = (struct xtlock *) & tlck->lock;
 			hwm = xtlck->hwm.offset;
 			lrd->log.updatemap.nxd =
 			    cpu_to_le16(hwm - next + 1);
 			/* reformat linelock for lmLog() */
 			xtlck->header.offset = next;
 			xtlck->header.length = hwm - next + 1;
 			xtlck->index = 1;
 			lrd->backchain =
 			    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
 		}
 		/*
 		 *      format maplock(s) for txUpdateMap() to update bmap
 		 */
 		maplock->index = 0;
 		/*
 		 * allocate entries XAD[lwm:next):
 		 */
 		if (lwm < next) {
 			/* format a maplock for txUpdateMap() to update bPMAP
 			 * for alloc of new/extended extents of XAD[lwm:next)
 			 * from the page itself;
 			 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
 			 */
 			tlck->flag |= tlckUPDATEMAP;
 			xadlock->flag = mlckALLOCXADLIST;
 			xadlock->count = next - lwm;
 			xadlock->xdlist = &p->xad[lwm];
 			jfs_info("xtLog: alloc ip:0x%p mp:0x%p count:%d "
 				 "lwm:%d next:%d",
 				 tlck->ip, mp, xadlock->count, lwm, next);
 			maplock->index++;
 			xadlock++;
 		}
 		/*
 		 * truncate entry XAD[twm == next - 1]:
 		 */
 		if (twm == next - 1) {
 			struct pxd_lock *pxdlock;
 			/* format a maplock for txUpdateMap() to update bmap
 			 * to free truncated delta extent of the truncated
 			 * entry XAD[next - 1];
 			 * (xtlck->pxdlock = truncated delta extent);
 			 */
 			tlck->flag |= tlckUPDATEMAP;
 			pxdlock = (struct pxd_lock *) xadlock;
 			pxdlock->flag = mlckFREEPXD;
 			pxdlock->count = 1;
 			pxdlock->pxd = pxd;
 			jfs_info("xtLog: truncate ip:0x%p mp:0x%p count:%d "
 				 "hwm:%d", ip, mp, pxdlock->count, hwm);
 			maplock->index++;
 			xadlock++;
 		}
 		/*
 		 * free entries XAD[next:hwm]:
 		 */
 		if (hwm >= next) {
 			/* format a maplock for txUpdateMap() to update bmap
 			 * to free extents of XAD[next:hwm] from thedeleted
 			 * page itself;
 			 */
 			tlck->flag |= tlckUPDATEMAP;
 			xadlock->flag = mlckFREEXADLIST;
 			xadlock->count = hwm - next + 1;
 			xadlock->xdlist = &p->xad[next];
 			jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d "
 				 "next:%d hwm:%d",
 				 tlck->ip, mp, xadlock->count, next, hwm);
 			maplock->index++;
 		}
 		/* mark page as homeward bound */
 		tlck->flag |= tlckWRITEPAGE;
 	}
 	return;
 }
 /*
  *      mapLog()
  *
  * function:    log from maplock of freed data extents;
  */
 void mapLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
 	    struct tlock * tlck)
 {
 	struct pxd_lock *pxdlock;
 	int i, nlock;
 	pxd_t *pxd;
 	/*
 	 *      page relocation: free the source page extent
 	 *
 	 * a maplock for txUpdateMap() for free of the page
 	 * has been formatted at txLock() time saving the src
 	 * relocated page address;
 	 */
 	if (tlck->type & tlckRELOCATE) {
 		/* log LOG_NOREDOPAGE of the old relocated page
 		 * for logredo() to start NoRedoPage filter;
 		 */
 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		pxd = &lrd->log.redopage.pxd;
 		*pxd = pxdlock->pxd;
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		/* (N.B. currently, logredo() does NOT update bmap
 		 * for free of the page itself for (LOG_XTREE|LOG_NOREDOPAGE);
 		 * if page free from relocation, LOG_UPDATEMAP log is
 		 * specifically generated now for logredo()
 		 * to update bmap for free of src relocated page;
 		 * (new flag LOG_RELOCATE may be introduced which will
 		 * inform logredo() to start NORedoPage filter and also
 		 * update block allocation map at the same time, thus
 		 * avoiding an extra log write);
 		 */
 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
 		lrd->log.updatemap.nxd = cpu_to_le16(1);
 		lrd->log.updatemap.pxd = pxdlock->pxd;
 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 		/* a maplock for txUpdateMap() for free of the page
 		 * has been formatted at txLock() time;
 		 */
 		tlck->flag |= tlckUPDATEMAP;
 		return;
 	}
 	/*
 	 * Otherwise it's not a relocate request
 	 *
 	 */
 	else {
 		/* log LOG_UPDATEMAP for logredo() to update bmap for
 		 * free of truncated/relocated delta extent of the data;
 		 * e.g.: external EA extent, relocated/truncated extent
 		 * from xtTailgate();
 		 */
 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
 		pxdlock = (struct pxd_lock *) & tlck->lock;
 		nlock = pxdlock->index;
 		for (i = 0; i < nlock; i++, pxdlock++) {
 			if (pxdlock->flag & mlckALLOCPXD)
 				lrd->log.updatemap.type =
 				    cpu_to_le16(LOG_ALLOCPXD);
 			else
 				lrd->log.updatemap.type =
 				    cpu_to_le16(LOG_FREEPXD);
 			lrd->log.updatemap.nxd = cpu_to_le16(1);
 			lrd->log.updatemap.pxd = pxdlock->pxd;
 			lrd->backchain =
 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
 			jfs_info("mapLog: xaddr:0x%lx xlen:0x%x",
 				 (ulong) addressPXD(&pxdlock->pxd),
 				 lengthPXD(&pxdlock->pxd));
 		}
 		/* update bmap */
 		tlck->flag |= tlckUPDATEMAP;
 	}
 }
 /*
  *      txEA()
  *
  * function:    acquire maplock for EA/ACL extents or
  *              set COMMIT_INLINE flag;
  */
 void txEA(tid_t tid, struct inode *ip, dxd_t * oldea, dxd_t * newea)
 {
 	struct tlock *tlck = NULL;
 	struct pxd_lock *maplock = NULL, *pxdlock = NULL;
 	/*
 	 * format maplock for alloc of new EA extent
 	 */
 	if (newea) {
 		/* Since the newea could be a completely zeroed entry we need to
 		 * check for the two flags which indicate we should actually
 		 * commit new EA data
 		 */
 		if (newea->flag & DXD_EXTENT) {
 			tlck = txMaplock(tid, ip, tlckMAP);
 			maplock = (struct pxd_lock *) & tlck->lock;
 			pxdlock = (struct pxd_lock *) maplock;
 			pxdlock->flag = mlckALLOCPXD;
 			PXDaddress(&pxdlock->pxd, addressDXD(newea));
 			PXDlength(&pxdlock->pxd, lengthDXD(newea));
 			pxdlock++;
 			maplock->index = 1;
 		} else if (newea->flag & DXD_INLINE) {
 			tlck = NULL;
 			set_cflag(COMMIT_Inlineea, ip);
 		}
 	}
 	/*
 	 * format maplock for free of old EA extent
 	 */
 	if (!test_cflag(COMMIT_Nolink, ip) && oldea->flag & DXD_EXTENT) {
 		if (tlck == NULL) {
 			tlck = txMaplock(tid, ip, tlckMAP);
 			maplock = (struct pxd_lock *) & tlck->lock;
 			pxdlock = (struct pxd_lock *) maplock;
 			maplock->index = 0;
 		}
 		pxdlock->flag = mlckFREEPXD;
 		PXDaddress(&pxdlock->pxd, addressDXD(oldea));
 		PXDlength(&pxdlock->pxd, lengthDXD(oldea));
 		maplock->index++;
 	}
 }
 /*
  *      txForce()
  *
  * function: synchronously write pages locked by transaction
  *              after txLog() but before txUpdateMap();
  */
 void txForce(struct tblock * tblk)
 {
 	struct tlock *tlck;
 	lid_t lid, next;
 	struct metapage *mp;
 	/*
 	 * reverse the order of transaction tlocks in
 	 * careful update order of address index pages
 	 * (right to left, bottom up)
 	 */
 	tlck = lid_to_tlock(tblk->next);
 	lid = tlck->next;
 	tlck->next = 0;
 	while (lid) {
 		tlck = lid_to_tlock(lid);
 		next = tlck->next;
 		tlck->next = tblk->next;
 		tblk->next = lid;
 		lid = next;
 	}
 	/*
 	 * synchronously write the page, and
 	 * hold the page for txUpdateMap();
 	 */
 	for (lid = tblk->next; lid; lid = next) {
 		tlck = lid_to_tlock(lid);
 		next = tlck->next;
 		if ((mp = tlck->mp) != NULL &&
 		    (tlck->type & tlckBTROOT) == 0) {
 			assert(mp->xflag & COMMIT_PAGE);
 			if (tlck->flag & tlckWRITEPAGE) {
 				tlck->flag &= ~tlckWRITEPAGE;
 				/* do not release page to freelist */
 				force_metapage(mp);
 #if 0
 				/*
 				 * The "right" thing to do here is to
 				 * synchronously write the metadata.
 				 * With the current implementation this
 				 * is hard since write_metapage requires
 				 * us to kunmap & remap the page.  If we
 				 * have tlocks pointing into the metadata
 				 * pages, we don't want to do this.  I think
 				 * we can get by with synchronously writing
 				 * the pages when they are released.
 				 */
 				assert(mp->nohomeok);
 				set_bit(META_dirty, &mp->flag);
 				set_bit(META_sync, &mp->flag);
 #endif
 			}
 		}
 	}
 }
 /*
  *      txUpdateMap()
  *
  * function:    update persistent allocation map (and working map
  *              if appropriate);
  *
  * parameter:
  */
 static void txUpdateMap(struct tblock * tblk)
 {
 	struct inode *ip;
 	struct inode *ipimap;
 	lid_t lid;
 	struct tlock *tlck;
 	struct maplock *maplock;
 	struct pxd_lock pxdlock;
 	int maptype;
 	int k, nlock;
 	struct metapage *mp = NULL;
 	ipimap = JFS_SBI(tblk->sb)->ipimap;
 	maptype = (tblk->xflag & COMMIT_PMAP) ? COMMIT_PMAP : COMMIT_PWMAP;
 	/*
 	 *      update block allocation map
 	 *
 	 * update allocation state in pmap (and wmap) and
 	 * update lsn of the pmap page;
 	 */
 	/*
 	 * scan each tlock/page of transaction for block allocation/free:
 	 *
 	 * for each tlock/page of transaction, update map.
 	 *  ? are there tlock for pmap and pwmap at the same time ?
 	 */
 	for (lid = tblk->next; lid; lid = tlck->next) {
 		tlck = lid_to_tlock(lid);
 		if ((tlck->flag & tlckUPDATEMAP) == 0)
 			continue;
 		if (tlck->flag & tlckFREEPAGE) {
 			/*
 			 * Another thread may attempt to reuse freed space
 			 * immediately, so we want to get rid of the metapage
 			 * before anyone else has a chance to get it.
 			 * Lock metapage, update maps, then invalidate
 			 * the metapage.
 			 */
 			mp = tlck->mp;
 			ASSERT(mp->xflag & COMMIT_PAGE);
 			grab_metapage(mp);
 		}
 		/*
 		 * extent list:
 		 * . in-line PXD list:
 		 * . out-of-line XAD list:
 		 */
 		maplock = (struct maplock *) & tlck->lock;
 		nlock = maplock->index;
 		for (k = 0; k < nlock; k++, maplock++) {
 			/*
 			 * allocate blocks in persistent map:
 			 *
 			 * blocks have been allocated from wmap at alloc time;
 			 */
 			if (maplock->flag & mlckALLOC) {
 				txAllocPMap(ipimap, maplock, tblk);
 			}
 			/*
 			 * free blocks in persistent and working map:
 			 * blocks will be freed in pmap and then in wmap;
 			 *
 			 * ? tblock specifies the PMAP/PWMAP based upon
 			 * transaction
 			 *
 			 * free blocks in persistent map:
 			 * blocks will be freed from wmap at last reference
 			 * release of the object for regular files;
 			 *
 			 * Alway free blocks from both persistent & working
 			 * maps for directories
 			 */
 			else {	/* (maplock->flag & mlckFREE) */
 				if (S_ISDIR(tlck->ip->i_mode))
 					txFreeMap(ipimap, maplock,
 						  tblk, COMMIT_PWMAP);
 				else
 					txFreeMap(ipimap, maplock,
 						  tblk, maptype);
 			}
 		}
 		if (tlck->flag & tlckFREEPAGE) {
 			if (!(tblk->flag & tblkGC_LAZY)) {
 				/* This is equivalent to txRelease */
 				ASSERT(mp->lid == lid);
 				tlck->mp->lid = 0;
 			}
 			assert(mp->nohomeok == 1);
 			metapage_homeok(mp);
 			discard_metapage(mp);
 			tlck->mp = NULL;
 		}
 	}
 	/*
 	 *      update inode allocation map
 	 *
 	 * update allocation state in pmap and
 	 * update lsn of the pmap page;
 	 * update in-memory inode flag/state
 	 *
 	 * unlock mapper/write lock
 	 */
 	if (tblk->xflag & COMMIT_CREATE) {
 		diUpdatePMap(ipimap, tblk->ino, FALSE, tblk);
 		ipimap->i_state |= I_DIRTY;
 		/* update persistent block allocation map
 		 * for the allocation of inode extent;
 		 */
 		pxdlock.flag = mlckALLOCPXD;
 		pxdlock.pxd = tblk->u.ixpxd;
 		pxdlock.index = 1;
 		txAllocPMap(ipimap, (struct maplock *) & pxdlock, tblk);
 	} else if (tblk->xflag & COMMIT_DELETE) {
 		ip = tblk->u.ip;
 		diUpdatePMap(ipimap, ip->i_ino, TRUE, tblk);
 		ipimap->i_state |= I_DIRTY;
 		iput(ip);
 	}
 }
 /*
  *      txAllocPMap()
  *
  * function: allocate from persistent map;
  *
  * parameter:
  *      ipbmap  -
  *      malock -
  *              xad list:
  *              pxd:
  *
  *      maptype -
  *              allocate from persistent map;
  *              free from persistent map;
  *              (e.g., tmp file - free from working map at releae
  *               of last reference);
  *              free from persistent and working map;
  *
  *      lsn     - log sequence number;
  */
 static void txAllocPMap(struct inode *ip, struct maplock * maplock,
 			struct tblock * tblk)
 {
 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
 	struct xdlistlock *xadlistlock;
 	xad_t *xad;
 	s64 xaddr;
 	int xlen;
 	struct pxd_lock *pxdlock;
 	struct xdlistlock *pxdlistlock;
 	pxd_t *pxd;
 	int n;
 	/*
 	 * allocate from persistent map;
 	 */
 	if (maplock->flag & mlckALLOCXADLIST) {
 		xadlistlock = (struct xdlistlock *) maplock;
 		xad = xadlistlock->xdlist;
 		for (n = 0; n < xadlistlock->count; n++, xad++) {
 			if (xad->flag & (XAD_NEW | XAD_EXTENDED)) {
 				xaddr = addressXAD(xad);
 				xlen = lengthXAD(xad);
 				dbUpdatePMap(ipbmap, FALSE, xaddr,
 					     (s64) xlen, tblk);
 				xad->flag &= ~(XAD_NEW | XAD_EXTENDED);
 				jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
 					 (ulong) xaddr, xlen);
 			}
 		}
 	} else if (maplock->flag & mlckALLOCPXD) {
 		pxdlock = (struct pxd_lock *) maplock;
 		xaddr = addressPXD(&pxdlock->pxd);
 		xlen = lengthPXD(&pxdlock->pxd);
 		dbUpdatePMap(ipbmap, FALSE, xaddr, (s64) xlen, tblk);
 		jfs_info("allocPMap: xaddr:0x%lx xlen:%d", (ulong) xaddr, xlen);
 	} else {		/* (maplock->flag & mlckALLOCPXDLIST) */
 		pxdlistlock = (struct xdlistlock *) maplock;
 		pxd = pxdlistlock->xdlist;
 		for (n = 0; n < pxdlistlock->count; n++, pxd++) {
 			xaddr = addressPXD(pxd);
 			xlen = lengthPXD(pxd);
 			dbUpdatePMap(ipbmap, FALSE, xaddr, (s64) xlen,
 				     tblk);
 			jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
 				 (ulong) xaddr, xlen);
 		}
 	}
 }
 /*
  *      txFreeMap()
  *
  * function:    free from persistent and/or working map;
  *
  * todo: optimization
  */
 void txFreeMap(struct inode *ip,
 	       struct maplock * maplock, struct tblock * tblk, int maptype)
 {
 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
 	struct xdlistlock *xadlistlock;
 	xad_t *xad;
 	s64 xaddr;
 	int xlen;
 	struct pxd_lock *pxdlock;
 	struct xdlistlock *pxdlistlock;
 	pxd_t *pxd;
 	int n;
 	jfs_info("txFreeMap: tblk:0x%p maplock:0x%p maptype:0x%x",
 		 tblk, maplock, maptype);
 	/*
 	 * free from persistent map;
 	 */
 	if (maptype == COMMIT_PMAP || maptype == COMMIT_PWMAP) {
 		if (maplock->flag & mlckFREEXADLIST) {
 			xadlistlock = (struct xdlistlock *) maplock;
 			xad = xadlistlock->xdlist;
 			for (n = 0; n < xadlistlock->count; n++, xad++) {
 				if (!(xad->flag & XAD_NEW)) {
 					xaddr = addressXAD(xad);
 					xlen = lengthXAD(xad);
 					dbUpdatePMap(ipbmap, TRUE, xaddr,
 						     (s64) xlen, tblk);
 					jfs_info("freePMap: xaddr:0x%lx "
 						 "xlen:%d",
 						 (ulong) xaddr, xlen);
 				}
 			}
 		} else if (maplock->flag & mlckFREEPXD) {
 			pxdlock = (struct pxd_lock *) maplock;
 			xaddr = addressPXD(&pxdlock->pxd);
 			xlen = lengthPXD(&pxdlock->pxd);
 			dbUpdatePMap(ipbmap, TRUE, xaddr, (s64) xlen,
 				     tblk);
 			jfs_info("freePMap: xaddr:0x%lx xlen:%d",
 				 (ulong) xaddr, xlen);
 		} else {	/* (maplock->flag & mlckALLOCPXDLIST) */
 			pxdlistlock = (struct xdlistlock *) maplock;
 			pxd = pxdlistlock->xdlist;
 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
 				xaddr = addressPXD(pxd);
 				xlen = lengthPXD(pxd);
 				dbUpdatePMap(ipbmap, TRUE, xaddr,
 					     (s64) xlen, tblk);
 				jfs_info("freePMap: xaddr:0x%lx xlen:%d",
 					 (ulong) xaddr, xlen);
 			}
 		}
 	}
 	/*
 	 * free from working map;
 	 */
 	if (maptype == COMMIT_PWMAP || maptype == COMMIT_WMAP) {
 		if (maplock->flag & mlckFREEXADLIST) {
 			xadlistlock = (struct xdlistlock *) maplock;
 			xad = xadlistlock->xdlist;
 			for (n = 0; n < xadlistlock->count; n++, xad++) {
 				xaddr = addressXAD(xad);
 				xlen = lengthXAD(xad);
 				dbFree(ip, xaddr, (s64) xlen);
 				xad->flag = 0;
 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
 					 (ulong) xaddr, xlen);
 			}
 		} else if (maplock->flag & mlckFREEPXD) {
 			pxdlock = (struct pxd_lock *) maplock;
 			xaddr = addressPXD(&pxdlock->pxd);
 			xlen = lengthPXD(&pxdlock->pxd);
 			dbFree(ip, xaddr, (s64) xlen);
 			jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
 				 (ulong) xaddr, xlen);
 		} else {	/* (maplock->flag & mlckFREEPXDLIST) */
 			pxdlistlock = (struct xdlistlock *) maplock;
 			pxd = pxdlistlock->xdlist;
 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
 				xaddr = addressPXD(pxd);
 				xlen = lengthPXD(pxd);
 				dbFree(ip, xaddr, (s64) xlen);
 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
 					 (ulong) xaddr, xlen);
 			}
 		}
 	}
 }
 /*
  *      txFreelock()
  *
  * function:    remove tlock from inode anonymous locklist
  */
 void txFreelock(struct inode *ip)
 {
 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
 	struct tlock *xtlck, *tlck;
 	lid_t xlid = 0, lid;
 	if (!jfs_ip->atlhead)
 		return;
 	TXN_LOCK();
 	xtlck = (struct tlock *) &jfs_ip->atlhead;
 	while ((lid = xtlck->next) != 0) {
 		tlck = lid_to_tlock(lid);
 		if (tlck->flag & tlckFREELOCK) {
 			xtlck->next = tlck->next;
 			txLockFree(lid);
 		} else {
 			xtlck = tlck;
 			xlid = lid;
 		}
 	}
 	if (jfs_ip->atlhead)
 		jfs_ip->atltail = xlid;
 	else {
 		jfs_ip->atltail = 0;
 		/*
 		 * If inode was on anon_list, remove it
 		 */
 		list_del_init(&jfs_ip->anon_inode_list);
 	}
 	TXN_UNLOCK();
 }
 /*
  *      txAbort()
  *
  * function: abort tx before commit;
  *
  * frees line-locks and segment locks for all
  * segments in comdata structure.
  * Optionally sets state of file-system to FM_DIRTY in super-block.
  * log age of page-frames in memory for which caller has
  * are reset to 0 (to avoid logwarap).
  */
 void txAbort(tid_t tid, int dirty)
 {
 	lid_t lid, next;
 	struct metapage *mp;
 	struct tblock *tblk = tid_to_tblock(tid);
 	struct tlock *tlck;
 	/*
 	 * free tlocks of the transaction
 	 */
 	for (lid = tblk->next; lid; lid = next) {
 		tlck = lid_to_tlock(lid);
 		next = tlck->next;
 		mp = tlck->mp;
 		JFS_IP(tlck->ip)->xtlid = 0;
 		if (mp) {
 			mp->lid = 0;
 			/*
 			 * reset lsn of page to avoid logwarap:
 			 *
 			 * (page may have been previously committed by another
 			 * transaction(s) but has not been paged, i.e.,
 			 * it may be on logsync list even though it has not
 			 * been logged for the current tx.)
 			 */
 			if (mp->xflag & COMMIT_PAGE && mp->lsn)
 				LogSyncRelease(mp);
 		}
 		/* insert tlock at head of freelist */
 		TXN_LOCK();
 		txLockFree(lid);
 		TXN_UNLOCK();
 	}
 	/* caller will free the transaction block */
 	tblk->next = tblk->last = 0;
 	/*
 	 * mark filesystem dirty
 	 */
 	if (dirty)
 		jfs_error(tblk->sb, "txAbort");
 	return;
 }
 /*
  *      txLazyCommit(void)
  *
  *	All transactions except those changing ipimap (COMMIT_FORCE) are
  *	processed by this routine.  This insures that the inode and block
  *	allocation maps are updated in order.  For synchronous transactions,
  *	let the user thread finish processing after txUpdateMap() is called.
  */
 static void txLazyCommit(struct tblock * tblk)
 {
 	struct jfs_log *log;
 	while (((tblk->flag & tblkGC_READY) == 0) &&
 	       ((tblk->flag & tblkGC_UNLOCKED) == 0)) {
 		/* We must have gotten ahead of the user thread
 		 */
 		jfs_info("jfs_lazycommit: tblk 0x%p not unlocked", tblk);
 		yield();
 	}
 	jfs_info("txLazyCommit: processing tblk 0x%p", tblk);
 	txUpdateMap(tblk);
 	log = (struct jfs_log *) JFS_SBI(tblk->sb)->log;
 	spin_lock_irq(&log->gclock);	// LOGGC_LOCK
 	tblk->flag |= tblkGC_COMMITTED;
 	if (tblk->flag & tblkGC_READY)
 		log->gcrtc--;
 	wake_up_all(&tblk->gcwait);	// LOGGC_WAKEUP
 	/*
 	 * Can't release log->gclock until we've tested tblk->flag
 	 */
 	if (tblk->flag & tblkGC_LAZY) {
 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
 		txUnlock(tblk);
 		tblk->flag &= ~tblkGC_LAZY;
 		txEnd(tblk - TxBlock);	/* Convert back to tid */
 	} else
 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
 	jfs_info("txLazyCommit: done: tblk = 0x%p", tblk);
 }
 /*
  *      jfs_lazycommit(void)
  *
  *	To be run as a kernel daemon.  If lbmIODone is called in an interrupt
  *	context, or where blocking is not wanted, this routine will process
  *	committed transactions from the unlock queue.
  */
 int jfs_lazycommit(void *arg)
 {
 	int WorkDone;
 	struct tblock *tblk;
 	unsigned long flags;
 	struct jfs_sb_info *sbi;
 	daemonize("jfsCommit");
 	complete(&jfsIOwait);
 	do {
 		LAZY_LOCK(flags);
 		jfs_commit_thread_waking = 0;	/* OK to wake another thread */
 		while (!list_empty(&TxAnchor.unlock_queue)) {
 			WorkDone = 0;
 			list_for_each_entry(tblk, &TxAnchor.unlock_queue,
 					    cqueue) {
 				sbi = JFS_SBI(tblk->sb);
 				/*
 				 * For each volume, the transactions must be
 				 * handled in order.  If another commit thread
 				 * is handling a tblk for this superblock,
 				 * skip it
 				 */
 				if (sbi->commit_state & IN_LAZYCOMMIT)
 					continue;
 				sbi->commit_state |= IN_LAZYCOMMIT;
 				WorkDone = 1;
 				/*
 				 * Remove transaction from queue
 				 */
 				list_del(&tblk->cqueue);
 				LAZY_UNLOCK(flags);
 				txLazyCommit(tblk);
 				LAZY_LOCK(flags);
 				sbi->commit_state &= ~IN_LAZYCOMMIT;
 				/*
 				 * Don't continue in the for loop.  (We can't
 				 * anyway, it's unsafe!)  We want to go back to
 				 * the beginning of the list.
 				 */
 				break;
 			}
 			/* If there was nothing to do, don't continue */
 			if (!WorkDone)
 				break;
 		}
 		/* In case a wakeup came while all threads were active */
 		jfs_commit_thread_waking = 0;
 		if (freezing(current)) {
 			LAZY_UNLOCK(flags);
 			refrigerator();
 		} else {
 			DECLARE_WAITQUEUE(wq, current);
 			add_wait_queue(&jfs_commit_thread_wait, &wq);
 			set_current_state(TASK_INTERRUPTIBLE);
 			LAZY_UNLOCK(flags);
 			schedule();
 			current->state = TASK_RUNNING;
 			remove_wait_queue(&jfs_commit_thread_wait, &wq);
 		}
 	} while (!jfs_stop_threads);
 	if (!list_empty(&TxAnchor.unlock_queue))
 		jfs_err("jfs_lazycommit being killed w/pending transactions!");
 	else
 		jfs_info("jfs_lazycommit being killed\n");
 	complete_and_exit(&jfsIOwait, 0);
 }
 void txLazyUnlock(struct tblock * tblk)
 {
 	unsigned long flags;
 	LAZY_LOCK(flags);
 	list_add_tail(&tblk->cqueue, &TxAnchor.unlock_queue);
 	/*
 	 * Don't wake up a commit thread if there is already one servicing
 	 * this superblock, or if the last one we woke up hasn't started yet.
 	 */
 	if (!(JFS_SBI(tblk->sb)->commit_state & IN_LAZYCOMMIT) &&
 	    !jfs_commit_thread_waking) {
 		jfs_commit_thread_waking = 1;
 		wake_up(&jfs_commit_thread_wait);
 	}
 	LAZY_UNLOCK(flags);
 }
 static void LogSyncRelease(struct metapage * mp)
 {
 	struct jfs_log *log = mp->log;
 	assert(mp->nohomeok);
 	assert(log);
 	metapage_homeok(mp);
 }
 /*
  *	txQuiesce
  *
  *	Block all new transactions and push anonymous transactions to
  *	completion
  *
  *	This does almost the same thing as jfs_sync below.  We don't
  *	worry about deadlocking when jfs_tlocks_low is set, since we would
  *	expect jfs_sync to get us out of that jam.
  */
 void txQuiesce(struct super_block *sb)
 {
 	struct inode *ip;
 	struct jfs_inode_info *jfs_ip;
 	struct jfs_log *log = JFS_SBI(sb)->log;
 	tid_t tid;
 	set_bit(log_QUIESCE, &log->flag);
 	TXN_LOCK();
 restart:
 	while (!list_empty(&TxAnchor.anon_list)) {
 		jfs_ip = list_entry(TxAnchor.anon_list.next,
 				    struct jfs_inode_info,
 				    anon_inode_list);
 		ip = &jfs_ip->vfs_inode;
 		/*
 		 * inode will be removed from anonymous list
 		 * when it is committed
 		 */
 		TXN_UNLOCK();
 		tid = txBegin(ip->i_sb, COMMIT_INODE | COMMIT_FORCE);
 		down(&jfs_ip->commit_sem);
 		txCommit(tid, 1, &ip, 0);
 		txEnd(tid);
 		up(&jfs_ip->commit_sem);
 		/*
 		 * Just to be safe.  I don't know how
 		 * long we can run without blocking
 		 */
 		cond_resched();
 		TXN_LOCK();
 	}
 	/*
 	 * If jfs_sync is running in parallel, there could be some inodes
 	 * on anon_list2.  Let's check.
 	 */
 	if (!list_empty(&TxAnchor.anon_list2)) {
 		list_splice(&TxAnchor.anon_list2, &TxAnchor.anon_list);
 		INIT_LIST_HEAD(&TxAnchor.anon_list2);
 		goto restart;
 	}
 	TXN_UNLOCK();
 	/*
 	 * We may need to kick off the group commit
 	 */
 	jfs_flush_journal(log, 0);
 }
 /*
  * txResume()
  *
  * Allows transactions to start again following txQuiesce
  */
 void txResume(struct super_block *sb)
 {
 	struct jfs_log *log = JFS_SBI(sb)->log;
 	clear_bit(log_QUIESCE, &log->flag);
 	TXN_WAKEUP(&log->syncwait);
 }
 /*
  *      jfs_sync(void)
  *
  *	To be run as a kernel daemon.  This is awakened when tlocks run low.
  *	We write any inodes that have anonymous tlocks so they will become
  *	available.
  */
 int jfs_sync(void *arg)
 {
 	struct inode *ip;
 	struct jfs_inode_info *jfs_ip;
 	int rc;
 	tid_t tid;
 	daemonize("jfsSync");
 	complete(&jfsIOwait);
 	do {
 		/*
 		 * write each inode on the anonymous inode list
 		 */
 		TXN_LOCK();
 		while (jfs_tlocks_low && !list_empty(&TxAnchor.anon_list)) {
 			jfs_ip = list_entry(TxAnchor.anon_list.next,
 					    struct jfs_inode_info,
 					    anon_inode_list);
 			ip = &jfs_ip->vfs_inode;
 			if (! igrab(ip)) {
 				/*
 				 * Inode is being freed
 				 */
 				list_del_init(&jfs_ip->anon_inode_list);
 			} else if (! down_trylock(&jfs_ip->commit_sem)) {
 				/*
 				 * inode will be removed from anonymous list
 				 * when it is committed
 				 */
 				TXN_UNLOCK();
 				tid = txBegin(ip->i_sb, COMMIT_INODE);
 				rc = txCommit(tid, 1, &ip, 0);
 				txEnd(tid);
 				up(&jfs_ip->commit_sem);
 				iput(ip);
 				/*
 				 * Just to be safe.  I don't know how
 				 * long we can run without blocking
 				 */
 				cond_resched();
 				TXN_LOCK();
 			} else {
 				/* We can't get the commit semaphore.  It may
 				 * be held by a thread waiting for tlock's
 				 * so let's not block here.  Save it to
 				 * put back on the anon_list.
 				 */
 				/* Take off anon_list */
 				list_del(&jfs_ip->anon_inode_list);
 				/* Put on anon_list2 */
 				list_add(&jfs_ip->anon_inode_list,
 					 &TxAnchor.anon_list2);
 				TXN_UNLOCK();
 				iput(ip);
 				TXN_LOCK();
 			}
 		}
 		/* Add anon_list2 back to anon_list */
 		list_splice_init(&TxAnchor.anon_list2, &TxAnchor.anon_list);
 		if (freezing(current)) {
 			TXN_UNLOCK();
 			refrigerator();
 		} else {
 			DECLARE_WAITQUEUE(wq, current);
 			add_wait_queue(&jfs_sync_thread_wait, &wq);
 			set_current_state(TASK_INTERRUPTIBLE);
 			TXN_UNLOCK();
 			schedule();
 			current->state = TASK_RUNNING;
 			remove_wait_queue(&jfs_sync_thread_wait, &wq);
 		}
 	} while (!jfs_stop_threads);
 	jfs_info("jfs_sync being killed");
 	complete_and_exit(&jfsIOwait, 0);
 }
 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_DEBUG)
 int jfs_txanchor_read(char *buffer, char **start, off_t offset, int length,
 		      int *eof, void *data)
 {
 	int len = 0;
 	off_t begin;
 	char *freewait;
 	char *freelockwait;
 	char *lowlockwait;
 	freewait =
 	    waitqueue_active(&TxAnchor.freewait) ? "active" : "empty";
 	freelockwait =
 	    waitqueue_active(&TxAnchor.freelockwait) ? "active" : "empty";
 	lowlockwait =
 	    waitqueue_active(&TxAnchor.lowlockwait) ? "active" : "empty";
 	len += sprintf(buffer,
 		       "JFS TxAnchor\n"
 		       "============\n"
 		       "freetid = %d\n"
 		       "freewait = %s\n"
 		       "freelock = %d\n"
 		       "freelockwait = %s\n"
 		       "lowlockwait = %s\n"
 		       "tlocksInUse = %d\n"
 		       "jfs_tlocks_low = %d\n"
 		       "unlock_queue is %sempty\n",
 		       TxAnchor.freetid,
 		       freewait,
 		       TxAnchor.freelock,
 		       freelockwait,
 		       lowlockwait,
 		       TxAnchor.tlocksInUse,
 		       jfs_tlocks_low,
 		       list_empty(&TxAnchor.unlock_queue) ? "" : "not ");
 	begin = offset;
 	*start = buffer + begin;
 	len -= begin;
 	if (len > length)
 		len = length;
 	else
 		*eof = 1;
 	if (len < 0)
 		len = 0;
 	return len;
 }
 #endif
 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_STATISTICS)
 int jfs_txstats_read(char *buffer, char **start, off_t offset, int length,
 		     int *eof, void *data)
 {
 	int len = 0;
 	off_t begin;
 	len += sprintf(buffer,
 		       "JFS TxStats\n"
 		       "===========\n"
 		       "calls to txBegin = %d\n"
 		       "txBegin blocked by sync barrier = %d\n"
 		       "txBegin blocked by tlocks low = %d\n"
 		       "txBegin blocked by no free tid = %d\n"
 		       "calls to txBeginAnon = %d\n"
 		       "txBeginAnon blocked by sync barrier = %d\n"
 		       "txBeginAnon blocked by tlocks low = %d\n"
 		       "calls to txLockAlloc = %d\n"
 		       "tLockAlloc blocked by no free lock = %d\n",
 		       TxStat.txBegin,
 		       TxStat.txBegin_barrier,
 		       TxStat.txBegin_lockslow,
 		       TxStat.txBegin_freetid,
 		       TxStat.txBeginAnon,
 		       TxStat.txBeginAnon_barrier,
 		       TxStat.txBeginAnon_lockslow,
 		       TxStat.txLockAlloc,
 		       TxStat.txLockAlloc_freelock);
 	begin = offset;
 	*start = buffer + begin;
 	len -= begin;
 	if (len > length)
 		len = length;
 	else
 		*eof = 1;
 	if (len < 0)
 		len = 0;

fs/jfs/super.c

Diff comments View file @ cbc3d65

1	/*	1	/*
2	* Copyright (C) International Business Machines Corp., 2000-2004	2	* Copyright (C) International Business Machines Corp., 2000-2004
3	* Portions Copyright (C) Christoph Hellwig, 2001-2002	3	* Portions Copyright (C) Christoph Hellwig, 2001-2002
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13	* the GNU General Public License for more details.	13	* the GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/	18	*/
19		19
20	#include <linux/fs.h>	20	#include <linux/fs.h>
21	#include <linux/config.h>	21	#include <linux/config.h>
22	#include <linux/module.h>	22	#include <linux/module.h>
23	#include <linux/parser.h>	23	#include <linux/parser.h>
24	#include <linux/completion.h>	24	#include <linux/completion.h>
25	#include <linux/vfs.h>	25	#include <linux/vfs.h>
26	#include <linux/moduleparam.h>	26	#include <linux/moduleparam.h>
27	#include <linux/posix_acl.h>	27	#include <linux/posix_acl.h>
28	#include <asm/uaccess.h>	28	#include <asm/uaccess.h>
29		29
30	#include "jfs_incore.h"	30	#include "jfs_incore.h"
31	#include "jfs_filsys.h"	31	#include "jfs_filsys.h"
32	#include "jfs_inode.h"	32	#include "jfs_inode.h"
33	#include "jfs_metapage.h"	33	#include "jfs_metapage.h"
34	#include "jfs_superblock.h"	34	#include "jfs_superblock.h"
35	#include "jfs_dmap.h"	35	#include "jfs_dmap.h"
36	#include "jfs_imap.h"	36	#include "jfs_imap.h"
37	#include "jfs_acl.h"	37	#include "jfs_acl.h"
38	#include "jfs_debug.h"	38	#include "jfs_debug.h"
39		39
40	MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");	40	MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
41	MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");	41	MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
42	MODULE_LICENSE("GPL");	42	MODULE_LICENSE("GPL");
43		43
44	static kmem_cache_t * jfs_inode_cachep;	44	static kmem_cache_t * jfs_inode_cachep;
45		45
46	static struct super_operations jfs_super_operations;	46	static struct super_operations jfs_super_operations;
47	static struct export_operations jfs_export_operations;	47	static struct export_operations jfs_export_operations;
48	static struct file_system_type jfs_fs_type;	48	static struct file_system_type jfs_fs_type;
49		49
50	#define MAX_COMMIT_THREADS 64	50	#define MAX_COMMIT_THREADS 64
51	static int commit_threads = 0;	51	static int commit_threads = 0;
52	module_param(commit_threads, int, 0);	52	module_param(commit_threads, int, 0);
53	MODULE_PARM_DESC(commit_threads, "Number of commit threads");	53	MODULE_PARM_DESC(commit_threads, "Number of commit threads");
54		54
55	int jfs_stop_threads;	55	int jfs_stop_threads;
56	static pid_t jfsIOthread;	56	static pid_t jfsIOthread;
57	static pid_t jfsCommitThread[MAX_COMMIT_THREADS];	57	static pid_t jfsCommitThread[MAX_COMMIT_THREADS];
58	static pid_t jfsSyncThread;	58	static pid_t jfsSyncThread;
59	DECLARE_COMPLETION(jfsIOwait);	59	DECLARE_COMPLETION(jfsIOwait);
60		60
61	#ifdef CONFIG_JFS_DEBUG	61	#ifdef CONFIG_JFS_DEBUG
62	int jfsloglevel = JFS_LOGLEVEL_WARN;	62	int jfsloglevel = JFS_LOGLEVEL_WARN;
63	module_param(jfsloglevel, int, 0644);	63	module_param(jfsloglevel, int, 0644);
64	MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");	64	MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");
65	#endif	65	#endif
66		66
67	static void jfs_handle_error(struct super_block *sb)	67	static void jfs_handle_error(struct super_block *sb)
68	{	68	{
69	struct jfs_sb_info *sbi = JFS_SBI(sb);	69	struct jfs_sb_info *sbi = JFS_SBI(sb);
70		70
71	if (sb->s_flags & MS_RDONLY)	71	if (sb->s_flags & MS_RDONLY)
72	return;	72	return;
73		73
74	updateSuper(sb, FM_DIRTY);	74	updateSuper(sb, FM_DIRTY);
75		75
76	if (sbi->flag & JFS_ERR_PANIC)	76	if (sbi->flag & JFS_ERR_PANIC)
77	panic("JFS (device %s): panic forced after error\n",	77	panic("JFS (device %s): panic forced after error\n",
78	sb->s_id);	78	sb->s_id);
79	else if (sbi->flag & JFS_ERR_REMOUNT_RO) {	79	else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
80	jfs_err("ERROR: (device %s): remounting filesystem "	80	jfs_err("ERROR: (device %s): remounting filesystem "
81	"as read-only\n",	81	"as read-only\n",
82	sb->s_id);	82	sb->s_id);
83	sb->s_flags \|= MS_RDONLY;	83	sb->s_flags \|= MS_RDONLY;
84	}	84	}
85		85
86	/* nothing is done for continue beyond marking the superblock dirty */	86	/* nothing is done for continue beyond marking the superblock dirty */
87	}	87	}
88		88
89	void jfs_error(struct super_block sb, const char function, ...)	89	void jfs_error(struct super_block sb, const char function, ...)
90	{	90	{
91	static char error_buf[256];	91	static char error_buf[256];
92	va_list args;	92	va_list args;
93		93
94	va_start(args, function);	94	va_start(args, function);
95	vsprintf(error_buf, function, args);	95	vsprintf(error_buf, function, args);
96	va_end(args);	96	va_end(args);
97		97
98	printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);	98	printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);
99		99
100	jfs_handle_error(sb);	100	jfs_handle_error(sb);
101	}	101	}
102		102
103	static struct inode jfs_alloc_inode(struct super_block sb)	103	static struct inode jfs_alloc_inode(struct super_block sb)
104	{	104	{
105	struct jfs_inode_info *jfs_inode;	105	struct jfs_inode_info *jfs_inode;
106		106
107	jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);	107	jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
108	if (!jfs_inode)	108	if (!jfs_inode)
109	return NULL;	109	return NULL;
110	return &jfs_inode->vfs_inode;	110	return &jfs_inode->vfs_inode;
111	}	111	}
112		112
113	static void jfs_destroy_inode(struct inode *inode)	113	static void jfs_destroy_inode(struct inode *inode)
114	{	114	{
115	struct jfs_inode_info *ji = JFS_IP(inode);	115	struct jfs_inode_info *ji = JFS_IP(inode);
116		116
117	spin_lock_irq(&ji->ag_lock);	117	spin_lock_irq(&ji->ag_lock);
118	if (ji->active_ag != -1) {	118	if (ji->active_ag != -1) {
119	struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;	119	struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
120	atomic_dec(&bmap->db_active[ji->active_ag]);	120	atomic_dec(&bmap->db_active[ji->active_ag]);
121	ji->active_ag = -1;	121	ji->active_ag = -1;
122	}	122	}
123	spin_unlock_irq(&ji->ag_lock);	123	spin_unlock_irq(&ji->ag_lock);
124		124
125	#ifdef CONFIG_JFS_POSIX_ACL	125	#ifdef CONFIG_JFS_POSIX_ACL
126	if (ji->i_acl != JFS_ACL_NOT_CACHED) {	126	if (ji->i_acl != JFS_ACL_NOT_CACHED) {
127	posix_acl_release(ji->i_acl);	127	posix_acl_release(ji->i_acl);
128	ji->i_acl = JFS_ACL_NOT_CACHED;	128	ji->i_acl = JFS_ACL_NOT_CACHED;
129	}	129	}
130	if (ji->i_default_acl != JFS_ACL_NOT_CACHED) {	130	if (ji->i_default_acl != JFS_ACL_NOT_CACHED) {
131	posix_acl_release(ji->i_default_acl);	131	posix_acl_release(ji->i_default_acl);
132	ji->i_default_acl = JFS_ACL_NOT_CACHED;	132	ji->i_default_acl = JFS_ACL_NOT_CACHED;
133	}	133	}
134	#endif	134	#endif
135		135
136	kmem_cache_free(jfs_inode_cachep, ji);	136	kmem_cache_free(jfs_inode_cachep, ji);
137	}	137	}
138		138
139	static int jfs_statfs(struct super_block sb, struct kstatfs buf)	139	static int jfs_statfs(struct super_block sb, struct kstatfs buf)
140	{	140	{
141	struct jfs_sb_info *sbi = JFS_SBI(sb);	141	struct jfs_sb_info *sbi = JFS_SBI(sb);
142	s64 maxinodes;	142	s64 maxinodes;
143	struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;	143	struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
144		144
145	jfs_info("In jfs_statfs");	145	jfs_info("In jfs_statfs");
146	buf->f_type = JFS_SUPER_MAGIC;	146	buf->f_type = JFS_SUPER_MAGIC;
147	buf->f_bsize = sbi->bsize;	147	buf->f_bsize = sbi->bsize;
148	buf->f_blocks = sbi->bmap->db_mapsize;	148	buf->f_blocks = sbi->bmap->db_mapsize;
149	buf->f_bfree = sbi->bmap->db_nfree;	149	buf->f_bfree = sbi->bmap->db_nfree;
150	buf->f_bavail = sbi->bmap->db_nfree;	150	buf->f_bavail = sbi->bmap->db_nfree;
151	/*	151	/*
152	* If we really return the number of allocated & free inodes, some	152	* If we really return the number of allocated & free inodes, some
153	* applications will fail because they won't see enough free inodes.	153	* applications will fail because they won't see enough free inodes.
154	* We'll try to calculate some guess as to how may inodes we can	154	* We'll try to calculate some guess as to how may inodes we can
155	* really allocate	155	* really allocate
156	*	156	*
157	* buf->f_files = atomic_read(&imap->im_numinos);	157	* buf->f_files = atomic_read(&imap->im_numinos);
158	* buf->f_ffree = atomic_read(&imap->im_numfree);	158	* buf->f_ffree = atomic_read(&imap->im_numfree);
159	*/	159	*/
160	maxinodes = min((s64) atomic_read(&imap->im_numinos) +	160	maxinodes = min((s64) atomic_read(&imap->im_numinos) +
161	((sbi->bmap->db_nfree >> imap->im_l2nbperiext)	161	((sbi->bmap->db_nfree >> imap->im_l2nbperiext)
162	<< L2INOSPEREXT), (s64) 0xffffffffLL);	162	<< L2INOSPEREXT), (s64) 0xffffffffLL);
163	buf->f_files = maxinodes;	163	buf->f_files = maxinodes;
164	buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -	164	buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
165	atomic_read(&imap->im_numfree));	165	atomic_read(&imap->im_numfree));
166		166
167	buf->f_namelen = JFS_NAME_MAX;	167	buf->f_namelen = JFS_NAME_MAX;
168	return 0;	168	return 0;
169	}	169	}
170		170
171	static void jfs_put_super(struct super_block *sb)	171	static void jfs_put_super(struct super_block *sb)
172	{	172	{
173	struct jfs_sb_info *sbi = JFS_SBI(sb);	173	struct jfs_sb_info *sbi = JFS_SBI(sb);
174	int rc;	174	int rc;
175		175
176	jfs_info("In jfs_put_super");	176	jfs_info("In jfs_put_super");
177	rc = jfs_umount(sb);	177	rc = jfs_umount(sb);
178	if (rc)	178	if (rc)
179	jfs_err("jfs_umount failed with return code %d", rc);	179	jfs_err("jfs_umount failed with return code %d", rc);
180	if (sbi->nls_tab)	180	if (sbi->nls_tab)
181	unload_nls(sbi->nls_tab);	181	unload_nls(sbi->nls_tab);
182	sbi->nls_tab = NULL;	182	sbi->nls_tab = NULL;
183		183
184	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);	184	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
185	iput(sbi->direct_inode);	185	iput(sbi->direct_inode);
186	sbi->direct_inode = NULL;	186	sbi->direct_inode = NULL;
187		187
188	kfree(sbi);	188	kfree(sbi);
189	}	189	}
190		190
191	enum {	191	enum {
192	Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,	192	Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,
193	Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err,	193	Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err,
194	};	194	};
195		195
196	static match_table_t tokens = {	196	static match_table_t tokens = {
197	{Opt_integrity, "integrity"},	197	{Opt_integrity, "integrity"},
198	{Opt_nointegrity, "nointegrity"},	198	{Opt_nointegrity, "nointegrity"},
199	{Opt_iocharset, "iocharset=%s"},	199	{Opt_iocharset, "iocharset=%s"},
200	{Opt_resize, "resize=%u"},	200	{Opt_resize, "resize=%u"},
201	{Opt_resize_nosize, "resize"},	201	{Opt_resize_nosize, "resize"},
202	{Opt_errors, "errors=%s"},	202	{Opt_errors, "errors=%s"},
203	{Opt_ignore, "noquota"},	203	{Opt_ignore, "noquota"},
204	{Opt_ignore, "quota"},	204	{Opt_ignore, "quota"},
205	{Opt_ignore, "usrquota"},	205	{Opt_ignore, "usrquota"},
206	{Opt_ignore, "grpquota"},	206	{Opt_ignore, "grpquota"},
207	{Opt_err, NULL}	207	{Opt_err, NULL}
208	};	208	};
209		209
210	static int parse_options(char options, struct super_block sb, s64 *newLVSize,	210	static int parse_options(char options, struct super_block sb, s64 *newLVSize,
211	int *flag)	211	int *flag)
212	{	212	{
213	void nls_map = (void )-1; /* -1: no change; NULL: none */	213	void nls_map = (void )-1; /* -1: no change; NULL: none */
214	char *p;	214	char *p;
215	struct jfs_sb_info *sbi = JFS_SBI(sb);	215	struct jfs_sb_info *sbi = JFS_SBI(sb);
216		216
217	*newLVSize = 0;	217	*newLVSize = 0;
218		218
219	if (!options)	219	if (!options)
220	return 1;	220	return 1;
221		221
222	while ((p = strsep(&options, ",")) != NULL) {	222	while ((p = strsep(&options, ",")) != NULL) {
223	substring_t args[MAX_OPT_ARGS];	223	substring_t args[MAX_OPT_ARGS];
224	int token;	224	int token;
225	if (!*p)	225	if (!*p)
226	continue;	226	continue;
227		227
228	token = match_token(p, tokens, args);	228	token = match_token(p, tokens, args);
229	switch (token) {	229	switch (token) {
230	case Opt_integrity:	230	case Opt_integrity:
231	*flag &= ~JFS_NOINTEGRITY;	231	*flag &= ~JFS_NOINTEGRITY;
232	break;	232	break;
233	case Opt_nointegrity:	233	case Opt_nointegrity:
234	*flag \|= JFS_NOINTEGRITY;	234	*flag \|= JFS_NOINTEGRITY;
235	break;	235	break;
236	case Opt_ignore:	236	case Opt_ignore:
237	/* Silently ignore the quota options */	237	/* Silently ignore the quota options */
238	/* Don't do anything ;-) */	238	/* Don't do anything ;-) */
239	break;	239	break;
240	case Opt_iocharset:	240	case Opt_iocharset:
241	if (nls_map && nls_map != (void *) -1)	241	if (nls_map && nls_map != (void *) -1)
242	unload_nls(nls_map);	242	unload_nls(nls_map);
243	if (!strcmp(args[0].from, "none"))	243	if (!strcmp(args[0].from, "none"))
244	nls_map = NULL;	244	nls_map = NULL;
245	else {	245	else {
246	nls_map = load_nls(args[0].from);	246	nls_map = load_nls(args[0].from);
247	if (!nls_map) {	247	if (!nls_map) {
248	printk(KERN_ERR	248	printk(KERN_ERR
249	"JFS: charset not found\n");	249	"JFS: charset not found\n");
250	goto cleanup;	250	goto cleanup;
251	}	251	}
252	}	252	}
253	break;	253	break;
254	case Opt_resize:	254	case Opt_resize:
255	{	255	{
256	char *resize = args[0].from;	256	char *resize = args[0].from;
257	*newLVSize = simple_strtoull(resize, &resize, 0);	257	*newLVSize = simple_strtoull(resize, &resize, 0);
258	break;	258	break;
259	}	259	}
260	case Opt_resize_nosize:	260	case Opt_resize_nosize:
261	{	261	{
262	*newLVSize = sb->s_bdev->bd_inode->i_size >>	262	*newLVSize = sb->s_bdev->bd_inode->i_size >>
263	sb->s_blocksize_bits;	263	sb->s_blocksize_bits;
264	if (*newLVSize == 0)	264	if (*newLVSize == 0)
265	printk(KERN_ERR	265	printk(KERN_ERR
266	"JFS: Cannot determine volume size\n");	266	"JFS: Cannot determine volume size\n");
267	break;	267	break;
268	}	268	}
269	case Opt_errors:	269	case Opt_errors:
270	{	270	{
271	char *errors = args[0].from;	271	char *errors = args[0].from;
272	if (!errors \|\| !*errors)	272	if (!errors \|\| !*errors)
273	goto cleanup;	273	goto cleanup;
274	if (!strcmp(errors, "continue")) {	274	if (!strcmp(errors, "continue")) {
275	*flag &= ~JFS_ERR_REMOUNT_RO;	275	*flag &= ~JFS_ERR_REMOUNT_RO;
276	*flag &= ~JFS_ERR_PANIC;	276	*flag &= ~JFS_ERR_PANIC;
277	*flag \|= JFS_ERR_CONTINUE;	277	*flag \|= JFS_ERR_CONTINUE;
278	} else if (!strcmp(errors, "remount-ro")) {	278	} else if (!strcmp(errors, "remount-ro")) {
279	*flag &= ~JFS_ERR_CONTINUE;	279	*flag &= ~JFS_ERR_CONTINUE;
280	*flag &= ~JFS_ERR_PANIC;	280	*flag &= ~JFS_ERR_PANIC;
281	*flag \|= JFS_ERR_REMOUNT_RO;	281	*flag \|= JFS_ERR_REMOUNT_RO;
282	} else if (!strcmp(errors, "panic")) {	282	} else if (!strcmp(errors, "panic")) {
283	*flag &= ~JFS_ERR_CONTINUE;	283	*flag &= ~JFS_ERR_CONTINUE;
284	*flag &= ~JFS_ERR_REMOUNT_RO;	284	*flag &= ~JFS_ERR_REMOUNT_RO;
285	*flag \|= JFS_ERR_PANIC;	285	*flag \|= JFS_ERR_PANIC;
286	} else {	286	} else {
287	printk(KERN_ERR	287	printk(KERN_ERR
288	"JFS: %s is an invalid error handler\n",	288	"JFS: %s is an invalid error handler\n",
289	errors);	289	errors);
290	goto cleanup;	290	goto cleanup;
291	}	291	}
292	break;	292	break;
293	}	293	}
294	default:	294	default:
295	printk("jfs: Unrecognized mount option \"%s\" "	295	printk("jfs: Unrecognized mount option \"%s\" "
296	" or missing value\n", p);	296	" or missing value\n", p);
297	goto cleanup;	297	goto cleanup;
298	}	298	}
299	}	299	}
300		300
301	if (nls_map != (void *) -1) {	301	if (nls_map != (void *) -1) {
302	/* Discard old (if remount) */	302	/* Discard old (if remount) */
303	if (sbi->nls_tab)	303	if (sbi->nls_tab)
304	unload_nls(sbi->nls_tab);	304	unload_nls(sbi->nls_tab);
305	sbi->nls_tab = nls_map;	305	sbi->nls_tab = nls_map;
306	}	306	}
307	return 1;	307	return 1;
308		308
309	cleanup:	309	cleanup:
310	if (nls_map && nls_map != (void *) -1)	310	if (nls_map && nls_map != (void *) -1)
311	unload_nls(nls_map);	311	unload_nls(nls_map);
312	return 0;	312	return 0;
313	}	313	}
314		314
315	static int jfs_remount(struct super_block sb, int flags, char *data)	315	static int jfs_remount(struct super_block sb, int flags, char *data)
316	{	316	{
317	s64 newLVSize = 0;	317	s64 newLVSize = 0;
318	int rc = 0;	318	int rc = 0;
319	int flag = JFS_SBI(sb)->flag;	319	int flag = JFS_SBI(sb)->flag;
320		320
321	if (!parse_options(data, sb, &newLVSize, &flag)) {	321	if (!parse_options(data, sb, &newLVSize, &flag)) {
322	return -EINVAL;	322	return -EINVAL;
323	}	323	}
324	if (newLVSize) {	324	if (newLVSize) {
325	if (sb->s_flags & MS_RDONLY) {	325	if (sb->s_flags & MS_RDONLY) {
326	printk(KERN_ERR	326	printk(KERN_ERR
327	"JFS: resize requires volume to be mounted read-write\n");	327	"JFS: resize requires volume to be mounted read-write\n");
328	return -EROFS;	328	return -EROFS;
329	}	329	}
330	rc = jfs_extendfs(sb, newLVSize, 0);	330	rc = jfs_extendfs(sb, newLVSize, 0);
331	if (rc)	331	if (rc)
332	return rc;	332	return rc;
333	}	333	}
334		334
335	if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {	335	if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
336	/*	336	/*
337	* Invalidate any previously read metadata. fsck may have	337	* Invalidate any previously read metadata. fsck may have
338	* changed the on-disk data since we mounted r/o	338	* changed the on-disk data since we mounted r/o
339	*/	339	*/
340	truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);	340	truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
341		341
342	JFS_SBI(sb)->flag = flag;	342	JFS_SBI(sb)->flag = flag;
343	return jfs_mount_rw(sb, 1);	343	return jfs_mount_rw(sb, 1);
344	}	344	}
345	if ((!(sb->s_flags & MS_RDONLY)) && (*flags & MS_RDONLY)) {	345	if ((!(sb->s_flags & MS_RDONLY)) && (*flags & MS_RDONLY)) {
346	rc = jfs_umount_rw(sb);	346	rc = jfs_umount_rw(sb);
347	JFS_SBI(sb)->flag = flag;	347	JFS_SBI(sb)->flag = flag;
348	return rc;	348	return rc;
349	}	349	}
350	if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))	350	if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
351	if (!(sb->s_flags & MS_RDONLY)) {	351	if (!(sb->s_flags & MS_RDONLY)) {
352	rc = jfs_umount_rw(sb);	352	rc = jfs_umount_rw(sb);
353	if (rc)	353	if (rc)
354	return rc;	354	return rc;
355	JFS_SBI(sb)->flag = flag;	355	JFS_SBI(sb)->flag = flag;
356	return jfs_mount_rw(sb, 1);	356	return jfs_mount_rw(sb, 1);
357	}	357	}
358	JFS_SBI(sb)->flag = flag;	358	JFS_SBI(sb)->flag = flag;
359		359
360	return 0;	360	return 0;
361	}	361	}
362		362
363	static int jfs_fill_super(struct super_block sb, void data, int silent)	363	static int jfs_fill_super(struct super_block sb, void data, int silent)
364	{	364	{
365	struct jfs_sb_info *sbi;	365	struct jfs_sb_info *sbi;
366	struct inode *inode;	366	struct inode *inode;
367	int rc;	367	int rc;
368	s64 newLVSize = 0;	368	s64 newLVSize = 0;
369	int flag;	369	int flag;
370		370
371	jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);	371	jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
372		372
373	if (!new_valid_dev(sb->s_bdev->bd_dev))	373	if (!new_valid_dev(sb->s_bdev->bd_dev))
374	return -EOVERFLOW;	374	return -EOVERFLOW;
375		375
376	sbi = kmalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);	376	sbi = kmalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
377	if (!sbi)	377	if (!sbi)
378	return -ENOSPC;	378	return -ENOSPC;
379	memset(sbi, 0, sizeof (struct jfs_sb_info));	379	memset(sbi, 0, sizeof (struct jfs_sb_info));
380	sb->s_fs_info = sbi;	380	sb->s_fs_info = sbi;
381	sbi->sb = sb;	381	sbi->sb = sb;
382		382
383	/* initialize the mount flag and determine the default error handler */	383	/* initialize the mount flag and determine the default error handler */
384	flag = JFS_ERR_REMOUNT_RO;	384	flag = JFS_ERR_REMOUNT_RO;
385		385
386	if (!parse_options((char *) data, sb, &newLVSize, &flag)) {	386	if (!parse_options((char *) data, sb, &newLVSize, &flag)) {
387	kfree(sbi);	387	kfree(sbi);
388	return -EINVAL;	388	return -EINVAL;
389	}	389	}
390	sbi->flag = flag;	390	sbi->flag = flag;
391		391
392	#ifdef CONFIG_JFS_POSIX_ACL	392	#ifdef CONFIG_JFS_POSIX_ACL
393	sb->s_flags \|= MS_POSIXACL;	393	sb->s_flags \|= MS_POSIXACL;
394	#endif	394	#endif
395		395
396	if (newLVSize) {	396	if (newLVSize) {
397	printk(KERN_ERR "resize option for remount only\n");	397	printk(KERN_ERR "resize option for remount only\n");
398	return -EINVAL;	398	return -EINVAL;
399	}	399	}
400		400
401	/*	401	/*
402	* Initialize blocksize to 4K.	402	* Initialize blocksize to 4K.
403	*/	403	*/
404	sb_set_blocksize(sb, PSIZE);	404	sb_set_blocksize(sb, PSIZE);
405		405
406	/*	406	/*
407	* Set method vectors.	407	* Set method vectors.
408	*/	408	*/
409	sb->s_op = &jfs_super_operations;	409	sb->s_op = &jfs_super_operations;
410	sb->s_export_op = &jfs_export_operations;	410	sb->s_export_op = &jfs_export_operations;
411		411
412	/*	412	/*
413	* Initialize direct-mapping inode/address-space	413	* Initialize direct-mapping inode/address-space
414	*/	414	*/
415	inode = new_inode(sb);	415	inode = new_inode(sb);
416	if (inode == NULL)	416	if (inode == NULL)
417	goto out_kfree;	417	goto out_kfree;
418	inode->i_ino = 0;	418	inode->i_ino = 0;
419	inode->i_nlink = 1;	419	inode->i_nlink = 1;
420	inode->i_size = sb->s_bdev->bd_inode->i_size;	420	inode->i_size = sb->s_bdev->bd_inode->i_size;
421	inode->i_mapping->a_ops = &jfs_metapage_aops;	421	inode->i_mapping->a_ops = &jfs_metapage_aops;
422	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);	422	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
423		423
424	sbi->direct_inode = inode;	424	sbi->direct_inode = inode;
425		425
426	rc = jfs_mount(sb);	426	rc = jfs_mount(sb);
427	if (rc) {	427	if (rc) {
428	if (!silent) {	428	if (!silent) {
429	jfs_err("jfs_mount failed w/return code = %d", rc);	429	jfs_err("jfs_mount failed w/return code = %d", rc);
430	}	430	}
431	goto out_mount_failed;	431	goto out_mount_failed;
432	}	432	}
433	if (sb->s_flags & MS_RDONLY)	433	if (sb->s_flags & MS_RDONLY)
434	sbi->log = NULL;	434	sbi->log = NULL;
435	else {	435	else {
436	rc = jfs_mount_rw(sb, 0);	436	rc = jfs_mount_rw(sb, 0);
437	if (rc) {	437	if (rc) {
438	if (!silent) {	438	if (!silent) {
439	jfs_err("jfs_mount_rw failed, return code = %d",	439	jfs_err("jfs_mount_rw failed, return code = %d",
440	rc);	440	rc);
441	}	441	}
442	goto out_no_rw;	442	goto out_no_rw;
443	}	443	}
444	}	444	}
445		445
446	sb->s_magic = JFS_SUPER_MAGIC;	446	sb->s_magic = JFS_SUPER_MAGIC;
447		447
448	inode = iget(sb, ROOT_I);	448	inode = iget(sb, ROOT_I);
449	if (!inode \|\| is_bad_inode(inode))	449	if (!inode \|\| is_bad_inode(inode))
450	goto out_no_root;	450	goto out_no_root;
451	sb->s_root = d_alloc_root(inode);	451	sb->s_root = d_alloc_root(inode);
452	if (!sb->s_root)	452	if (!sb->s_root)
453	goto out_no_root;	453	goto out_no_root;
454		454
455	if (sbi->mntflag & JFS_OS2)	455	if (sbi->mntflag & JFS_OS2)
456	sb->s_root->d_op = &jfs_ci_dentry_operations;	456	sb->s_root->d_op = &jfs_ci_dentry_operations;
457		457
458	/* logical blocks are represented by 40 bits in pxd_t, etc. */	458	/* logical blocks are represented by 40 bits in pxd_t, etc. */
459	sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;	459	sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;
460	#if BITS_PER_LONG == 32	460	#if BITS_PER_LONG == 32
461	/*	461	/*
462	* Page cache is indexed by long.	462	* Page cache is indexed by long.
463	* I would use MAX_LFS_FILESIZE, but it's only half as big	463	* I would use MAX_LFS_FILESIZE, but it's only half as big
464	*/	464	*/
465	sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, sb->s_maxbytes);	465	sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, sb->s_maxbytes);
466	#endif	466	#endif
467	sb->s_time_gran = 1;	467	sb->s_time_gran = 1;
468	return 0;	468	return 0;
469		469
470	out_no_root:	470	out_no_root:
471	jfs_err("jfs_read_super: get root inode failed");	471	jfs_err("jfs_read_super: get root inode failed");
472	if (inode)	472	if (inode)
473	iput(inode);	473	iput(inode);
474		474
475	out_no_rw:	475	out_no_rw:
476	rc = jfs_umount(sb);	476	rc = jfs_umount(sb);
477	if (rc) {	477	if (rc) {
478	jfs_err("jfs_umount failed with return code %d", rc);	478	jfs_err("jfs_umount failed with return code %d", rc);
479	}	479	}
480	out_mount_failed:	480	out_mount_failed:
481	filemap_fdatawrite(sbi->direct_inode->i_mapping);	481	filemap_fdatawrite(sbi->direct_inode->i_mapping);
482	filemap_fdatawait(sbi->direct_inode->i_mapping);	482	filemap_fdatawait(sbi->direct_inode->i_mapping);
483	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);	483	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
484	make_bad_inode(sbi->direct_inode);	484	make_bad_inode(sbi->direct_inode);
485	iput(sbi->direct_inode);	485	iput(sbi->direct_inode);
486	sbi->direct_inode = NULL;	486	sbi->direct_inode = NULL;
487	out_kfree:	487	out_kfree:
488	if (sbi->nls_tab)	488	if (sbi->nls_tab)
489	unload_nls(sbi->nls_tab);	489	unload_nls(sbi->nls_tab);
490	kfree(sbi);	490	kfree(sbi);
491	return -EINVAL;	491	return -EINVAL;
492	}	492	}
493		493
494	static void jfs_write_super_lockfs(struct super_block *sb)	494	static void jfs_write_super_lockfs(struct super_block *sb)
495	{	495	{
496	struct jfs_sb_info *sbi = JFS_SBI(sb);	496	struct jfs_sb_info *sbi = JFS_SBI(sb);
497	struct jfs_log *log = sbi->log;	497	struct jfs_log *log = sbi->log;
498		498
499	if (!(sb->s_flags & MS_RDONLY)) {	499	if (!(sb->s_flags & MS_RDONLY)) {
500	txQuiesce(sb);	500	txQuiesce(sb);
501	lmLogShutdown(log);	501	lmLogShutdown(log);
502	updateSuper(sb, FM_CLEAN);	502	updateSuper(sb, FM_CLEAN);
503	}	503	}
504	}	504	}
505		505
506	static void jfs_unlockfs(struct super_block *sb)	506	static void jfs_unlockfs(struct super_block *sb)
507	{	507	{
508	struct jfs_sb_info *sbi = JFS_SBI(sb);	508	struct jfs_sb_info *sbi = JFS_SBI(sb);
509	struct jfs_log *log = sbi->log;	509	struct jfs_log *log = sbi->log;
510	int rc = 0;	510	int rc = 0;
511		511
512	if (!(sb->s_flags & MS_RDONLY)) {	512	if (!(sb->s_flags & MS_RDONLY)) {
513	updateSuper(sb, FM_MOUNT);	513	updateSuper(sb, FM_MOUNT);
514	if ((rc = lmLogInit(log)))	514	if ((rc = lmLogInit(log)))
515	jfs_err("jfs_unlock failed with return code %d", rc);	515	jfs_err("jfs_unlock failed with return code %d", rc);
516	else	516	else
517	txResume(sb);	517	txResume(sb);
518	}	518	}
519	}	519	}
520		520
521	static struct super_block jfs_get_sb(struct file_system_type fs_type,	521	static struct super_block jfs_get_sb(struct file_system_type fs_type,
522	int flags, const char dev_name, void data)	522	int flags, const char dev_name, void data)
523	{	523	{
524	return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super);	524	return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super);
525	}	525	}
526		526
527	static int jfs_sync_fs(struct super_block *sb, int wait)	527	static int jfs_sync_fs(struct super_block *sb, int wait)
528	{	528	{
529	struct jfs_log *log = JFS_SBI(sb)->log;	529	struct jfs_log *log = JFS_SBI(sb)->log;
530		530
531	/* log == NULL indicates read-only mount */	531	/* log == NULL indicates read-only mount */
532	if (log) {	532	if (log) {
533	jfs_flush_journal(log, wait);	533	jfs_flush_journal(log, wait);
534	jfs_syncpt(log);	534	jfs_syncpt(log, 0);
535	}	535	}
536		536
537	return 0;	537	return 0;
538	}	538	}
539		539
540	static struct super_operations jfs_super_operations = {	540	static struct super_operations jfs_super_operations = {
541	.alloc_inode = jfs_alloc_inode,	541	.alloc_inode = jfs_alloc_inode,
542	.destroy_inode = jfs_destroy_inode,	542	.destroy_inode = jfs_destroy_inode,
543	.read_inode = jfs_read_inode,	543	.read_inode = jfs_read_inode,
544	.dirty_inode = jfs_dirty_inode,	544	.dirty_inode = jfs_dirty_inode,
545	.write_inode = jfs_write_inode,	545	.write_inode = jfs_write_inode,
546	.delete_inode = jfs_delete_inode,	546	.delete_inode = jfs_delete_inode,
547	.put_super = jfs_put_super,	547	.put_super = jfs_put_super,
548	.sync_fs = jfs_sync_fs,	548	.sync_fs = jfs_sync_fs,
549	.write_super_lockfs = jfs_write_super_lockfs,	549	.write_super_lockfs = jfs_write_super_lockfs,
550	.unlockfs = jfs_unlockfs,	550	.unlockfs = jfs_unlockfs,
551	.statfs = jfs_statfs,	551	.statfs = jfs_statfs,
552	.remount_fs = jfs_remount,	552	.remount_fs = jfs_remount,
553	};	553	};
554		554
555	static struct export_operations jfs_export_operations = {	555	static struct export_operations jfs_export_operations = {
556	.get_parent = jfs_get_parent,	556	.get_parent = jfs_get_parent,
557	};	557	};
558		558
559	static struct file_system_type jfs_fs_type = {	559	static struct file_system_type jfs_fs_type = {
560	.owner = THIS_MODULE,	560	.owner = THIS_MODULE,
561	.name = "jfs",	561	.name = "jfs",
562	.get_sb = jfs_get_sb,	562	.get_sb = jfs_get_sb,
563	.kill_sb = kill_block_super,	563	.kill_sb = kill_block_super,
564	.fs_flags = FS_REQUIRES_DEV,	564	.fs_flags = FS_REQUIRES_DEV,
565	};	565	};
566		566
567	static void init_once(void foo, kmem_cache_t cachep, unsigned long flags)	567	static void init_once(void foo, kmem_cache_t cachep, unsigned long flags)
568	{	568	{
569	struct jfs_inode_info jfs_ip = (struct jfs_inode_info ) foo;	569	struct jfs_inode_info jfs_ip = (struct jfs_inode_info ) foo;
570		570
571	if ((flags & (SLAB_CTOR_VERIFY \| SLAB_CTOR_CONSTRUCTOR)) ==	571	if ((flags & (SLAB_CTOR_VERIFY \| SLAB_CTOR_CONSTRUCTOR)) ==
572	SLAB_CTOR_CONSTRUCTOR) {	572	SLAB_CTOR_CONSTRUCTOR) {
573	memset(jfs_ip, 0, sizeof(struct jfs_inode_info));	573	memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
574	INIT_LIST_HEAD(&jfs_ip->anon_inode_list);	574	INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
575	init_rwsem(&jfs_ip->rdwrlock);	575	init_rwsem(&jfs_ip->rdwrlock);
576	init_MUTEX(&jfs_ip->commit_sem);	576	init_MUTEX(&jfs_ip->commit_sem);
577	init_rwsem(&jfs_ip->xattr_sem);	577	init_rwsem(&jfs_ip->xattr_sem);
578	spin_lock_init(&jfs_ip->ag_lock);	578	spin_lock_init(&jfs_ip->ag_lock);
579	jfs_ip->active_ag = -1;	579	jfs_ip->active_ag = -1;
580	#ifdef CONFIG_JFS_POSIX_ACL	580	#ifdef CONFIG_JFS_POSIX_ACL
581	jfs_ip->i_acl = JFS_ACL_NOT_CACHED;	581	jfs_ip->i_acl = JFS_ACL_NOT_CACHED;
582	jfs_ip->i_default_acl = JFS_ACL_NOT_CACHED;	582	jfs_ip->i_default_acl = JFS_ACL_NOT_CACHED;
583	#endif	583	#endif
584	inode_init_once(&jfs_ip->vfs_inode);	584	inode_init_once(&jfs_ip->vfs_inode);
585	}	585	}
586	}	586	}
587		587
588	static int __init init_jfs_fs(void)	588	static int __init init_jfs_fs(void)
589	{	589	{
590	int i;	590	int i;
591	int rc;	591	int rc;
592		592
593	jfs_inode_cachep =	593	jfs_inode_cachep =
594	kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,	594	kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
595	SLAB_RECLAIM_ACCOUNT, init_once, NULL);	595	SLAB_RECLAIM_ACCOUNT, init_once, NULL);
596	if (jfs_inode_cachep == NULL)	596	if (jfs_inode_cachep == NULL)
597	return -ENOMEM;	597	return -ENOMEM;
598		598
599	/*	599	/*
600	* Metapage initialization	600	* Metapage initialization
601	*/	601	*/
602	rc = metapage_init();	602	rc = metapage_init();
603	if (rc) {	603	if (rc) {
604	jfs_err("metapage_init failed w/rc = %d", rc);	604	jfs_err("metapage_init failed w/rc = %d", rc);
605	goto free_slab;	605	goto free_slab;
606	}	606	}
607		607
608	/*	608	/*
609	* Transaction Manager initialization	609	* Transaction Manager initialization
610	*/	610	*/
611	rc = txInit();	611	rc = txInit();
612	if (rc) {	612	if (rc) {
613	jfs_err("txInit failed w/rc = %d", rc);	613	jfs_err("txInit failed w/rc = %d", rc);
614	goto free_metapage;	614	goto free_metapage;
615	}	615	}
616		616
617	/*	617	/*
618	* I/O completion thread (endio)	618	* I/O completion thread (endio)
619	*/	619	*/
620	jfsIOthread = kernel_thread(jfsIOWait, NULL, CLONE_KERNEL);	620	jfsIOthread = kernel_thread(jfsIOWait, NULL, CLONE_KERNEL);
621	if (jfsIOthread < 0) {	621	if (jfsIOthread < 0) {
622	jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread);	622	jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsIOthread);
623	goto end_txmngr;	623	goto end_txmngr;
624	}	624	}
625	wait_for_completion(&jfsIOwait); /* Wait until thread starts */	625	wait_for_completion(&jfsIOwait); /* Wait until thread starts */
626		626
627	if (commit_threads < 1)	627	if (commit_threads < 1)
628	commit_threads = num_online_cpus();	628	commit_threads = num_online_cpus();
629	if (commit_threads > MAX_COMMIT_THREADS)	629	if (commit_threads > MAX_COMMIT_THREADS)
630	commit_threads = MAX_COMMIT_THREADS;	630	commit_threads = MAX_COMMIT_THREADS;
631		631
632	for (i = 0; i < commit_threads; i++) {	632	for (i = 0; i < commit_threads; i++) {
633	jfsCommitThread[i] = kernel_thread(jfs_lazycommit, NULL,	633	jfsCommitThread[i] = kernel_thread(jfs_lazycommit, NULL,
634	CLONE_KERNEL);	634	CLONE_KERNEL);
635	if (jfsCommitThread[i] < 0) {	635	if (jfsCommitThread[i] < 0) {
636	jfs_err("init_jfs_fs: fork failed w/rc = %d",	636	jfs_err("init_jfs_fs: fork failed w/rc = %d",
637	jfsCommitThread[i]);	637	jfsCommitThread[i]);
638	commit_threads = i;	638	commit_threads = i;
639	goto kill_committask;	639	goto kill_committask;
640	}	640	}
641	/* Wait until thread starts */	641	/* Wait until thread starts */
642	wait_for_completion(&jfsIOwait);	642	wait_for_completion(&jfsIOwait);
643	}	643	}
644		644
645	jfsSyncThread = kernel_thread(jfs_sync, NULL, CLONE_KERNEL);	645	jfsSyncThread = kernel_thread(jfs_sync, NULL, CLONE_KERNEL);
646	if (jfsSyncThread < 0) {	646	if (jfsSyncThread < 0) {
647	jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread);	647	jfs_err("init_jfs_fs: fork failed w/rc = %d", jfsSyncThread);
648	goto kill_committask;	648	goto kill_committask;
649	}	649	}
650	wait_for_completion(&jfsIOwait); /* Wait until thread starts */	650	wait_for_completion(&jfsIOwait); /* Wait until thread starts */
651		651
652	#ifdef PROC_FS_JFS	652	#ifdef PROC_FS_JFS
653	jfs_proc_init();	653	jfs_proc_init();
654	#endif	654	#endif
655		655
656	return register_filesystem(&jfs_fs_type);	656	return register_filesystem(&jfs_fs_type);
657		657
658	kill_committask:	658	kill_committask:
659	jfs_stop_threads = 1;	659	jfs_stop_threads = 1;
660	wake_up_all(&jfs_commit_thread_wait);	660	wake_up_all(&jfs_commit_thread_wait);
661	for (i = 0; i < commit_threads; i++)	661	for (i = 0; i < commit_threads; i++)
662	wait_for_completion(&jfsIOwait);	662	wait_for_completion(&jfsIOwait);
663		663
664	wake_up(&jfs_IO_thread_wait);	664	wake_up(&jfs_IO_thread_wait);
665	wait_for_completion(&jfsIOwait); /* Wait for thread exit */	665	wait_for_completion(&jfsIOwait); /* Wait for thread exit */
666	end_txmngr:	666	end_txmngr:
667	txExit();	667	txExit();
668	free_metapage:	668	free_metapage:
669	metapage_exit();	669	metapage_exit();
670	free_slab:	670	free_slab:
671	kmem_cache_destroy(jfs_inode_cachep);	671	kmem_cache_destroy(jfs_inode_cachep);
672	return rc;	672	return rc;
673	}	673	}
674		674
675	static void __exit exit_jfs_fs(void)	675	static void __exit exit_jfs_fs(void)
676	{	676	{
677	int i;	677	int i;
678		678
679	jfs_info("exit_jfs_fs called");	679	jfs_info("exit_jfs_fs called");
680		680
681	jfs_stop_threads = 1;	681	jfs_stop_threads = 1;
682	txExit();	682	txExit();
683	metapage_exit();	683	metapage_exit();
684	wake_up(&jfs_IO_thread_wait);	684	wake_up(&jfs_IO_thread_wait);
685	wait_for_completion(&jfsIOwait); /* Wait until IO thread exits */	685	wait_for_completion(&jfsIOwait); /* Wait until IO thread exits */
686	wake_up_all(&jfs_commit_thread_wait);	686	wake_up_all(&jfs_commit_thread_wait);
687	for (i = 0; i < commit_threads; i++)	687	for (i = 0; i < commit_threads; i++)
688	wait_for_completion(&jfsIOwait);	688	wait_for_completion(&jfsIOwait);
689	wake_up(&jfs_sync_thread_wait);	689	wake_up(&jfs_sync_thread_wait);
690	wait_for_completion(&jfsIOwait); /* Wait until Sync thread exits */	690	wait_for_completion(&jfsIOwait); /* Wait until Sync thread exits */
691	#ifdef PROC_FS_JFS	691	#ifdef PROC_FS_JFS
692	jfs_proc_clean();	692	jfs_proc_clean();
693	#endif	693	#endif
694	unregister_filesystem(&jfs_fs_type);	694	unregister_filesystem(&jfs_fs_type);
695	kmem_cache_destroy(jfs_inode_cachep);	695	kmem_cache_destroy(jfs_inode_cachep);
696	}	696	}
697		697
698	module_init(init_jfs_fs)	698	module_init(init_jfs_fs)
699	module_exit(exit_jfs_fs)	699	module_exit(exit_jfs_fs)
700		700