xref: /openbmc/linux/fs/jfs/jfs_txnmgr.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /*
2  *   Copyright (C) International Business Machines Corp., 2000-2005
3  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
4  *
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
7  *   the Free Software Foundation; either version 2 of the License, or
8  *   (at your option) any later version.
9  *
10  *   This program is distributed in the hope that it will be useful,
11  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
13  *   the GNU General Public License for more details.
14  *
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
17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  */
19 
20 /*
21  *      jfs_txnmgr.c: transaction manager
22  *
23  * notes:
24  * transaction starts with txBegin() and ends with txCommit()
25  * or txAbort().
26  *
27  * tlock is acquired at the time of update;
28  * (obviate scan at commit time for xtree and dtree)
29  * tlock and mp points to each other;
30  * (no hashlist for mp -> tlock).
31  *
32  * special cases:
33  * tlock on in-memory inode:
34  * in-place tlock in the in-memory inode itself;
35  * converted to page lock by iWrite() at commit time.
36  *
37  * tlock during write()/mmap() under anonymous transaction (tid = 0):
38  * transferred (?) to transaction at commit time.
39  *
40  * use the page itself to update allocation maps
41  * (obviate intermediate replication of allocation/deallocation data)
42  * hold on to mp+lock thru update of maps
43  */
44 
45 #include <linux/fs.h>
46 #include <linux/vmalloc.h>
47 #include <linux/completion.h>
48 #include <linux/freezer.h>
49 #include <linux/module.h>
50 #include <linux/moduleparam.h>
51 #include <linux/kthread.h>
52 #include "jfs_incore.h"
53 #include "jfs_inode.h"
54 #include "jfs_filsys.h"
55 #include "jfs_metapage.h"
56 #include "jfs_dinode.h"
57 #include "jfs_imap.h"
58 #include "jfs_dmap.h"
59 #include "jfs_superblock.h"
60 #include "jfs_debug.h"
61 
62 /*
63  *      transaction management structures
64  */
65 static struct {
66 	int freetid;		/* index of a free tid structure */
67 	int freelock;		/* index first free lock word */
68 	wait_queue_head_t freewait;	/* eventlist of free tblock */
69 	wait_queue_head_t freelockwait;	/* eventlist of free tlock */
70 	wait_queue_head_t lowlockwait;	/* eventlist of ample tlocks */
71 	int tlocksInUse;	/* Number of tlocks in use */
72 	spinlock_t LazyLock;	/* synchronize sync_queue & unlock_queue */
73 /*	struct tblock *sync_queue; * Transactions waiting for data sync */
74 	struct list_head unlock_queue;	/* Txns waiting to be released */
75 	struct list_head anon_list;	/* inodes having anonymous txns */
76 	struct list_head anon_list2;	/* inodes having anonymous txns
77 					   that couldn't be sync'ed */
78 } TxAnchor;
79 
80 int jfs_tlocks_low;		/* Indicates low number of available tlocks */
81 
82 #ifdef CONFIG_JFS_STATISTICS
83 static struct {
84 	uint txBegin;
85 	uint txBegin_barrier;
86 	uint txBegin_lockslow;
87 	uint txBegin_freetid;
88 	uint txBeginAnon;
89 	uint txBeginAnon_barrier;
90 	uint txBeginAnon_lockslow;
91 	uint txLockAlloc;
92 	uint txLockAlloc_freelock;
93 } TxStat;
94 #endif
95 
96 static int nTxBlock = -1;	/* number of transaction blocks */
97 module_param(nTxBlock, int, 0);
98 MODULE_PARM_DESC(nTxBlock,
99 		 "Number of transaction blocks (max:65536)");
100 
101 static int nTxLock = -1;	/* number of transaction locks */
102 module_param(nTxLock, int, 0);
103 MODULE_PARM_DESC(nTxLock,
104 		 "Number of transaction locks (max:65536)");
105 
106 struct tblock *TxBlock;	        /* transaction block table */
107 static int TxLockLWM;		/* Low water mark for number of txLocks used */
108 static int TxLockHWM;		/* High water mark for number of txLocks used */
109 static int TxLockVHWM;		/* Very High water mark */
110 struct tlock *TxLock;           /* transaction lock table */
111 
112 /*
113  *      transaction management lock
114  */
115 static DEFINE_SPINLOCK(jfsTxnLock);
116 
117 #define TXN_LOCK()              spin_lock(&jfsTxnLock)
118 #define TXN_UNLOCK()            spin_unlock(&jfsTxnLock)
119 
120 #define LAZY_LOCK_INIT()	spin_lock_init(&TxAnchor.LazyLock);
121 #define LAZY_LOCK(flags)	spin_lock_irqsave(&TxAnchor.LazyLock, flags)
122 #define LAZY_UNLOCK(flags) spin_unlock_irqrestore(&TxAnchor.LazyLock, flags)
123 
124 static DECLARE_WAIT_QUEUE_HEAD(jfs_commit_thread_wait);
125 static int jfs_commit_thread_waking;
126 
127 /*
128  * Retry logic exist outside these macros to protect from spurrious wakeups.
129  */
130 static inline void TXN_SLEEP_DROP_LOCK(wait_queue_head_t * event)
131 {
132 	DECLARE_WAITQUEUE(wait, current);
133 
134 	add_wait_queue(event, &wait);
135 	set_current_state(TASK_UNINTERRUPTIBLE);
136 	TXN_UNLOCK();
137 	io_schedule();
138 	__set_current_state(TASK_RUNNING);
139 	remove_wait_queue(event, &wait);
140 }
141 
142 #define TXN_SLEEP(event)\
143 {\
144 	TXN_SLEEP_DROP_LOCK(event);\
145 	TXN_LOCK();\
146 }
147 
148 #define TXN_WAKEUP(event) wake_up_all(event)
149 
150 /*
151  *      statistics
152  */
153 static struct {
154 	tid_t maxtid;		/* 4: biggest tid ever used */
155 	lid_t maxlid;		/* 4: biggest lid ever used */
156 	int ntid;		/* 4: # of transactions performed */
157 	int nlid;		/* 4: # of tlocks acquired */
158 	int waitlock;		/* 4: # of tlock wait */
159 } stattx;
160 
161 /*
162  * forward references
163  */
164 static int diLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
165 		struct tlock * tlck, struct commit * cd);
166 static int dataLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
167 		struct tlock * tlck);
168 static void dtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
169 		struct tlock * tlck);
170 static void mapLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
171 		struct tlock * tlck);
172 static void txAllocPMap(struct inode *ip, struct maplock * maplock,
173 		struct tblock * tblk);
174 static void txForce(struct tblock * tblk);
175 static int txLog(struct jfs_log * log, struct tblock * tblk,
176 		struct commit * cd);
177 static void txUpdateMap(struct tblock * tblk);
178 static void txRelease(struct tblock * tblk);
179 static void xtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
180 	   struct tlock * tlck);
181 static void LogSyncRelease(struct metapage * mp);
182 
183 /*
184  *              transaction block/lock management
185  *              ---------------------------------
186  */
187 
188 /*
189  * Get a transaction lock from the free list.  If the number in use is
190  * greater than the high water mark, wake up the sync daemon.  This should
191  * free some anonymous transaction locks.  (TXN_LOCK must be held.)
192  */
193 static lid_t txLockAlloc(void)
194 {
195 	lid_t lid;
196 
197 	INCREMENT(TxStat.txLockAlloc);
198 	if (!TxAnchor.freelock) {
199 		INCREMENT(TxStat.txLockAlloc_freelock);
200 	}
201 
202 	while (!(lid = TxAnchor.freelock))
203 		TXN_SLEEP(&TxAnchor.freelockwait);
204 	TxAnchor.freelock = TxLock[lid].next;
205 	HIGHWATERMARK(stattx.maxlid, lid);
206 	if ((++TxAnchor.tlocksInUse > TxLockHWM) && (jfs_tlocks_low == 0)) {
207 		jfs_info("txLockAlloc tlocks low");
208 		jfs_tlocks_low = 1;
209 		wake_up_process(jfsSyncThread);
210 	}
211 
212 	return lid;
213 }
214 
215 static void txLockFree(lid_t lid)
216 {
217 	TxLock[lid].tid = 0;
218 	TxLock[lid].next = TxAnchor.freelock;
219 	TxAnchor.freelock = lid;
220 	TxAnchor.tlocksInUse--;
221 	if (jfs_tlocks_low && (TxAnchor.tlocksInUse < TxLockLWM)) {
222 		jfs_info("txLockFree jfs_tlocks_low no more");
223 		jfs_tlocks_low = 0;
224 		TXN_WAKEUP(&TxAnchor.lowlockwait);
225 	}
226 	TXN_WAKEUP(&TxAnchor.freelockwait);
227 }
228 
229 /*
230  * NAME:        txInit()
231  *
232  * FUNCTION:    initialize transaction management structures
233  *
234  * RETURN:
235  *
236  * serialization: single thread at jfs_init()
237  */
238 int txInit(void)
239 {
240 	int k, size;
241 	struct sysinfo si;
242 
243 	/* Set defaults for nTxLock and nTxBlock if unset */
244 
245 	if (nTxLock == -1) {
246 		if (nTxBlock == -1) {
247 			/* Base default on memory size */
248 			si_meminfo(&si);
249 			if (si.totalram > (256 * 1024)) /* 1 GB */
250 				nTxLock = 64 * 1024;
251 			else
252 				nTxLock = si.totalram >> 2;
253 		} else if (nTxBlock > (8 * 1024))
254 			nTxLock = 64 * 1024;
255 		else
256 			nTxLock = nTxBlock << 3;
257 	}
258 	if (nTxBlock == -1)
259 		nTxBlock = nTxLock >> 3;
260 
261 	/* Verify tunable parameters */
262 	if (nTxBlock < 16)
263 		nTxBlock = 16;	/* No one should set it this low */
264 	if (nTxBlock > 65536)
265 		nTxBlock = 65536;
266 	if (nTxLock < 256)
267 		nTxLock = 256;	/* No one should set it this low */
268 	if (nTxLock > 65536)
269 		nTxLock = 65536;
270 
271 	printk(KERN_INFO "JFS: nTxBlock = %d, nTxLock = %d\n",
272 	       nTxBlock, nTxLock);
273 	/*
274 	 * initialize transaction block (tblock) table
275 	 *
276 	 * transaction id (tid) = tblock index
277 	 * tid = 0 is reserved.
278 	 */
279 	TxLockLWM = (nTxLock * 4) / 10;
280 	TxLockHWM = (nTxLock * 7) / 10;
281 	TxLockVHWM = (nTxLock * 8) / 10;
282 
283 	size = sizeof(struct tblock) * nTxBlock;
284 	TxBlock = vmalloc(size);
285 	if (TxBlock == NULL)
286 		return -ENOMEM;
287 
288 	for (k = 1; k < nTxBlock - 1; k++) {
289 		TxBlock[k].next = k + 1;
290 		init_waitqueue_head(&TxBlock[k].gcwait);
291 		init_waitqueue_head(&TxBlock[k].waitor);
292 	}
293 	TxBlock[k].next = 0;
294 	init_waitqueue_head(&TxBlock[k].gcwait);
295 	init_waitqueue_head(&TxBlock[k].waitor);
296 
297 	TxAnchor.freetid = 1;
298 	init_waitqueue_head(&TxAnchor.freewait);
299 
300 	stattx.maxtid = 1;	/* statistics */
301 
302 	/*
303 	 * initialize transaction lock (tlock) table
304 	 *
305 	 * transaction lock id = tlock index
306 	 * tlock id = 0 is reserved.
307 	 */
308 	size = sizeof(struct tlock) * nTxLock;
309 	TxLock = vmalloc(size);
310 	if (TxLock == NULL) {
311 		vfree(TxBlock);
312 		return -ENOMEM;
313 	}
314 
315 	/* initialize tlock table */
316 	for (k = 1; k < nTxLock - 1; k++)
317 		TxLock[k].next = k + 1;
318 	TxLock[k].next = 0;
319 	init_waitqueue_head(&TxAnchor.freelockwait);
320 	init_waitqueue_head(&TxAnchor.lowlockwait);
321 
322 	TxAnchor.freelock = 1;
323 	TxAnchor.tlocksInUse = 0;
324 	INIT_LIST_HEAD(&TxAnchor.anon_list);
325 	INIT_LIST_HEAD(&TxAnchor.anon_list2);
326 
327 	LAZY_LOCK_INIT();
328 	INIT_LIST_HEAD(&TxAnchor.unlock_queue);
329 
330 	stattx.maxlid = 1;	/* statistics */
331 
332 	return 0;
333 }
334 
335 /*
336  * NAME:        txExit()
337  *
338  * FUNCTION:    clean up when module is unloaded
339  */
340 void txExit(void)
341 {
342 	vfree(TxLock);
343 	TxLock = NULL;
344 	vfree(TxBlock);
345 	TxBlock = NULL;
346 }
347 
348 /*
349  * NAME:        txBegin()
350  *
351  * FUNCTION:    start a transaction.
352  *
353  * PARAMETER:   sb	- superblock
354  *              flag	- force for nested tx;
355  *
356  * RETURN:	tid	- transaction id
357  *
358  * note: flag force allows to start tx for nested tx
359  * to prevent deadlock on logsync barrier;
360  */
361 tid_t txBegin(struct super_block *sb, int flag)
362 {
363 	tid_t t;
364 	struct tblock *tblk;
365 	struct jfs_log *log;
366 
367 	jfs_info("txBegin: flag = 0x%x", flag);
368 	log = JFS_SBI(sb)->log;
369 
370 	TXN_LOCK();
371 
372 	INCREMENT(TxStat.txBegin);
373 
374       retry:
375 	if (!(flag & COMMIT_FORCE)) {
376 		/*
377 		 * synchronize with logsync barrier
378 		 */
379 		if (test_bit(log_SYNCBARRIER, &log->flag) ||
380 		    test_bit(log_QUIESCE, &log->flag)) {
381 			INCREMENT(TxStat.txBegin_barrier);
382 			TXN_SLEEP(&log->syncwait);
383 			goto retry;
384 		}
385 	}
386 	if (flag == 0) {
387 		/*
388 		 * Don't begin transaction if we're getting starved for tlocks
389 		 * unless COMMIT_FORCE or COMMIT_INODE (which may ultimately
390 		 * free tlocks)
391 		 */
392 		if (TxAnchor.tlocksInUse > TxLockVHWM) {
393 			INCREMENT(TxStat.txBegin_lockslow);
394 			TXN_SLEEP(&TxAnchor.lowlockwait);
395 			goto retry;
396 		}
397 	}
398 
399 	/*
400 	 * allocate transaction id/block
401 	 */
402 	if ((t = TxAnchor.freetid) == 0) {
403 		jfs_info("txBegin: waiting for free tid");
404 		INCREMENT(TxStat.txBegin_freetid);
405 		TXN_SLEEP(&TxAnchor.freewait);
406 		goto retry;
407 	}
408 
409 	tblk = tid_to_tblock(t);
410 
411 	if ((tblk->next == 0) && !(flag & COMMIT_FORCE)) {
412 		/* Don't let a non-forced transaction take the last tblk */
413 		jfs_info("txBegin: waiting for free tid");
414 		INCREMENT(TxStat.txBegin_freetid);
415 		TXN_SLEEP(&TxAnchor.freewait);
416 		goto retry;
417 	}
418 
419 	TxAnchor.freetid = tblk->next;
420 
421 	/*
422 	 * initialize transaction
423 	 */
424 
425 	/*
426 	 * We can't zero the whole thing or we screw up another thread being
427 	 * awakened after sleeping on tblk->waitor
428 	 *
429 	 * memset(tblk, 0, sizeof(struct tblock));
430 	 */
431 	tblk->next = tblk->last = tblk->xflag = tblk->flag = tblk->lsn = 0;
432 
433 	tblk->sb = sb;
434 	++log->logtid;
435 	tblk->logtid = log->logtid;
436 
437 	++log->active;
438 
439 	HIGHWATERMARK(stattx.maxtid, t);	/* statistics */
440 	INCREMENT(stattx.ntid);	/* statistics */
441 
442 	TXN_UNLOCK();
443 
444 	jfs_info("txBegin: returning tid = %d", t);
445 
446 	return t;
447 }
448 
449 /*
450  * NAME:        txBeginAnon()
451  *
452  * FUNCTION:    start an anonymous transaction.
453  *		Blocks if logsync or available tlocks are low to prevent
454  *		anonymous tlocks from depleting supply.
455  *
456  * PARAMETER:   sb	- superblock
457  *
458  * RETURN:	none
459  */
460 void txBeginAnon(struct super_block *sb)
461 {
462 	struct jfs_log *log;
463 
464 	log = JFS_SBI(sb)->log;
465 
466 	TXN_LOCK();
467 	INCREMENT(TxStat.txBeginAnon);
468 
469       retry:
470 	/*
471 	 * synchronize with logsync barrier
472 	 */
473 	if (test_bit(log_SYNCBARRIER, &log->flag) ||
474 	    test_bit(log_QUIESCE, &log->flag)) {
475 		INCREMENT(TxStat.txBeginAnon_barrier);
476 		TXN_SLEEP(&log->syncwait);
477 		goto retry;
478 	}
479 
480 	/*
481 	 * Don't begin transaction if we're getting starved for tlocks
482 	 */
483 	if (TxAnchor.tlocksInUse > TxLockVHWM) {
484 		INCREMENT(TxStat.txBeginAnon_lockslow);
485 		TXN_SLEEP(&TxAnchor.lowlockwait);
486 		goto retry;
487 	}
488 	TXN_UNLOCK();
489 }
490 
491 /*
492  *      txEnd()
493  *
494  * function: free specified transaction block.
495  *
496  *      logsync barrier processing:
497  *
498  * serialization:
499  */
500 void txEnd(tid_t tid)
501 {
502 	struct tblock *tblk = tid_to_tblock(tid);
503 	struct jfs_log *log;
504 
505 	jfs_info("txEnd: tid = %d", tid);
506 	TXN_LOCK();
507 
508 	/*
509 	 * wakeup transactions waiting on the page locked
510 	 * by the current transaction
511 	 */
512 	TXN_WAKEUP(&tblk->waitor);
513 
514 	log = JFS_SBI(tblk->sb)->log;
515 
516 	/*
517 	 * Lazy commit thread can't free this guy until we mark it UNLOCKED,
518 	 * otherwise, we would be left with a transaction that may have been
519 	 * reused.
520 	 *
521 	 * Lazy commit thread will turn off tblkGC_LAZY before calling this
522 	 * routine.
523 	 */
524 	if (tblk->flag & tblkGC_LAZY) {
525 		jfs_info("txEnd called w/lazy tid: %d, tblk = 0x%p", tid, tblk);
526 		TXN_UNLOCK();
527 
528 		spin_lock_irq(&log->gclock);	// LOGGC_LOCK
529 		tblk->flag |= tblkGC_UNLOCKED;
530 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
531 		return;
532 	}
533 
534 	jfs_info("txEnd: tid: %d, tblk = 0x%p", tid, tblk);
535 
536 	assert(tblk->next == 0);
537 
538 	/*
539 	 * insert tblock back on freelist
540 	 */
541 	tblk->next = TxAnchor.freetid;
542 	TxAnchor.freetid = tid;
543 
544 	/*
545 	 * mark the tblock not active
546 	 */
547 	if (--log->active == 0) {
548 		clear_bit(log_FLUSH, &log->flag);
549 
550 		/*
551 		 * synchronize with logsync barrier
552 		 */
553 		if (test_bit(log_SYNCBARRIER, &log->flag)) {
554 			TXN_UNLOCK();
555 
556 			/* write dirty metadata & forward log syncpt */
557 			jfs_syncpt(log, 1);
558 
559 			jfs_info("log barrier off: 0x%x", log->lsn);
560 
561 			/* enable new transactions start */
562 			clear_bit(log_SYNCBARRIER, &log->flag);
563 
564 			/* wakeup all waitors for logsync barrier */
565 			TXN_WAKEUP(&log->syncwait);
566 
567 			goto wakeup;
568 		}
569 	}
570 
571 	TXN_UNLOCK();
572 wakeup:
573 	/*
574 	 * wakeup all waitors for a free tblock
575 	 */
576 	TXN_WAKEUP(&TxAnchor.freewait);
577 }
578 
579 /*
580  *      txLock()
581  *
582  * function: acquire a transaction lock on the specified <mp>
583  *
584  * parameter:
585  *
586  * return:      transaction lock id
587  *
588  * serialization:
589  */
590 struct tlock *txLock(tid_t tid, struct inode *ip, struct metapage * mp,
591 		     int type)
592 {
593 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
594 	int dir_xtree = 0;
595 	lid_t lid;
596 	tid_t xtid;
597 	struct tlock *tlck;
598 	struct xtlock *xtlck;
599 	struct linelock *linelock;
600 	xtpage_t *p;
601 	struct tblock *tblk;
602 
603 	TXN_LOCK();
604 
605 	if (S_ISDIR(ip->i_mode) && (type & tlckXTREE) &&
606 	    !(mp->xflag & COMMIT_PAGE)) {
607 		/*
608 		 * Directory inode is special.  It can have both an xtree tlock
609 		 * and a dtree tlock associated with it.
610 		 */
611 		dir_xtree = 1;
612 		lid = jfs_ip->xtlid;
613 	} else
614 		lid = mp->lid;
615 
616 	/* is page not locked by a transaction ? */
617 	if (lid == 0)
618 		goto allocateLock;
619 
620 	jfs_info("txLock: tid:%d ip:0x%p mp:0x%p lid:%d", tid, ip, mp, lid);
621 
622 	/* is page locked by the requester transaction ? */
623 	tlck = lid_to_tlock(lid);
624 	if ((xtid = tlck->tid) == tid) {
625 		TXN_UNLOCK();
626 		goto grantLock;
627 	}
628 
629 	/*
630 	 * is page locked by anonymous transaction/lock ?
631 	 *
632 	 * (page update without transaction (i.e., file write) is
633 	 * locked under anonymous transaction tid = 0:
634 	 * anonymous tlocks maintained on anonymous tlock list of
635 	 * the inode of the page and available to all anonymous
636 	 * transactions until txCommit() time at which point
637 	 * they are transferred to the transaction tlock list of
638 	 * the commiting transaction of the inode)
639 	 */
640 	if (xtid == 0) {
641 		tlck->tid = tid;
642 		TXN_UNLOCK();
643 		tblk = tid_to_tblock(tid);
644 		/*
645 		 * The order of the tlocks in the transaction is important
646 		 * (during truncate, child xtree pages must be freed before
647 		 * parent's tlocks change the working map).
648 		 * Take tlock off anonymous list and add to tail of
649 		 * transaction list
650 		 *
651 		 * Note:  We really need to get rid of the tid & lid and
652 		 * use list_head's.  This code is getting UGLY!
653 		 */
654 		if (jfs_ip->atlhead == lid) {
655 			if (jfs_ip->atltail == lid) {
656 				/* only anonymous txn.
657 				 * Remove from anon_list
658 				 */
659 				TXN_LOCK();
660 				list_del_init(&jfs_ip->anon_inode_list);
661 				TXN_UNLOCK();
662 			}
663 			jfs_ip->atlhead = tlck->next;
664 		} else {
665 			lid_t last;
666 			for (last = jfs_ip->atlhead;
667 			     lid_to_tlock(last)->next != lid;
668 			     last = lid_to_tlock(last)->next) {
669 				assert(last);
670 			}
671 			lid_to_tlock(last)->next = tlck->next;
672 			if (jfs_ip->atltail == lid)
673 				jfs_ip->atltail = last;
674 		}
675 
676 		/* insert the tlock at tail of transaction tlock list */
677 
678 		if (tblk->next)
679 			lid_to_tlock(tblk->last)->next = lid;
680 		else
681 			tblk->next = lid;
682 		tlck->next = 0;
683 		tblk->last = lid;
684 
685 		goto grantLock;
686 	}
687 
688 	goto waitLock;
689 
690 	/*
691 	 * allocate a tlock
692 	 */
693       allocateLock:
694 	lid = txLockAlloc();
695 	tlck = lid_to_tlock(lid);
696 
697 	/*
698 	 * initialize tlock
699 	 */
700 	tlck->tid = tid;
701 
702 	TXN_UNLOCK();
703 
704 	/* mark tlock for meta-data page */
705 	if (mp->xflag & COMMIT_PAGE) {
706 
707 		tlck->flag = tlckPAGELOCK;
708 
709 		/* mark the page dirty and nohomeok */
710 		metapage_nohomeok(mp);
711 
712 		jfs_info("locking mp = 0x%p, nohomeok = %d tid = %d tlck = 0x%p",
713 			 mp, mp->nohomeok, tid, tlck);
714 
715 		/* if anonymous transaction, and buffer is on the group
716 		 * commit synclist, mark inode to show this.  This will
717 		 * prevent the buffer from being marked nohomeok for too
718 		 * long a time.
719 		 */
720 		if ((tid == 0) && mp->lsn)
721 			set_cflag(COMMIT_Synclist, ip);
722 	}
723 	/* mark tlock for in-memory inode */
724 	else
725 		tlck->flag = tlckINODELOCK;
726 
727 	if (S_ISDIR(ip->i_mode))
728 		tlck->flag |= tlckDIRECTORY;
729 
730 	tlck->type = 0;
731 
732 	/* bind the tlock and the page */
733 	tlck->ip = ip;
734 	tlck->mp = mp;
735 	if (dir_xtree)
736 		jfs_ip->xtlid = lid;
737 	else
738 		mp->lid = lid;
739 
740 	/*
741 	 * enqueue transaction lock to transaction/inode
742 	 */
743 	/* insert the tlock at tail of transaction tlock list */
744 	if (tid) {
745 		tblk = tid_to_tblock(tid);
746 		if (tblk->next)
747 			lid_to_tlock(tblk->last)->next = lid;
748 		else
749 			tblk->next = lid;
750 		tlck->next = 0;
751 		tblk->last = lid;
752 	}
753 	/* anonymous transaction:
754 	 * insert the tlock at head of inode anonymous tlock list
755 	 */
756 	else {
757 		tlck->next = jfs_ip->atlhead;
758 		jfs_ip->atlhead = lid;
759 		if (tlck->next == 0) {
760 			/* This inode's first anonymous transaction */
761 			jfs_ip->atltail = lid;
762 			TXN_LOCK();
763 			list_add_tail(&jfs_ip->anon_inode_list,
764 				      &TxAnchor.anon_list);
765 			TXN_UNLOCK();
766 		}
767 	}
768 
769 	/* initialize type dependent area for linelock */
770 	linelock = (struct linelock *) & tlck->lock;
771 	linelock->next = 0;
772 	linelock->flag = tlckLINELOCK;
773 	linelock->maxcnt = TLOCKSHORT;
774 	linelock->index = 0;
775 
776 	switch (type & tlckTYPE) {
777 	case tlckDTREE:
778 		linelock->l2linesize = L2DTSLOTSIZE;
779 		break;
780 
781 	case tlckXTREE:
782 		linelock->l2linesize = L2XTSLOTSIZE;
783 
784 		xtlck = (struct xtlock *) linelock;
785 		xtlck->header.offset = 0;
786 		xtlck->header.length = 2;
787 
788 		if (type & tlckNEW) {
789 			xtlck->lwm.offset = XTENTRYSTART;
790 		} else {
791 			if (mp->xflag & COMMIT_PAGE)
792 				p = (xtpage_t *) mp->data;
793 			else
794 				p = &jfs_ip->i_xtroot;
795 			xtlck->lwm.offset =
796 			    le16_to_cpu(p->header.nextindex);
797 		}
798 		xtlck->lwm.length = 0;	/* ! */
799 		xtlck->twm.offset = 0;
800 		xtlck->hwm.offset = 0;
801 
802 		xtlck->index = 2;
803 		break;
804 
805 	case tlckINODE:
806 		linelock->l2linesize = L2INODESLOTSIZE;
807 		break;
808 
809 	case tlckDATA:
810 		linelock->l2linesize = L2DATASLOTSIZE;
811 		break;
812 
813 	default:
814 		jfs_err("UFO tlock:0x%p", tlck);
815 	}
816 
817 	/*
818 	 * update tlock vector
819 	 */
820       grantLock:
821 	tlck->type |= type;
822 
823 	return tlck;
824 
825 	/*
826 	 * page is being locked by another transaction:
827 	 */
828       waitLock:
829 	/* Only locks on ipimap or ipaimap should reach here */
830 	/* assert(jfs_ip->fileset == AGGREGATE_I); */
831 	if (jfs_ip->fileset != AGGREGATE_I) {
832 		jfs_err("txLock: trying to lock locked page!");
833 		dump_mem("ip", ip, sizeof(struct inode));
834 		dump_mem("mp", mp, sizeof(struct metapage));
835 		dump_mem("Locker's tblk", tid_to_tblock(tid),
836 			 sizeof(struct tblock));
837 		dump_mem("Tlock", tlck, sizeof(struct tlock));
838 		BUG();
839 	}
840 	INCREMENT(stattx.waitlock);	/* statistics */
841 	TXN_UNLOCK();
842 	release_metapage(mp);
843 	TXN_LOCK();
844 	xtid = tlck->tid;	/* reacquire after dropping TXN_LOCK */
845 
846 	jfs_info("txLock: in waitLock, tid = %d, xtid = %d, lid = %d",
847 		 tid, xtid, lid);
848 
849 	/* Recheck everything since dropping TXN_LOCK */
850 	if (xtid && (tlck->mp == mp) && (mp->lid == lid))
851 		TXN_SLEEP_DROP_LOCK(&tid_to_tblock(xtid)->waitor);
852 	else
853 		TXN_UNLOCK();
854 	jfs_info("txLock: awakened     tid = %d, lid = %d", tid, lid);
855 
856 	return NULL;
857 }
858 
859 /*
860  * NAME:        txRelease()
861  *
862  * FUNCTION:    Release buffers associated with transaction locks, but don't
863  *		mark homeok yet.  The allows other transactions to modify
864  *		buffers, but won't let them go to disk until commit record
865  *		actually gets written.
866  *
867  * PARAMETER:
868  *              tblk    -
869  *
870  * RETURN:      Errors from subroutines.
871  */
872 static void txRelease(struct tblock * tblk)
873 {
874 	struct metapage *mp;
875 	lid_t lid;
876 	struct tlock *tlck;
877 
878 	TXN_LOCK();
879 
880 	for (lid = tblk->next; lid; lid = tlck->next) {
881 		tlck = lid_to_tlock(lid);
882 		if ((mp = tlck->mp) != NULL &&
883 		    (tlck->type & tlckBTROOT) == 0) {
884 			assert(mp->xflag & COMMIT_PAGE);
885 			mp->lid = 0;
886 		}
887 	}
888 
889 	/*
890 	 * wakeup transactions waiting on a page locked
891 	 * by the current transaction
892 	 */
893 	TXN_WAKEUP(&tblk->waitor);
894 
895 	TXN_UNLOCK();
896 }
897 
898 /*
899  * NAME:        txUnlock()
900  *
901  * FUNCTION:    Initiates pageout of pages modified by tid in journalled
902  *              objects and frees their lockwords.
903  */
904 static void txUnlock(struct tblock * tblk)
905 {
906 	struct tlock *tlck;
907 	struct linelock *linelock;
908 	lid_t lid, next, llid, k;
909 	struct metapage *mp;
910 	struct jfs_log *log;
911 	int difft, diffp;
912 	unsigned long flags;
913 
914 	jfs_info("txUnlock: tblk = 0x%p", tblk);
915 	log = JFS_SBI(tblk->sb)->log;
916 
917 	/*
918 	 * mark page under tlock homeok (its log has been written):
919 	 */
920 	for (lid = tblk->next; lid; lid = next) {
921 		tlck = lid_to_tlock(lid);
922 		next = tlck->next;
923 
924 		jfs_info("unlocking lid = %d, tlck = 0x%p", lid, tlck);
925 
926 		/* unbind page from tlock */
927 		if ((mp = tlck->mp) != NULL &&
928 		    (tlck->type & tlckBTROOT) == 0) {
929 			assert(mp->xflag & COMMIT_PAGE);
930 
931 			/* hold buffer
932 			 */
933 			hold_metapage(mp);
934 
935 			assert(mp->nohomeok > 0);
936 			_metapage_homeok(mp);
937 
938 			/* inherit younger/larger clsn */
939 			LOGSYNC_LOCK(log, flags);
940 			if (mp->clsn) {
941 				logdiff(difft, tblk->clsn, log);
942 				logdiff(diffp, mp->clsn, log);
943 				if (difft > diffp)
944 					mp->clsn = tblk->clsn;
945 			} else
946 				mp->clsn = tblk->clsn;
947 			LOGSYNC_UNLOCK(log, flags);
948 
949 			assert(!(tlck->flag & tlckFREEPAGE));
950 
951 			put_metapage(mp);
952 		}
953 
954 		/* insert tlock, and linelock(s) of the tlock if any,
955 		 * at head of freelist
956 		 */
957 		TXN_LOCK();
958 
959 		llid = ((struct linelock *) & tlck->lock)->next;
960 		while (llid) {
961 			linelock = (struct linelock *) lid_to_tlock(llid);
962 			k = linelock->next;
963 			txLockFree(llid);
964 			llid = k;
965 		}
966 		txLockFree(lid);
967 
968 		TXN_UNLOCK();
969 	}
970 	tblk->next = tblk->last = 0;
971 
972 	/*
973 	 * remove tblock from logsynclist
974 	 * (allocation map pages inherited lsn of tblk and
975 	 * has been inserted in logsync list at txUpdateMap())
976 	 */
977 	if (tblk->lsn) {
978 		LOGSYNC_LOCK(log, flags);
979 		log->count--;
980 		list_del(&tblk->synclist);
981 		LOGSYNC_UNLOCK(log, flags);
982 	}
983 }
984 
985 /*
986  *      txMaplock()
987  *
988  * function: allocate a transaction lock for freed page/entry;
989  *      for freed page, maplock is used as xtlock/dtlock type;
990  */
991 struct tlock *txMaplock(tid_t tid, struct inode *ip, int type)
992 {
993 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
994 	lid_t lid;
995 	struct tblock *tblk;
996 	struct tlock *tlck;
997 	struct maplock *maplock;
998 
999 	TXN_LOCK();
1000 
1001 	/*
1002 	 * allocate a tlock
1003 	 */
1004 	lid = txLockAlloc();
1005 	tlck = lid_to_tlock(lid);
1006 
1007 	/*
1008 	 * initialize tlock
1009 	 */
1010 	tlck->tid = tid;
1011 
1012 	/* bind the tlock and the object */
1013 	tlck->flag = tlckINODELOCK;
1014 	if (S_ISDIR(ip->i_mode))
1015 		tlck->flag |= tlckDIRECTORY;
1016 	tlck->ip = ip;
1017 	tlck->mp = NULL;
1018 
1019 	tlck->type = type;
1020 
1021 	/*
1022 	 * enqueue transaction lock to transaction/inode
1023 	 */
1024 	/* insert the tlock at tail of transaction tlock list */
1025 	if (tid) {
1026 		tblk = tid_to_tblock(tid);
1027 		if (tblk->next)
1028 			lid_to_tlock(tblk->last)->next = lid;
1029 		else
1030 			tblk->next = lid;
1031 		tlck->next = 0;
1032 		tblk->last = lid;
1033 	}
1034 	/* anonymous transaction:
1035 	 * insert the tlock at head of inode anonymous tlock list
1036 	 */
1037 	else {
1038 		tlck->next = jfs_ip->atlhead;
1039 		jfs_ip->atlhead = lid;
1040 		if (tlck->next == 0) {
1041 			/* This inode's first anonymous transaction */
1042 			jfs_ip->atltail = lid;
1043 			list_add_tail(&jfs_ip->anon_inode_list,
1044 				      &TxAnchor.anon_list);
1045 		}
1046 	}
1047 
1048 	TXN_UNLOCK();
1049 
1050 	/* initialize type dependent area for maplock */
1051 	maplock = (struct maplock *) & tlck->lock;
1052 	maplock->next = 0;
1053 	maplock->maxcnt = 0;
1054 	maplock->index = 0;
1055 
1056 	return tlck;
1057 }
1058 
1059 /*
1060  *      txLinelock()
1061  *
1062  * function: allocate a transaction lock for log vector list
1063  */
1064 struct linelock *txLinelock(struct linelock * tlock)
1065 {
1066 	lid_t lid;
1067 	struct tlock *tlck;
1068 	struct linelock *linelock;
1069 
1070 	TXN_LOCK();
1071 
1072 	/* allocate a TxLock structure */
1073 	lid = txLockAlloc();
1074 	tlck = lid_to_tlock(lid);
1075 
1076 	TXN_UNLOCK();
1077 
1078 	/* initialize linelock */
1079 	linelock = (struct linelock *) tlck;
1080 	linelock->next = 0;
1081 	linelock->flag = tlckLINELOCK;
1082 	linelock->maxcnt = TLOCKLONG;
1083 	linelock->index = 0;
1084 	if (tlck->flag & tlckDIRECTORY)
1085 		linelock->flag |= tlckDIRECTORY;
1086 
1087 	/* append linelock after tlock */
1088 	linelock->next = tlock->next;
1089 	tlock->next = lid;
1090 
1091 	return linelock;
1092 }
1093 
1094 /*
1095  *              transaction commit management
1096  *              -----------------------------
1097  */
1098 
1099 /*
1100  * NAME:        txCommit()
1101  *
1102  * FUNCTION:    commit the changes to the objects specified in
1103  *              clist.  For journalled segments only the
1104  *              changes of the caller are committed, ie by tid.
1105  *              for non-journalled segments the data are flushed to
1106  *              disk and then the change to the disk inode and indirect
1107  *              blocks committed (so blocks newly allocated to the
1108  *              segment will be made a part of the segment atomically).
1109  *
1110  *              all of the segments specified in clist must be in
1111  *              one file system. no more than 6 segments are needed
1112  *              to handle all unix svcs.
1113  *
1114  *              if the i_nlink field (i.e. disk inode link count)
1115  *              is zero, and the type of inode is a regular file or
1116  *              directory, or symbolic link , the inode is truncated
1117  *              to zero length. the truncation is committed but the
1118  *              VM resources are unaffected until it is closed (see
1119  *              iput and iclose).
1120  *
1121  * PARAMETER:
1122  *
1123  * RETURN:
1124  *
1125  * serialization:
1126  *              on entry the inode lock on each segment is assumed
1127  *              to be held.
1128  *
1129  * i/o error:
1130  */
1131 int txCommit(tid_t tid,		/* transaction identifier */
1132 	     int nip,		/* number of inodes to commit */
1133 	     struct inode **iplist,	/* list of inode to commit */
1134 	     int flag)
1135 {
1136 	int rc = 0;
1137 	struct commit cd;
1138 	struct jfs_log *log;
1139 	struct tblock *tblk;
1140 	struct lrd *lrd;
1141 	int lsn;
1142 	struct inode *ip;
1143 	struct jfs_inode_info *jfs_ip;
1144 	int k, n;
1145 	ino_t top;
1146 	struct super_block *sb;
1147 
1148 	jfs_info("txCommit, tid = %d, flag = %d", tid, flag);
1149 	/* is read-only file system ? */
1150 	if (isReadOnly(iplist[0])) {
1151 		rc = -EROFS;
1152 		goto TheEnd;
1153 	}
1154 
1155 	sb = cd.sb = iplist[0]->i_sb;
1156 	cd.tid = tid;
1157 
1158 	if (tid == 0)
1159 		tid = txBegin(sb, 0);
1160 	tblk = tid_to_tblock(tid);
1161 
1162 	/*
1163 	 * initialize commit structure
1164 	 */
1165 	log = JFS_SBI(sb)->log;
1166 	cd.log = log;
1167 
1168 	/* initialize log record descriptor in commit */
1169 	lrd = &cd.lrd;
1170 	lrd->logtid = cpu_to_le32(tblk->logtid);
1171 	lrd->backchain = 0;
1172 
1173 	tblk->xflag |= flag;
1174 
1175 	if ((flag & (COMMIT_FORCE | COMMIT_SYNC)) == 0)
1176 		tblk->xflag |= COMMIT_LAZY;
1177 	/*
1178 	 *      prepare non-journaled objects for commit
1179 	 *
1180 	 * flush data pages of non-journaled file
1181 	 * to prevent the file getting non-initialized disk blocks
1182 	 * in case of crash.
1183 	 * (new blocks - )
1184 	 */
1185 	cd.iplist = iplist;
1186 	cd.nip = nip;
1187 
1188 	/*
1189 	 *      acquire transaction lock on (on-disk) inodes
1190 	 *
1191 	 * update on-disk inode from in-memory inode
1192 	 * acquiring transaction locks for AFTER records
1193 	 * on the on-disk inode of file object
1194 	 *
1195 	 * sort the inodes array by inode number in descending order
1196 	 * to prevent deadlock when acquiring transaction lock
1197 	 * of on-disk inodes on multiple on-disk inode pages by
1198 	 * multiple concurrent transactions
1199 	 */
1200 	for (k = 0; k < cd.nip; k++) {
1201 		top = (cd.iplist[k])->i_ino;
1202 		for (n = k + 1; n < cd.nip; n++) {
1203 			ip = cd.iplist[n];
1204 			if (ip->i_ino > top) {
1205 				top = ip->i_ino;
1206 				cd.iplist[n] = cd.iplist[k];
1207 				cd.iplist[k] = ip;
1208 			}
1209 		}
1210 
1211 		ip = cd.iplist[k];
1212 		jfs_ip = JFS_IP(ip);
1213 
1214 		/*
1215 		 * BUGBUG - This code has temporarily been removed.  The
1216 		 * intent is to ensure that any file data is written before
1217 		 * the metadata is committed to the journal.  This prevents
1218 		 * uninitialized data from appearing in a file after the
1219 		 * journal has been replayed.  (The uninitialized data
1220 		 * could be sensitive data removed by another user.)
1221 		 *
1222 		 * The problem now is that we are holding the IWRITELOCK
1223 		 * on the inode, and calling filemap_fdatawrite on an
1224 		 * unmapped page will cause a deadlock in jfs_get_block.
1225 		 *
1226 		 * The long term solution is to pare down the use of
1227 		 * IWRITELOCK.  We are currently holding it too long.
1228 		 * We could also be smarter about which data pages need
1229 		 * to be written before the transaction is committed and
1230 		 * when we don't need to worry about it at all.
1231 		 *
1232 		 * if ((!S_ISDIR(ip->i_mode))
1233 		 *    && (tblk->flag & COMMIT_DELETE) == 0)
1234 		 *	filemap_write_and_wait(ip->i_mapping);
1235 		 */
1236 
1237 		/*
1238 		 * Mark inode as not dirty.  It will still be on the dirty
1239 		 * inode list, but we'll know not to commit it again unless
1240 		 * it gets marked dirty again
1241 		 */
1242 		clear_cflag(COMMIT_Dirty, ip);
1243 
1244 		/* inherit anonymous tlock(s) of inode */
1245 		if (jfs_ip->atlhead) {
1246 			lid_to_tlock(jfs_ip->atltail)->next = tblk->next;
1247 			tblk->next = jfs_ip->atlhead;
1248 			if (!tblk->last)
1249 				tblk->last = jfs_ip->atltail;
1250 			jfs_ip->atlhead = jfs_ip->atltail = 0;
1251 			TXN_LOCK();
1252 			list_del_init(&jfs_ip->anon_inode_list);
1253 			TXN_UNLOCK();
1254 		}
1255 
1256 		/*
1257 		 * acquire transaction lock on on-disk inode page
1258 		 * (become first tlock of the tblk's tlock list)
1259 		 */
1260 		if (((rc = diWrite(tid, ip))))
1261 			goto out;
1262 	}
1263 
1264 	/*
1265 	 *      write log records from transaction locks
1266 	 *
1267 	 * txUpdateMap() resets XAD_NEW in XAD.
1268 	 */
1269 	if ((rc = txLog(log, tblk, &cd)))
1270 		goto TheEnd;
1271 
1272 	/*
1273 	 * Ensure that inode isn't reused before
1274 	 * lazy commit thread finishes processing
1275 	 */
1276 	if (tblk->xflag & COMMIT_DELETE) {
1277 		atomic_inc(&tblk->u.ip->i_count);
1278 		/*
1279 		 * Avoid a rare deadlock
1280 		 *
1281 		 * If the inode is locked, we may be blocked in
1282 		 * jfs_commit_inode.  If so, we don't want the
1283 		 * lazy_commit thread doing the last iput() on the inode
1284 		 * since that may block on the locked inode.  Instead,
1285 		 * commit the transaction synchronously, so the last iput
1286 		 * will be done by the calling thread (or later)
1287 		 */
1288 		if (tblk->u.ip->i_state & I_LOCK)
1289 			tblk->xflag &= ~COMMIT_LAZY;
1290 	}
1291 
1292 	ASSERT((!(tblk->xflag & COMMIT_DELETE)) ||
1293 	       ((tblk->u.ip->i_nlink == 0) &&
1294 		!test_cflag(COMMIT_Nolink, tblk->u.ip)));
1295 
1296 	/*
1297 	 *      write COMMIT log record
1298 	 */
1299 	lrd->type = cpu_to_le16(LOG_COMMIT);
1300 	lrd->length = 0;
1301 	lsn = lmLog(log, tblk, lrd, NULL);
1302 
1303 	lmGroupCommit(log, tblk);
1304 
1305 	/*
1306 	 *      - transaction is now committed -
1307 	 */
1308 
1309 	/*
1310 	 * force pages in careful update
1311 	 * (imap addressing structure update)
1312 	 */
1313 	if (flag & COMMIT_FORCE)
1314 		txForce(tblk);
1315 
1316 	/*
1317 	 *      update allocation map.
1318 	 *
1319 	 * update inode allocation map and inode:
1320 	 * free pager lock on memory object of inode if any.
1321 	 * update  block allocation map.
1322 	 *
1323 	 * txUpdateMap() resets XAD_NEW in XAD.
1324 	 */
1325 	if (tblk->xflag & COMMIT_FORCE)
1326 		txUpdateMap(tblk);
1327 
1328 	/*
1329 	 *      free transaction locks and pageout/free pages
1330 	 */
1331 	txRelease(tblk);
1332 
1333 	if ((tblk->flag & tblkGC_LAZY) == 0)
1334 		txUnlock(tblk);
1335 
1336 
1337 	/*
1338 	 *      reset in-memory object state
1339 	 */
1340 	for (k = 0; k < cd.nip; k++) {
1341 		ip = cd.iplist[k];
1342 		jfs_ip = JFS_IP(ip);
1343 
1344 		/*
1345 		 * reset in-memory inode state
1346 		 */
1347 		jfs_ip->bxflag = 0;
1348 		jfs_ip->blid = 0;
1349 	}
1350 
1351       out:
1352 	if (rc != 0)
1353 		txAbort(tid, 1);
1354 
1355       TheEnd:
1356 	jfs_info("txCommit: tid = %d, returning %d", tid, rc);
1357 	return rc;
1358 }
1359 
1360 /*
1361  * NAME:        txLog()
1362  *
1363  * FUNCTION:    Writes AFTER log records for all lines modified
1364  *              by tid for segments specified by inodes in comdata.
1365  *              Code assumes only WRITELOCKS are recorded in lockwords.
1366  *
1367  * PARAMETERS:
1368  *
1369  * RETURN :
1370  */
1371 static int txLog(struct jfs_log * log, struct tblock * tblk, struct commit * cd)
1372 {
1373 	int rc = 0;
1374 	struct inode *ip;
1375 	lid_t lid;
1376 	struct tlock *tlck;
1377 	struct lrd *lrd = &cd->lrd;
1378 
1379 	/*
1380 	 * write log record(s) for each tlock of transaction,
1381 	 */
1382 	for (lid = tblk->next; lid; lid = tlck->next) {
1383 		tlck = lid_to_tlock(lid);
1384 
1385 		tlck->flag |= tlckLOG;
1386 
1387 		/* initialize lrd common */
1388 		ip = tlck->ip;
1389 		lrd->aggregate = cpu_to_le32(JFS_SBI(ip->i_sb)->aggregate);
1390 		lrd->log.redopage.fileset = cpu_to_le32(JFS_IP(ip)->fileset);
1391 		lrd->log.redopage.inode = cpu_to_le32(ip->i_ino);
1392 
1393 		/* write log record of page from the tlock */
1394 		switch (tlck->type & tlckTYPE) {
1395 		case tlckXTREE:
1396 			xtLog(log, tblk, lrd, tlck);
1397 			break;
1398 
1399 		case tlckDTREE:
1400 			dtLog(log, tblk, lrd, tlck);
1401 			break;
1402 
1403 		case tlckINODE:
1404 			diLog(log, tblk, lrd, tlck, cd);
1405 			break;
1406 
1407 		case tlckMAP:
1408 			mapLog(log, tblk, lrd, tlck);
1409 			break;
1410 
1411 		case tlckDATA:
1412 			dataLog(log, tblk, lrd, tlck);
1413 			break;
1414 
1415 		default:
1416 			jfs_err("UFO tlock:0x%p", tlck);
1417 		}
1418 	}
1419 
1420 	return rc;
1421 }
1422 
1423 /*
1424  *      diLog()
1425  *
1426  * function:    log inode tlock and format maplock to update bmap;
1427  */
1428 static int diLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1429 	  struct tlock * tlck, struct commit * cd)
1430 {
1431 	int rc = 0;
1432 	struct metapage *mp;
1433 	pxd_t *pxd;
1434 	struct pxd_lock *pxdlock;
1435 
1436 	mp = tlck->mp;
1437 
1438 	/* initialize as REDOPAGE record format */
1439 	lrd->log.redopage.type = cpu_to_le16(LOG_INODE);
1440 	lrd->log.redopage.l2linesize = cpu_to_le16(L2INODESLOTSIZE);
1441 
1442 	pxd = &lrd->log.redopage.pxd;
1443 
1444 	/*
1445 	 *      inode after image
1446 	 */
1447 	if (tlck->type & tlckENTRY) {
1448 		/* log after-image for logredo(): */
1449 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1450 		PXDaddress(pxd, mp->index);
1451 		PXDlength(pxd,
1452 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1453 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1454 
1455 		/* mark page as homeward bound */
1456 		tlck->flag |= tlckWRITEPAGE;
1457 	} else if (tlck->type & tlckFREE) {
1458 		/*
1459 		 *      free inode extent
1460 		 *
1461 		 * (pages of the freed inode extent have been invalidated and
1462 		 * a maplock for free of the extent has been formatted at
1463 		 * txLock() time);
1464 		 *
1465 		 * the tlock had been acquired on the inode allocation map page
1466 		 * (iag) that specifies the freed extent, even though the map
1467 		 * page is not itself logged, to prevent pageout of the map
1468 		 * page before the log;
1469 		 */
1470 
1471 		/* log LOG_NOREDOINOEXT of the freed inode extent for
1472 		 * logredo() to start NoRedoPage filters, and to update
1473 		 * imap and bmap for free of the extent;
1474 		 */
1475 		lrd->type = cpu_to_le16(LOG_NOREDOINOEXT);
1476 		/*
1477 		 * For the LOG_NOREDOINOEXT record, we need
1478 		 * to pass the IAG number and inode extent
1479 		 * index (within that IAG) from which the
1480 		 * the extent being released.  These have been
1481 		 * passed to us in the iplist[1] and iplist[2].
1482 		 */
1483 		lrd->log.noredoinoext.iagnum =
1484 		    cpu_to_le32((u32) (size_t) cd->iplist[1]);
1485 		lrd->log.noredoinoext.inoext_idx =
1486 		    cpu_to_le32((u32) (size_t) cd->iplist[2]);
1487 
1488 		pxdlock = (struct pxd_lock *) & tlck->lock;
1489 		*pxd = pxdlock->pxd;
1490 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1491 
1492 		/* update bmap */
1493 		tlck->flag |= tlckUPDATEMAP;
1494 
1495 		/* mark page as homeward bound */
1496 		tlck->flag |= tlckWRITEPAGE;
1497 	} else
1498 		jfs_err("diLog: UFO type tlck:0x%p", tlck);
1499 #ifdef  _JFS_WIP
1500 	/*
1501 	 *      alloc/free external EA extent
1502 	 *
1503 	 * a maplock for txUpdateMap() to update bPWMAP for alloc/free
1504 	 * of the extent has been formatted at txLock() time;
1505 	 */
1506 	else {
1507 		assert(tlck->type & tlckEA);
1508 
1509 		/* log LOG_UPDATEMAP for logredo() to update bmap for
1510 		 * alloc of new (and free of old) external EA extent;
1511 		 */
1512 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1513 		pxdlock = (struct pxd_lock *) & tlck->lock;
1514 		nlock = pxdlock->index;
1515 		for (i = 0; i < nlock; i++, pxdlock++) {
1516 			if (pxdlock->flag & mlckALLOCPXD)
1517 				lrd->log.updatemap.type =
1518 				    cpu_to_le16(LOG_ALLOCPXD);
1519 			else
1520 				lrd->log.updatemap.type =
1521 				    cpu_to_le16(LOG_FREEPXD);
1522 			lrd->log.updatemap.nxd = cpu_to_le16(1);
1523 			lrd->log.updatemap.pxd = pxdlock->pxd;
1524 			lrd->backchain =
1525 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1526 		}
1527 
1528 		/* update bmap */
1529 		tlck->flag |= tlckUPDATEMAP;
1530 	}
1531 #endif				/* _JFS_WIP */
1532 
1533 	return rc;
1534 }
1535 
1536 /*
1537  *      dataLog()
1538  *
1539  * function:    log data tlock
1540  */
1541 static int dataLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1542 	    struct tlock * tlck)
1543 {
1544 	struct metapage *mp;
1545 	pxd_t *pxd;
1546 
1547 	mp = tlck->mp;
1548 
1549 	/* initialize as REDOPAGE record format */
1550 	lrd->log.redopage.type = cpu_to_le16(LOG_DATA);
1551 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DATASLOTSIZE);
1552 
1553 	pxd = &lrd->log.redopage.pxd;
1554 
1555 	/* log after-image for logredo(): */
1556 	lrd->type = cpu_to_le16(LOG_REDOPAGE);
1557 
1558 	if (jfs_dirtable_inline(tlck->ip)) {
1559 		/*
1560 		 * The table has been truncated, we've must have deleted
1561 		 * the last entry, so don't bother logging this
1562 		 */
1563 		mp->lid = 0;
1564 		grab_metapage(mp);
1565 		metapage_homeok(mp);
1566 		discard_metapage(mp);
1567 		tlck->mp = NULL;
1568 		return 0;
1569 	}
1570 
1571 	PXDaddress(pxd, mp->index);
1572 	PXDlength(pxd, mp->logical_size >> tblk->sb->s_blocksize_bits);
1573 
1574 	lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1575 
1576 	/* mark page as homeward bound */
1577 	tlck->flag |= tlckWRITEPAGE;
1578 
1579 	return 0;
1580 }
1581 
1582 /*
1583  *      dtLog()
1584  *
1585  * function:    log dtree tlock and format maplock to update bmap;
1586  */
1587 static void dtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1588 	   struct tlock * tlck)
1589 {
1590 	struct metapage *mp;
1591 	struct pxd_lock *pxdlock;
1592 	pxd_t *pxd;
1593 
1594 	mp = tlck->mp;
1595 
1596 	/* initialize as REDOPAGE/NOREDOPAGE record format */
1597 	lrd->log.redopage.type = cpu_to_le16(LOG_DTREE);
1598 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DTSLOTSIZE);
1599 
1600 	pxd = &lrd->log.redopage.pxd;
1601 
1602 	if (tlck->type & tlckBTROOT)
1603 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
1604 
1605 	/*
1606 	 *      page extension via relocation: entry insertion;
1607 	 *      page extension in-place: entry insertion;
1608 	 *      new right page from page split, reinitialized in-line
1609 	 *      root from root page split: entry insertion;
1610 	 */
1611 	if (tlck->type & (tlckNEW | tlckEXTEND)) {
1612 		/* log after-image of the new page for logredo():
1613 		 * mark log (LOG_NEW) for logredo() to initialize
1614 		 * freelist and update bmap for alloc of the new page;
1615 		 */
1616 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1617 		if (tlck->type & tlckEXTEND)
1618 			lrd->log.redopage.type |= cpu_to_le16(LOG_EXTEND);
1619 		else
1620 			lrd->log.redopage.type |= cpu_to_le16(LOG_NEW);
1621 		PXDaddress(pxd, mp->index);
1622 		PXDlength(pxd,
1623 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1624 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1625 
1626 		/* format a maplock for txUpdateMap() to update bPMAP for
1627 		 * alloc of the new page;
1628 		 */
1629 		if (tlck->type & tlckBTROOT)
1630 			return;
1631 		tlck->flag |= tlckUPDATEMAP;
1632 		pxdlock = (struct pxd_lock *) & tlck->lock;
1633 		pxdlock->flag = mlckALLOCPXD;
1634 		pxdlock->pxd = *pxd;
1635 
1636 		pxdlock->index = 1;
1637 
1638 		/* mark page as homeward bound */
1639 		tlck->flag |= tlckWRITEPAGE;
1640 		return;
1641 	}
1642 
1643 	/*
1644 	 *      entry insertion/deletion,
1645 	 *      sibling page link update (old right page before split);
1646 	 */
1647 	if (tlck->type & (tlckENTRY | tlckRELINK)) {
1648 		/* log after-image for logredo(): */
1649 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1650 		PXDaddress(pxd, mp->index);
1651 		PXDlength(pxd,
1652 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1653 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1654 
1655 		/* mark page as homeward bound */
1656 		tlck->flag |= tlckWRITEPAGE;
1657 		return;
1658 	}
1659 
1660 	/*
1661 	 *      page deletion: page has been invalidated
1662 	 *      page relocation: source extent
1663 	 *
1664 	 *      a maplock for free of the page has been formatted
1665 	 *      at txLock() time);
1666 	 */
1667 	if (tlck->type & (tlckFREE | tlckRELOCATE)) {
1668 		/* log LOG_NOREDOPAGE of the deleted page for logredo()
1669 		 * to start NoRedoPage filter and to update bmap for free
1670 		 * of the deletd page
1671 		 */
1672 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
1673 		pxdlock = (struct pxd_lock *) & tlck->lock;
1674 		*pxd = pxdlock->pxd;
1675 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1676 
1677 		/* a maplock for txUpdateMap() for free of the page
1678 		 * has been formatted at txLock() time;
1679 		 */
1680 		tlck->flag |= tlckUPDATEMAP;
1681 	}
1682 	return;
1683 }
1684 
1685 /*
1686  *      xtLog()
1687  *
1688  * function:    log xtree tlock and format maplock to update bmap;
1689  */
1690 static void xtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1691 	   struct tlock * tlck)
1692 {
1693 	struct inode *ip;
1694 	struct metapage *mp;
1695 	xtpage_t *p;
1696 	struct xtlock *xtlck;
1697 	struct maplock *maplock;
1698 	struct xdlistlock *xadlock;
1699 	struct pxd_lock *pxdlock;
1700 	pxd_t *page_pxd;
1701 	int next, lwm, hwm;
1702 
1703 	ip = tlck->ip;
1704 	mp = tlck->mp;
1705 
1706 	/* initialize as REDOPAGE/NOREDOPAGE record format */
1707 	lrd->log.redopage.type = cpu_to_le16(LOG_XTREE);
1708 	lrd->log.redopage.l2linesize = cpu_to_le16(L2XTSLOTSIZE);
1709 
1710 	page_pxd = &lrd->log.redopage.pxd;
1711 
1712 	if (tlck->type & tlckBTROOT) {
1713 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
1714 		p = &JFS_IP(ip)->i_xtroot;
1715 		if (S_ISDIR(ip->i_mode))
1716 			lrd->log.redopage.type |=
1717 			    cpu_to_le16(LOG_DIR_XTREE);
1718 	} else
1719 		p = (xtpage_t *) mp->data;
1720 	next = le16_to_cpu(p->header.nextindex);
1721 
1722 	xtlck = (struct xtlock *) & tlck->lock;
1723 
1724 	maplock = (struct maplock *) & tlck->lock;
1725 	xadlock = (struct xdlistlock *) maplock;
1726 
1727 	/*
1728 	 *      entry insertion/extension;
1729 	 *      sibling page link update (old right page before split);
1730 	 */
1731 	if (tlck->type & (tlckNEW | tlckGROW | tlckRELINK)) {
1732 		/* log after-image for logredo():
1733 		 * logredo() will update bmap for alloc of new/extended
1734 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
1735 		 * after-image of XADlist;
1736 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
1737 		 * applying the after-image to the meta-data page.
1738 		 */
1739 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1740 		PXDaddress(page_pxd, mp->index);
1741 		PXDlength(page_pxd,
1742 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1743 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1744 
1745 		/* format a maplock for txUpdateMap() to update bPMAP
1746 		 * for alloc of new/extended extents of XAD[lwm:next)
1747 		 * from the page itself;
1748 		 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
1749 		 */
1750 		lwm = xtlck->lwm.offset;
1751 		if (lwm == 0)
1752 			lwm = XTPAGEMAXSLOT;
1753 
1754 		if (lwm == next)
1755 			goto out;
1756 		if (lwm > next) {
1757 			jfs_err("xtLog: lwm > next\n");
1758 			goto out;
1759 		}
1760 		tlck->flag |= tlckUPDATEMAP;
1761 		xadlock->flag = mlckALLOCXADLIST;
1762 		xadlock->count = next - lwm;
1763 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
1764 			int i;
1765 			pxd_t *pxd;
1766 			/*
1767 			 * Lazy commit may allow xtree to be modified before
1768 			 * txUpdateMap runs.  Copy xad into linelock to
1769 			 * preserve correct data.
1770 			 *
1771 			 * We can fit twice as may pxd's as xads in the lock
1772 			 */
1773 			xadlock->flag = mlckALLOCPXDLIST;
1774 			pxd = xadlock->xdlist = &xtlck->pxdlock;
1775 			for (i = 0; i < xadlock->count; i++) {
1776 				PXDaddress(pxd, addressXAD(&p->xad[lwm + i]));
1777 				PXDlength(pxd, lengthXAD(&p->xad[lwm + i]));
1778 				p->xad[lwm + i].flag &=
1779 				    ~(XAD_NEW | XAD_EXTENDED);
1780 				pxd++;
1781 			}
1782 		} else {
1783 			/*
1784 			 * xdlist will point to into inode's xtree, ensure
1785 			 * that transaction is not committed lazily.
1786 			 */
1787 			xadlock->flag = mlckALLOCXADLIST;
1788 			xadlock->xdlist = &p->xad[lwm];
1789 			tblk->xflag &= ~COMMIT_LAZY;
1790 		}
1791 		jfs_info("xtLog: alloc ip:0x%p mp:0x%p tlck:0x%p lwm:%d "
1792 			 "count:%d", tlck->ip, mp, tlck, lwm, xadlock->count);
1793 
1794 		maplock->index = 1;
1795 
1796 	      out:
1797 		/* mark page as homeward bound */
1798 		tlck->flag |= tlckWRITEPAGE;
1799 
1800 		return;
1801 	}
1802 
1803 	/*
1804 	 *      page deletion: file deletion/truncation (ref. xtTruncate())
1805 	 *
1806 	 * (page will be invalidated after log is written and bmap
1807 	 * is updated from the page);
1808 	 */
1809 	if (tlck->type & tlckFREE) {
1810 		/* LOG_NOREDOPAGE log for NoRedoPage filter:
1811 		 * if page free from file delete, NoRedoFile filter from
1812 		 * inode image of zero link count will subsume NoRedoPage
1813 		 * filters for each page;
1814 		 * if page free from file truncattion, write NoRedoPage
1815 		 * filter;
1816 		 *
1817 		 * upadte of block allocation map for the page itself:
1818 		 * if page free from deletion and truncation, LOG_UPDATEMAP
1819 		 * log for the page itself is generated from processing
1820 		 * its parent page xad entries;
1821 		 */
1822 		/* if page free from file truncation, log LOG_NOREDOPAGE
1823 		 * of the deleted page for logredo() to start NoRedoPage
1824 		 * filter for the page;
1825 		 */
1826 		if (tblk->xflag & COMMIT_TRUNCATE) {
1827 			/* write NOREDOPAGE for the page */
1828 			lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
1829 			PXDaddress(page_pxd, mp->index);
1830 			PXDlength(page_pxd,
1831 				  mp->logical_size >> tblk->sb->
1832 				  s_blocksize_bits);
1833 			lrd->backchain =
1834 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1835 
1836 			if (tlck->type & tlckBTROOT) {
1837 				/* Empty xtree must be logged */
1838 				lrd->type = cpu_to_le16(LOG_REDOPAGE);
1839 				lrd->backchain =
1840 				    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1841 			}
1842 		}
1843 
1844 		/* init LOG_UPDATEMAP of the freed extents
1845 		 * XAD[XTENTRYSTART:hwm) from the deleted page itself
1846 		 * for logredo() to update bmap;
1847 		 */
1848 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1849 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEXADLIST);
1850 		xtlck = (struct xtlock *) & tlck->lock;
1851 		hwm = xtlck->hwm.offset;
1852 		lrd->log.updatemap.nxd =
1853 		    cpu_to_le16(hwm - XTENTRYSTART + 1);
1854 		/* reformat linelock for lmLog() */
1855 		xtlck->header.offset = XTENTRYSTART;
1856 		xtlck->header.length = hwm - XTENTRYSTART + 1;
1857 		xtlck->index = 1;
1858 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1859 
1860 		/* format a maplock for txUpdateMap() to update bmap
1861 		 * to free extents of XAD[XTENTRYSTART:hwm) from the
1862 		 * deleted page itself;
1863 		 */
1864 		tlck->flag |= tlckUPDATEMAP;
1865 		xadlock->count = hwm - XTENTRYSTART + 1;
1866 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
1867 			int i;
1868 			pxd_t *pxd;
1869 			/*
1870 			 * Lazy commit may allow xtree to be modified before
1871 			 * txUpdateMap runs.  Copy xad into linelock to
1872 			 * preserve correct data.
1873 			 *
1874 			 * We can fit twice as may pxd's as xads in the lock
1875 			 */
1876 			xadlock->flag = mlckFREEPXDLIST;
1877 			pxd = xadlock->xdlist = &xtlck->pxdlock;
1878 			for (i = 0; i < xadlock->count; i++) {
1879 				PXDaddress(pxd,
1880 					addressXAD(&p->xad[XTENTRYSTART + i]));
1881 				PXDlength(pxd,
1882 					lengthXAD(&p->xad[XTENTRYSTART + i]));
1883 				pxd++;
1884 			}
1885 		} else {
1886 			/*
1887 			 * xdlist will point to into inode's xtree, ensure
1888 			 * that transaction is not committed lazily.
1889 			 */
1890 			xadlock->flag = mlckFREEXADLIST;
1891 			xadlock->xdlist = &p->xad[XTENTRYSTART];
1892 			tblk->xflag &= ~COMMIT_LAZY;
1893 		}
1894 		jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d lwm:2",
1895 			 tlck->ip, mp, xadlock->count);
1896 
1897 		maplock->index = 1;
1898 
1899 		/* mark page as invalid */
1900 		if (((tblk->xflag & COMMIT_PWMAP) || S_ISDIR(ip->i_mode))
1901 		    && !(tlck->type & tlckBTROOT))
1902 			tlck->flag |= tlckFREEPAGE;
1903 		/*
1904 		   else (tblk->xflag & COMMIT_PMAP)
1905 		   ? release the page;
1906 		 */
1907 		return;
1908 	}
1909 
1910 	/*
1911 	 *      page/entry truncation: file truncation (ref. xtTruncate())
1912 	 *
1913 	 *     |----------+------+------+---------------|
1914 	 *                |      |      |
1915 	 *                |      |     hwm - hwm before truncation
1916 	 *                |     next - truncation point
1917 	 *               lwm - lwm before truncation
1918 	 * header ?
1919 	 */
1920 	if (tlck->type & tlckTRUNCATE) {
1921 		/* This odd declaration suppresses a bogus gcc warning */
1922 		pxd_t pxd = pxd;	/* truncated extent of xad */
1923 		int twm;
1924 
1925 		/*
1926 		 * For truncation the entire linelock may be used, so it would
1927 		 * be difficult to store xad list in linelock itself.
1928 		 * Therefore, we'll just force transaction to be committed
1929 		 * synchronously, so that xtree pages won't be changed before
1930 		 * txUpdateMap runs.
1931 		 */
1932 		tblk->xflag &= ~COMMIT_LAZY;
1933 		lwm = xtlck->lwm.offset;
1934 		if (lwm == 0)
1935 			lwm = XTPAGEMAXSLOT;
1936 		hwm = xtlck->hwm.offset;
1937 		twm = xtlck->twm.offset;
1938 
1939 		/*
1940 		 *      write log records
1941 		 */
1942 		/* log after-image for logredo():
1943 		 *
1944 		 * logredo() will update bmap for alloc of new/extended
1945 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
1946 		 * after-image of XADlist;
1947 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
1948 		 * applying the after-image to the meta-data page.
1949 		 */
1950 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1951 		PXDaddress(page_pxd, mp->index);
1952 		PXDlength(page_pxd,
1953 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1954 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1955 
1956 		/*
1957 		 * truncate entry XAD[twm == next - 1]:
1958 		 */
1959 		if (twm == next - 1) {
1960 			/* init LOG_UPDATEMAP for logredo() to update bmap for
1961 			 * free of truncated delta extent of the truncated
1962 			 * entry XAD[next - 1]:
1963 			 * (xtlck->pxdlock = truncated delta extent);
1964 			 */
1965 			pxdlock = (struct pxd_lock *) & xtlck->pxdlock;
1966 			/* assert(pxdlock->type & tlckTRUNCATE); */
1967 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1968 			lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
1969 			lrd->log.updatemap.nxd = cpu_to_le16(1);
1970 			lrd->log.updatemap.pxd = pxdlock->pxd;
1971 			pxd = pxdlock->pxd;	/* save to format maplock */
1972 			lrd->backchain =
1973 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1974 		}
1975 
1976 		/*
1977 		 * free entries XAD[next:hwm]:
1978 		 */
1979 		if (hwm >= next) {
1980 			/* init LOG_UPDATEMAP of the freed extents
1981 			 * XAD[next:hwm] from the deleted page itself
1982 			 * for logredo() to update bmap;
1983 			 */
1984 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1985 			lrd->log.updatemap.type =
1986 			    cpu_to_le16(LOG_FREEXADLIST);
1987 			xtlck = (struct xtlock *) & tlck->lock;
1988 			hwm = xtlck->hwm.offset;
1989 			lrd->log.updatemap.nxd =
1990 			    cpu_to_le16(hwm - next + 1);
1991 			/* reformat linelock for lmLog() */
1992 			xtlck->header.offset = next;
1993 			xtlck->header.length = hwm - next + 1;
1994 			xtlck->index = 1;
1995 			lrd->backchain =
1996 			    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1997 		}
1998 
1999 		/*
2000 		 *      format maplock(s) for txUpdateMap() to update bmap
2001 		 */
2002 		maplock->index = 0;
2003 
2004 		/*
2005 		 * allocate entries XAD[lwm:next):
2006 		 */
2007 		if (lwm < next) {
2008 			/* format a maplock for txUpdateMap() to update bPMAP
2009 			 * for alloc of new/extended extents of XAD[lwm:next)
2010 			 * from the page itself;
2011 			 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
2012 			 */
2013 			tlck->flag |= tlckUPDATEMAP;
2014 			xadlock->flag = mlckALLOCXADLIST;
2015 			xadlock->count = next - lwm;
2016 			xadlock->xdlist = &p->xad[lwm];
2017 
2018 			jfs_info("xtLog: alloc ip:0x%p mp:0x%p count:%d "
2019 				 "lwm:%d next:%d",
2020 				 tlck->ip, mp, xadlock->count, lwm, next);
2021 			maplock->index++;
2022 			xadlock++;
2023 		}
2024 
2025 		/*
2026 		 * truncate entry XAD[twm == next - 1]:
2027 		 */
2028 		if (twm == next - 1) {
2029 			/* format a maplock for txUpdateMap() to update bmap
2030 			 * to free truncated delta extent of the truncated
2031 			 * entry XAD[next - 1];
2032 			 * (xtlck->pxdlock = truncated delta extent);
2033 			 */
2034 			tlck->flag |= tlckUPDATEMAP;
2035 			pxdlock = (struct pxd_lock *) xadlock;
2036 			pxdlock->flag = mlckFREEPXD;
2037 			pxdlock->count = 1;
2038 			pxdlock->pxd = pxd;
2039 
2040 			jfs_info("xtLog: truncate ip:0x%p mp:0x%p count:%d "
2041 				 "hwm:%d", ip, mp, pxdlock->count, hwm);
2042 			maplock->index++;
2043 			xadlock++;
2044 		}
2045 
2046 		/*
2047 		 * free entries XAD[next:hwm]:
2048 		 */
2049 		if (hwm >= next) {
2050 			/* format a maplock for txUpdateMap() to update bmap
2051 			 * to free extents of XAD[next:hwm] from thedeleted
2052 			 * page itself;
2053 			 */
2054 			tlck->flag |= tlckUPDATEMAP;
2055 			xadlock->flag = mlckFREEXADLIST;
2056 			xadlock->count = hwm - next + 1;
2057 			xadlock->xdlist = &p->xad[next];
2058 
2059 			jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d "
2060 				 "next:%d hwm:%d",
2061 				 tlck->ip, mp, xadlock->count, next, hwm);
2062 			maplock->index++;
2063 		}
2064 
2065 		/* mark page as homeward bound */
2066 		tlck->flag |= tlckWRITEPAGE;
2067 	}
2068 	return;
2069 }
2070 
2071 /*
2072  *      mapLog()
2073  *
2074  * function:    log from maplock of freed data extents;
2075  */
2076 static void mapLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
2077 		   struct tlock * tlck)
2078 {
2079 	struct pxd_lock *pxdlock;
2080 	int i, nlock;
2081 	pxd_t *pxd;
2082 
2083 	/*
2084 	 *      page relocation: free the source page extent
2085 	 *
2086 	 * a maplock for txUpdateMap() for free of the page
2087 	 * has been formatted at txLock() time saving the src
2088 	 * relocated page address;
2089 	 */
2090 	if (tlck->type & tlckRELOCATE) {
2091 		/* log LOG_NOREDOPAGE of the old relocated page
2092 		 * for logredo() to start NoRedoPage filter;
2093 		 */
2094 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
2095 		pxdlock = (struct pxd_lock *) & tlck->lock;
2096 		pxd = &lrd->log.redopage.pxd;
2097 		*pxd = pxdlock->pxd;
2098 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2099 
2100 		/* (N.B. currently, logredo() does NOT update bmap
2101 		 * for free of the page itself for (LOG_XTREE|LOG_NOREDOPAGE);
2102 		 * if page free from relocation, LOG_UPDATEMAP log is
2103 		 * specifically generated now for logredo()
2104 		 * to update bmap for free of src relocated page;
2105 		 * (new flag LOG_RELOCATE may be introduced which will
2106 		 * inform logredo() to start NORedoPage filter and also
2107 		 * update block allocation map at the same time, thus
2108 		 * avoiding an extra log write);
2109 		 */
2110 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
2111 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
2112 		lrd->log.updatemap.nxd = cpu_to_le16(1);
2113 		lrd->log.updatemap.pxd = pxdlock->pxd;
2114 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2115 
2116 		/* a maplock for txUpdateMap() for free of the page
2117 		 * has been formatted at txLock() time;
2118 		 */
2119 		tlck->flag |= tlckUPDATEMAP;
2120 		return;
2121 	}
2122 	/*
2123 
2124 	 * Otherwise it's not a relocate request
2125 	 *
2126 	 */
2127 	else {
2128 		/* log LOG_UPDATEMAP for logredo() to update bmap for
2129 		 * free of truncated/relocated delta extent of the data;
2130 		 * e.g.: external EA extent, relocated/truncated extent
2131 		 * from xtTailgate();
2132 		 */
2133 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
2134 		pxdlock = (struct pxd_lock *) & tlck->lock;
2135 		nlock = pxdlock->index;
2136 		for (i = 0; i < nlock; i++, pxdlock++) {
2137 			if (pxdlock->flag & mlckALLOCPXD)
2138 				lrd->log.updatemap.type =
2139 				    cpu_to_le16(LOG_ALLOCPXD);
2140 			else
2141 				lrd->log.updatemap.type =
2142 				    cpu_to_le16(LOG_FREEPXD);
2143 			lrd->log.updatemap.nxd = cpu_to_le16(1);
2144 			lrd->log.updatemap.pxd = pxdlock->pxd;
2145 			lrd->backchain =
2146 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2147 			jfs_info("mapLog: xaddr:0x%lx xlen:0x%x",
2148 				 (ulong) addressPXD(&pxdlock->pxd),
2149 				 lengthPXD(&pxdlock->pxd));
2150 		}
2151 
2152 		/* update bmap */
2153 		tlck->flag |= tlckUPDATEMAP;
2154 	}
2155 }
2156 
2157 /*
2158  *      txEA()
2159  *
2160  * function:    acquire maplock for EA/ACL extents or
2161  *              set COMMIT_INLINE flag;
2162  */
2163 void txEA(tid_t tid, struct inode *ip, dxd_t * oldea, dxd_t * newea)
2164 {
2165 	struct tlock *tlck = NULL;
2166 	struct pxd_lock *maplock = NULL, *pxdlock = NULL;
2167 
2168 	/*
2169 	 * format maplock for alloc of new EA extent
2170 	 */
2171 	if (newea) {
2172 		/* Since the newea could be a completely zeroed entry we need to
2173 		 * check for the two flags which indicate we should actually
2174 		 * commit new EA data
2175 		 */
2176 		if (newea->flag & DXD_EXTENT) {
2177 			tlck = txMaplock(tid, ip, tlckMAP);
2178 			maplock = (struct pxd_lock *) & tlck->lock;
2179 			pxdlock = (struct pxd_lock *) maplock;
2180 			pxdlock->flag = mlckALLOCPXD;
2181 			PXDaddress(&pxdlock->pxd, addressDXD(newea));
2182 			PXDlength(&pxdlock->pxd, lengthDXD(newea));
2183 			pxdlock++;
2184 			maplock->index = 1;
2185 		} else if (newea->flag & DXD_INLINE) {
2186 			tlck = NULL;
2187 
2188 			set_cflag(COMMIT_Inlineea, ip);
2189 		}
2190 	}
2191 
2192 	/*
2193 	 * format maplock for free of old EA extent
2194 	 */
2195 	if (!test_cflag(COMMIT_Nolink, ip) && oldea->flag & DXD_EXTENT) {
2196 		if (tlck == NULL) {
2197 			tlck = txMaplock(tid, ip, tlckMAP);
2198 			maplock = (struct pxd_lock *) & tlck->lock;
2199 			pxdlock = (struct pxd_lock *) maplock;
2200 			maplock->index = 0;
2201 		}
2202 		pxdlock->flag = mlckFREEPXD;
2203 		PXDaddress(&pxdlock->pxd, addressDXD(oldea));
2204 		PXDlength(&pxdlock->pxd, lengthDXD(oldea));
2205 		maplock->index++;
2206 	}
2207 }
2208 
2209 /*
2210  *      txForce()
2211  *
2212  * function: synchronously write pages locked by transaction
2213  *              after txLog() but before txUpdateMap();
2214  */
2215 static void txForce(struct tblock * tblk)
2216 {
2217 	struct tlock *tlck;
2218 	lid_t lid, next;
2219 	struct metapage *mp;
2220 
2221 	/*
2222 	 * reverse the order of transaction tlocks in
2223 	 * careful update order of address index pages
2224 	 * (right to left, bottom up)
2225 	 */
2226 	tlck = lid_to_tlock(tblk->next);
2227 	lid = tlck->next;
2228 	tlck->next = 0;
2229 	while (lid) {
2230 		tlck = lid_to_tlock(lid);
2231 		next = tlck->next;
2232 		tlck->next = tblk->next;
2233 		tblk->next = lid;
2234 		lid = next;
2235 	}
2236 
2237 	/*
2238 	 * synchronously write the page, and
2239 	 * hold the page for txUpdateMap();
2240 	 */
2241 	for (lid = tblk->next; lid; lid = next) {
2242 		tlck = lid_to_tlock(lid);
2243 		next = tlck->next;
2244 
2245 		if ((mp = tlck->mp) != NULL &&
2246 		    (tlck->type & tlckBTROOT) == 0) {
2247 			assert(mp->xflag & COMMIT_PAGE);
2248 
2249 			if (tlck->flag & tlckWRITEPAGE) {
2250 				tlck->flag &= ~tlckWRITEPAGE;
2251 
2252 				/* do not release page to freelist */
2253 				force_metapage(mp);
2254 #if 0
2255 				/*
2256 				 * The "right" thing to do here is to
2257 				 * synchronously write the metadata.
2258 				 * With the current implementation this
2259 				 * is hard since write_metapage requires
2260 				 * us to kunmap & remap the page.  If we
2261 				 * have tlocks pointing into the metadata
2262 				 * pages, we don't want to do this.  I think
2263 				 * we can get by with synchronously writing
2264 				 * the pages when they are released.
2265 				 */
2266 				assert(mp->nohomeok);
2267 				set_bit(META_dirty, &mp->flag);
2268 				set_bit(META_sync, &mp->flag);
2269 #endif
2270 			}
2271 		}
2272 	}
2273 }
2274 
2275 /*
2276  *      txUpdateMap()
2277  *
2278  * function:    update persistent allocation map (and working map
2279  *              if appropriate);
2280  *
2281  * parameter:
2282  */
2283 static void txUpdateMap(struct tblock * tblk)
2284 {
2285 	struct inode *ip;
2286 	struct inode *ipimap;
2287 	lid_t lid;
2288 	struct tlock *tlck;
2289 	struct maplock *maplock;
2290 	struct pxd_lock pxdlock;
2291 	int maptype;
2292 	int k, nlock;
2293 	struct metapage *mp = NULL;
2294 
2295 	ipimap = JFS_SBI(tblk->sb)->ipimap;
2296 
2297 	maptype = (tblk->xflag & COMMIT_PMAP) ? COMMIT_PMAP : COMMIT_PWMAP;
2298 
2299 
2300 	/*
2301 	 *      update block allocation map
2302 	 *
2303 	 * update allocation state in pmap (and wmap) and
2304 	 * update lsn of the pmap page;
2305 	 */
2306 	/*
2307 	 * scan each tlock/page of transaction for block allocation/free:
2308 	 *
2309 	 * for each tlock/page of transaction, update map.
2310 	 *  ? are there tlock for pmap and pwmap at the same time ?
2311 	 */
2312 	for (lid = tblk->next; lid; lid = tlck->next) {
2313 		tlck = lid_to_tlock(lid);
2314 
2315 		if ((tlck->flag & tlckUPDATEMAP) == 0)
2316 			continue;
2317 
2318 		if (tlck->flag & tlckFREEPAGE) {
2319 			/*
2320 			 * Another thread may attempt to reuse freed space
2321 			 * immediately, so we want to get rid of the metapage
2322 			 * before anyone else has a chance to get it.
2323 			 * Lock metapage, update maps, then invalidate
2324 			 * the metapage.
2325 			 */
2326 			mp = tlck->mp;
2327 			ASSERT(mp->xflag & COMMIT_PAGE);
2328 			grab_metapage(mp);
2329 		}
2330 
2331 		/*
2332 		 * extent list:
2333 		 * . in-line PXD list:
2334 		 * . out-of-line XAD list:
2335 		 */
2336 		maplock = (struct maplock *) & tlck->lock;
2337 		nlock = maplock->index;
2338 
2339 		for (k = 0; k < nlock; k++, maplock++) {
2340 			/*
2341 			 * allocate blocks in persistent map:
2342 			 *
2343 			 * blocks have been allocated from wmap at alloc time;
2344 			 */
2345 			if (maplock->flag & mlckALLOC) {
2346 				txAllocPMap(ipimap, maplock, tblk);
2347 			}
2348 			/*
2349 			 * free blocks in persistent and working map:
2350 			 * blocks will be freed in pmap and then in wmap;
2351 			 *
2352 			 * ? tblock specifies the PMAP/PWMAP based upon
2353 			 * transaction
2354 			 *
2355 			 * free blocks in persistent map:
2356 			 * blocks will be freed from wmap at last reference
2357 			 * release of the object for regular files;
2358 			 *
2359 			 * Alway free blocks from both persistent & working
2360 			 * maps for directories
2361 			 */
2362 			else {	/* (maplock->flag & mlckFREE) */
2363 
2364 				if (tlck->flag & tlckDIRECTORY)
2365 					txFreeMap(ipimap, maplock,
2366 						  tblk, COMMIT_PWMAP);
2367 				else
2368 					txFreeMap(ipimap, maplock,
2369 						  tblk, maptype);
2370 			}
2371 		}
2372 		if (tlck->flag & tlckFREEPAGE) {
2373 			if (!(tblk->flag & tblkGC_LAZY)) {
2374 				/* This is equivalent to txRelease */
2375 				ASSERT(mp->lid == lid);
2376 				tlck->mp->lid = 0;
2377 			}
2378 			assert(mp->nohomeok == 1);
2379 			metapage_homeok(mp);
2380 			discard_metapage(mp);
2381 			tlck->mp = NULL;
2382 		}
2383 	}
2384 	/*
2385 	 *      update inode allocation map
2386 	 *
2387 	 * update allocation state in pmap and
2388 	 * update lsn of the pmap page;
2389 	 * update in-memory inode flag/state
2390 	 *
2391 	 * unlock mapper/write lock
2392 	 */
2393 	if (tblk->xflag & COMMIT_CREATE) {
2394 		diUpdatePMap(ipimap, tblk->ino, false, tblk);
2395 		/* update persistent block allocation map
2396 		 * for the allocation of inode extent;
2397 		 */
2398 		pxdlock.flag = mlckALLOCPXD;
2399 		pxdlock.pxd = tblk->u.ixpxd;
2400 		pxdlock.index = 1;
2401 		txAllocPMap(ipimap, (struct maplock *) & pxdlock, tblk);
2402 	} else if (tblk->xflag & COMMIT_DELETE) {
2403 		ip = tblk->u.ip;
2404 		diUpdatePMap(ipimap, ip->i_ino, true, tblk);
2405 		iput(ip);
2406 	}
2407 }
2408 
2409 /*
2410  *      txAllocPMap()
2411  *
2412  * function: allocate from persistent map;
2413  *
2414  * parameter:
2415  *      ipbmap  -
2416  *      malock -
2417  *              xad list:
2418  *              pxd:
2419  *
2420  *      maptype -
2421  *              allocate from persistent map;
2422  *              free from persistent map;
2423  *              (e.g., tmp file - free from working map at releae
2424  *               of last reference);
2425  *              free from persistent and working map;
2426  *
2427  *      lsn     - log sequence number;
2428  */
2429 static void txAllocPMap(struct inode *ip, struct maplock * maplock,
2430 			struct tblock * tblk)
2431 {
2432 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
2433 	struct xdlistlock *xadlistlock;
2434 	xad_t *xad;
2435 	s64 xaddr;
2436 	int xlen;
2437 	struct pxd_lock *pxdlock;
2438 	struct xdlistlock *pxdlistlock;
2439 	pxd_t *pxd;
2440 	int n;
2441 
2442 	/*
2443 	 * allocate from persistent map;
2444 	 */
2445 	if (maplock->flag & mlckALLOCXADLIST) {
2446 		xadlistlock = (struct xdlistlock *) maplock;
2447 		xad = xadlistlock->xdlist;
2448 		for (n = 0; n < xadlistlock->count; n++, xad++) {
2449 			if (xad->flag & (XAD_NEW | XAD_EXTENDED)) {
2450 				xaddr = addressXAD(xad);
2451 				xlen = lengthXAD(xad);
2452 				dbUpdatePMap(ipbmap, false, xaddr,
2453 					     (s64) xlen, tblk);
2454 				xad->flag &= ~(XAD_NEW | XAD_EXTENDED);
2455 				jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
2456 					 (ulong) xaddr, xlen);
2457 			}
2458 		}
2459 	} else if (maplock->flag & mlckALLOCPXD) {
2460 		pxdlock = (struct pxd_lock *) maplock;
2461 		xaddr = addressPXD(&pxdlock->pxd);
2462 		xlen = lengthPXD(&pxdlock->pxd);
2463 		dbUpdatePMap(ipbmap, false, xaddr, (s64) xlen, tblk);
2464 		jfs_info("allocPMap: xaddr:0x%lx xlen:%d", (ulong) xaddr, xlen);
2465 	} else {		/* (maplock->flag & mlckALLOCPXDLIST) */
2466 
2467 		pxdlistlock = (struct xdlistlock *) maplock;
2468 		pxd = pxdlistlock->xdlist;
2469 		for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2470 			xaddr = addressPXD(pxd);
2471 			xlen = lengthPXD(pxd);
2472 			dbUpdatePMap(ipbmap, false, xaddr, (s64) xlen,
2473 				     tblk);
2474 			jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
2475 				 (ulong) xaddr, xlen);
2476 		}
2477 	}
2478 }
2479 
2480 /*
2481  *      txFreeMap()
2482  *
2483  * function:    free from persistent and/or working map;
2484  *
2485  * todo: optimization
2486  */
2487 void txFreeMap(struct inode *ip,
2488 	       struct maplock * maplock, struct tblock * tblk, int maptype)
2489 {
2490 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
2491 	struct xdlistlock *xadlistlock;
2492 	xad_t *xad;
2493 	s64 xaddr;
2494 	int xlen;
2495 	struct pxd_lock *pxdlock;
2496 	struct xdlistlock *pxdlistlock;
2497 	pxd_t *pxd;
2498 	int n;
2499 
2500 	jfs_info("txFreeMap: tblk:0x%p maplock:0x%p maptype:0x%x",
2501 		 tblk, maplock, maptype);
2502 
2503 	/*
2504 	 * free from persistent map;
2505 	 */
2506 	if (maptype == COMMIT_PMAP || maptype == COMMIT_PWMAP) {
2507 		if (maplock->flag & mlckFREEXADLIST) {
2508 			xadlistlock = (struct xdlistlock *) maplock;
2509 			xad = xadlistlock->xdlist;
2510 			for (n = 0; n < xadlistlock->count; n++, xad++) {
2511 				if (!(xad->flag & XAD_NEW)) {
2512 					xaddr = addressXAD(xad);
2513 					xlen = lengthXAD(xad);
2514 					dbUpdatePMap(ipbmap, true, xaddr,
2515 						     (s64) xlen, tblk);
2516 					jfs_info("freePMap: xaddr:0x%lx "
2517 						 "xlen:%d",
2518 						 (ulong) xaddr, xlen);
2519 				}
2520 			}
2521 		} else if (maplock->flag & mlckFREEPXD) {
2522 			pxdlock = (struct pxd_lock *) maplock;
2523 			xaddr = addressPXD(&pxdlock->pxd);
2524 			xlen = lengthPXD(&pxdlock->pxd);
2525 			dbUpdatePMap(ipbmap, true, xaddr, (s64) xlen,
2526 				     tblk);
2527 			jfs_info("freePMap: xaddr:0x%lx xlen:%d",
2528 				 (ulong) xaddr, xlen);
2529 		} else {	/* (maplock->flag & mlckALLOCPXDLIST) */
2530 
2531 			pxdlistlock = (struct xdlistlock *) maplock;
2532 			pxd = pxdlistlock->xdlist;
2533 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2534 				xaddr = addressPXD(pxd);
2535 				xlen = lengthPXD(pxd);
2536 				dbUpdatePMap(ipbmap, true, xaddr,
2537 					     (s64) xlen, tblk);
2538 				jfs_info("freePMap: xaddr:0x%lx xlen:%d",
2539 					 (ulong) xaddr, xlen);
2540 			}
2541 		}
2542 	}
2543 
2544 	/*
2545 	 * free from working map;
2546 	 */
2547 	if (maptype == COMMIT_PWMAP || maptype == COMMIT_WMAP) {
2548 		if (maplock->flag & mlckFREEXADLIST) {
2549 			xadlistlock = (struct xdlistlock *) maplock;
2550 			xad = xadlistlock->xdlist;
2551 			for (n = 0; n < xadlistlock->count; n++, xad++) {
2552 				xaddr = addressXAD(xad);
2553 				xlen = lengthXAD(xad);
2554 				dbFree(ip, xaddr, (s64) xlen);
2555 				xad->flag = 0;
2556 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2557 					 (ulong) xaddr, xlen);
2558 			}
2559 		} else if (maplock->flag & mlckFREEPXD) {
2560 			pxdlock = (struct pxd_lock *) maplock;
2561 			xaddr = addressPXD(&pxdlock->pxd);
2562 			xlen = lengthPXD(&pxdlock->pxd);
2563 			dbFree(ip, xaddr, (s64) xlen);
2564 			jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2565 				 (ulong) xaddr, xlen);
2566 		} else {	/* (maplock->flag & mlckFREEPXDLIST) */
2567 
2568 			pxdlistlock = (struct xdlistlock *) maplock;
2569 			pxd = pxdlistlock->xdlist;
2570 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2571 				xaddr = addressPXD(pxd);
2572 				xlen = lengthPXD(pxd);
2573 				dbFree(ip, xaddr, (s64) xlen);
2574 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2575 					 (ulong) xaddr, xlen);
2576 			}
2577 		}
2578 	}
2579 }
2580 
2581 /*
2582  *      txFreelock()
2583  *
2584  * function:    remove tlock from inode anonymous locklist
2585  */
2586 void txFreelock(struct inode *ip)
2587 {
2588 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
2589 	struct tlock *xtlck, *tlck;
2590 	lid_t xlid = 0, lid;
2591 
2592 	if (!jfs_ip->atlhead)
2593 		return;
2594 
2595 	TXN_LOCK();
2596 	xtlck = (struct tlock *) &jfs_ip->atlhead;
2597 
2598 	while ((lid = xtlck->next) != 0) {
2599 		tlck = lid_to_tlock(lid);
2600 		if (tlck->flag & tlckFREELOCK) {
2601 			xtlck->next = tlck->next;
2602 			txLockFree(lid);
2603 		} else {
2604 			xtlck = tlck;
2605 			xlid = lid;
2606 		}
2607 	}
2608 
2609 	if (jfs_ip->atlhead)
2610 		jfs_ip->atltail = xlid;
2611 	else {
2612 		jfs_ip->atltail = 0;
2613 		/*
2614 		 * If inode was on anon_list, remove it
2615 		 */
2616 		list_del_init(&jfs_ip->anon_inode_list);
2617 	}
2618 	TXN_UNLOCK();
2619 }
2620 
2621 /*
2622  *      txAbort()
2623  *
2624  * function: abort tx before commit;
2625  *
2626  * frees line-locks and segment locks for all
2627  * segments in comdata structure.
2628  * Optionally sets state of file-system to FM_DIRTY in super-block.
2629  * log age of page-frames in memory for which caller has
2630  * are reset to 0 (to avoid logwarap).
2631  */
2632 void txAbort(tid_t tid, int dirty)
2633 {
2634 	lid_t lid, next;
2635 	struct metapage *mp;
2636 	struct tblock *tblk = tid_to_tblock(tid);
2637 	struct tlock *tlck;
2638 
2639 	/*
2640 	 * free tlocks of the transaction
2641 	 */
2642 	for (lid = tblk->next; lid; lid = next) {
2643 		tlck = lid_to_tlock(lid);
2644 		next = tlck->next;
2645 		mp = tlck->mp;
2646 		JFS_IP(tlck->ip)->xtlid = 0;
2647 
2648 		if (mp) {
2649 			mp->lid = 0;
2650 
2651 			/*
2652 			 * reset lsn of page to avoid logwarap:
2653 			 *
2654 			 * (page may have been previously committed by another
2655 			 * transaction(s) but has not been paged, i.e.,
2656 			 * it may be on logsync list even though it has not
2657 			 * been logged for the current tx.)
2658 			 */
2659 			if (mp->xflag & COMMIT_PAGE && mp->lsn)
2660 				LogSyncRelease(mp);
2661 		}
2662 		/* insert tlock at head of freelist */
2663 		TXN_LOCK();
2664 		txLockFree(lid);
2665 		TXN_UNLOCK();
2666 	}
2667 
2668 	/* caller will free the transaction block */
2669 
2670 	tblk->next = tblk->last = 0;
2671 
2672 	/*
2673 	 * mark filesystem dirty
2674 	 */
2675 	if (dirty)
2676 		jfs_error(tblk->sb, "txAbort");
2677 
2678 	return;
2679 }
2680 
2681 /*
2682  *      txLazyCommit(void)
2683  *
2684  *	All transactions except those changing ipimap (COMMIT_FORCE) are
2685  *	processed by this routine.  This insures that the inode and block
2686  *	allocation maps are updated in order.  For synchronous transactions,
2687  *	let the user thread finish processing after txUpdateMap() is called.
2688  */
2689 static void txLazyCommit(struct tblock * tblk)
2690 {
2691 	struct jfs_log *log;
2692 
2693 	while (((tblk->flag & tblkGC_READY) == 0) &&
2694 	       ((tblk->flag & tblkGC_UNLOCKED) == 0)) {
2695 		/* We must have gotten ahead of the user thread
2696 		 */
2697 		jfs_info("jfs_lazycommit: tblk 0x%p not unlocked", tblk);
2698 		yield();
2699 	}
2700 
2701 	jfs_info("txLazyCommit: processing tblk 0x%p", tblk);
2702 
2703 	txUpdateMap(tblk);
2704 
2705 	log = (struct jfs_log *) JFS_SBI(tblk->sb)->log;
2706 
2707 	spin_lock_irq(&log->gclock);	// LOGGC_LOCK
2708 
2709 	tblk->flag |= tblkGC_COMMITTED;
2710 
2711 	if (tblk->flag & tblkGC_READY)
2712 		log->gcrtc--;
2713 
2714 	wake_up_all(&tblk->gcwait);	// LOGGC_WAKEUP
2715 
2716 	/*
2717 	 * Can't release log->gclock until we've tested tblk->flag
2718 	 */
2719 	if (tblk->flag & tblkGC_LAZY) {
2720 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
2721 		txUnlock(tblk);
2722 		tblk->flag &= ~tblkGC_LAZY;
2723 		txEnd(tblk - TxBlock);	/* Convert back to tid */
2724 	} else
2725 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
2726 
2727 	jfs_info("txLazyCommit: done: tblk = 0x%p", tblk);
2728 }
2729 
2730 /*
2731  *      jfs_lazycommit(void)
2732  *
2733  *	To be run as a kernel daemon.  If lbmIODone is called in an interrupt
2734  *	context, or where blocking is not wanted, this routine will process
2735  *	committed transactions from the unlock queue.
2736  */
2737 int jfs_lazycommit(void *arg)
2738 {
2739 	int WorkDone;
2740 	struct tblock *tblk;
2741 	unsigned long flags;
2742 	struct jfs_sb_info *sbi;
2743 
2744 	do {
2745 		LAZY_LOCK(flags);
2746 		jfs_commit_thread_waking = 0;	/* OK to wake another thread */
2747 		while (!list_empty(&TxAnchor.unlock_queue)) {
2748 			WorkDone = 0;
2749 			list_for_each_entry(tblk, &TxAnchor.unlock_queue,
2750 					    cqueue) {
2751 
2752 				sbi = JFS_SBI(tblk->sb);
2753 				/*
2754 				 * For each volume, the transactions must be
2755 				 * handled in order.  If another commit thread
2756 				 * is handling a tblk for this superblock,
2757 				 * skip it
2758 				 */
2759 				if (sbi->commit_state & IN_LAZYCOMMIT)
2760 					continue;
2761 
2762 				sbi->commit_state |= IN_LAZYCOMMIT;
2763 				WorkDone = 1;
2764 
2765 				/*
2766 				 * Remove transaction from queue
2767 				 */
2768 				list_del(&tblk->cqueue);
2769 
2770 				LAZY_UNLOCK(flags);
2771 				txLazyCommit(tblk);
2772 				LAZY_LOCK(flags);
2773 
2774 				sbi->commit_state &= ~IN_LAZYCOMMIT;
2775 				/*
2776 				 * Don't continue in the for loop.  (We can't
2777 				 * anyway, it's unsafe!)  We want to go back to
2778 				 * the beginning of the list.
2779 				 */
2780 				break;
2781 			}
2782 
2783 			/* If there was nothing to do, don't continue */
2784 			if (!WorkDone)
2785 				break;
2786 		}
2787 		/* In case a wakeup came while all threads were active */
2788 		jfs_commit_thread_waking = 0;
2789 
2790 		if (freezing(current)) {
2791 			LAZY_UNLOCK(flags);
2792 			refrigerator();
2793 		} else {
2794 			DECLARE_WAITQUEUE(wq, current);
2795 
2796 			add_wait_queue(&jfs_commit_thread_wait, &wq);
2797 			set_current_state(TASK_INTERRUPTIBLE);
2798 			LAZY_UNLOCK(flags);
2799 			schedule();
2800 			__set_current_state(TASK_RUNNING);
2801 			remove_wait_queue(&jfs_commit_thread_wait, &wq);
2802 		}
2803 	} while (!kthread_should_stop());
2804 
2805 	if (!list_empty(&TxAnchor.unlock_queue))
2806 		jfs_err("jfs_lazycommit being killed w/pending transactions!");
2807 	else
2808 		jfs_info("jfs_lazycommit being killed\n");
2809 	return 0;
2810 }
2811 
2812 void txLazyUnlock(struct tblock * tblk)
2813 {
2814 	unsigned long flags;
2815 
2816 	LAZY_LOCK(flags);
2817 
2818 	list_add_tail(&tblk->cqueue, &TxAnchor.unlock_queue);
2819 	/*
2820 	 * Don't wake up a commit thread if there is already one servicing
2821 	 * this superblock, or if the last one we woke up hasn't started yet.
2822 	 */
2823 	if (!(JFS_SBI(tblk->sb)->commit_state & IN_LAZYCOMMIT) &&
2824 	    !jfs_commit_thread_waking) {
2825 		jfs_commit_thread_waking = 1;
2826 		wake_up(&jfs_commit_thread_wait);
2827 	}
2828 	LAZY_UNLOCK(flags);
2829 }
2830 
2831 static void LogSyncRelease(struct metapage * mp)
2832 {
2833 	struct jfs_log *log = mp->log;
2834 
2835 	assert(mp->nohomeok);
2836 	assert(log);
2837 	metapage_homeok(mp);
2838 }
2839 
2840 /*
2841  *	txQuiesce
2842  *
2843  *	Block all new transactions and push anonymous transactions to
2844  *	completion
2845  *
2846  *	This does almost the same thing as jfs_sync below.  We don't
2847  *	worry about deadlocking when jfs_tlocks_low is set, since we would
2848  *	expect jfs_sync to get us out of that jam.
2849  */
2850 void txQuiesce(struct super_block *sb)
2851 {
2852 	struct inode *ip;
2853 	struct jfs_inode_info *jfs_ip;
2854 	struct jfs_log *log = JFS_SBI(sb)->log;
2855 	tid_t tid;
2856 
2857 	set_bit(log_QUIESCE, &log->flag);
2858 
2859 	TXN_LOCK();
2860 restart:
2861 	while (!list_empty(&TxAnchor.anon_list)) {
2862 		jfs_ip = list_entry(TxAnchor.anon_list.next,
2863 				    struct jfs_inode_info,
2864 				    anon_inode_list);
2865 		ip = &jfs_ip->vfs_inode;
2866 
2867 		/*
2868 		 * inode will be removed from anonymous list
2869 		 * when it is committed
2870 		 */
2871 		TXN_UNLOCK();
2872 		tid = txBegin(ip->i_sb, COMMIT_INODE | COMMIT_FORCE);
2873 		mutex_lock(&jfs_ip->commit_mutex);
2874 		txCommit(tid, 1, &ip, 0);
2875 		txEnd(tid);
2876 		mutex_unlock(&jfs_ip->commit_mutex);
2877 		/*
2878 		 * Just to be safe.  I don't know how
2879 		 * long we can run without blocking
2880 		 */
2881 		cond_resched();
2882 		TXN_LOCK();
2883 	}
2884 
2885 	/*
2886 	 * If jfs_sync is running in parallel, there could be some inodes
2887 	 * on anon_list2.  Let's check.
2888 	 */
2889 	if (!list_empty(&TxAnchor.anon_list2)) {
2890 		list_splice(&TxAnchor.anon_list2, &TxAnchor.anon_list);
2891 		INIT_LIST_HEAD(&TxAnchor.anon_list2);
2892 		goto restart;
2893 	}
2894 	TXN_UNLOCK();
2895 
2896 	/*
2897 	 * We may need to kick off the group commit
2898 	 */
2899 	jfs_flush_journal(log, 0);
2900 }
2901 
2902 /*
2903  * txResume()
2904  *
2905  * Allows transactions to start again following txQuiesce
2906  */
2907 void txResume(struct super_block *sb)
2908 {
2909 	struct jfs_log *log = JFS_SBI(sb)->log;
2910 
2911 	clear_bit(log_QUIESCE, &log->flag);
2912 	TXN_WAKEUP(&log->syncwait);
2913 }
2914 
2915 /*
2916  *      jfs_sync(void)
2917  *
2918  *	To be run as a kernel daemon.  This is awakened when tlocks run low.
2919  *	We write any inodes that have anonymous tlocks so they will become
2920  *	available.
2921  */
2922 int jfs_sync(void *arg)
2923 {
2924 	struct inode *ip;
2925 	struct jfs_inode_info *jfs_ip;
2926 	int rc;
2927 	tid_t tid;
2928 
2929 	do {
2930 		/*
2931 		 * write each inode on the anonymous inode list
2932 		 */
2933 		TXN_LOCK();
2934 		while (jfs_tlocks_low && !list_empty(&TxAnchor.anon_list)) {
2935 			jfs_ip = list_entry(TxAnchor.anon_list.next,
2936 					    struct jfs_inode_info,
2937 					    anon_inode_list);
2938 			ip = &jfs_ip->vfs_inode;
2939 
2940 			if (! igrab(ip)) {
2941 				/*
2942 				 * Inode is being freed
2943 				 */
2944 				list_del_init(&jfs_ip->anon_inode_list);
2945 			} else if (mutex_trylock(&jfs_ip->commit_mutex)) {
2946 				/*
2947 				 * inode will be removed from anonymous list
2948 				 * when it is committed
2949 				 */
2950 				TXN_UNLOCK();
2951 				tid = txBegin(ip->i_sb, COMMIT_INODE);
2952 				rc = txCommit(tid, 1, &ip, 0);
2953 				txEnd(tid);
2954 				mutex_unlock(&jfs_ip->commit_mutex);
2955 
2956 				iput(ip);
2957 				/*
2958 				 * Just to be safe.  I don't know how
2959 				 * long we can run without blocking
2960 				 */
2961 				cond_resched();
2962 				TXN_LOCK();
2963 			} else {
2964 				/* We can't get the commit mutex.  It may
2965 				 * be held by a thread waiting for tlock's
2966 				 * so let's not block here.  Save it to
2967 				 * put back on the anon_list.
2968 				 */
2969 
2970 				/* Take off anon_list */
2971 				list_del(&jfs_ip->anon_inode_list);
2972 
2973 				/* Put on anon_list2 */
2974 				list_add(&jfs_ip->anon_inode_list,
2975 					 &TxAnchor.anon_list2);
2976 
2977 				TXN_UNLOCK();
2978 				iput(ip);
2979 				TXN_LOCK();
2980 			}
2981 		}
2982 		/* Add anon_list2 back to anon_list */
2983 		list_splice_init(&TxAnchor.anon_list2, &TxAnchor.anon_list);
2984 
2985 		if (freezing(current)) {
2986 			TXN_UNLOCK();
2987 			refrigerator();
2988 		} else {
2989 			set_current_state(TASK_INTERRUPTIBLE);
2990 			TXN_UNLOCK();
2991 			schedule();
2992 			__set_current_state(TASK_RUNNING);
2993 		}
2994 	} while (!kthread_should_stop());
2995 
2996 	jfs_info("jfs_sync being killed");
2997 	return 0;
2998 }
2999 
3000 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_DEBUG)
3001 int jfs_txanchor_read(char *buffer, char **start, off_t offset, int length,
3002 		      int *eof, void *data)
3003 {
3004 	int len = 0;
3005 	off_t begin;
3006 	char *freewait;
3007 	char *freelockwait;
3008 	char *lowlockwait;
3009 
3010 	freewait =
3011 	    waitqueue_active(&TxAnchor.freewait) ? "active" : "empty";
3012 	freelockwait =
3013 	    waitqueue_active(&TxAnchor.freelockwait) ? "active" : "empty";
3014 	lowlockwait =
3015 	    waitqueue_active(&TxAnchor.lowlockwait) ? "active" : "empty";
3016 
3017 	len += sprintf(buffer,
3018 		       "JFS TxAnchor\n"
3019 		       "============\n"
3020 		       "freetid = %d\n"
3021 		       "freewait = %s\n"
3022 		       "freelock = %d\n"
3023 		       "freelockwait = %s\n"
3024 		       "lowlockwait = %s\n"
3025 		       "tlocksInUse = %d\n"
3026 		       "jfs_tlocks_low = %d\n"
3027 		       "unlock_queue is %sempty\n",
3028 		       TxAnchor.freetid,
3029 		       freewait,
3030 		       TxAnchor.freelock,
3031 		       freelockwait,
3032 		       lowlockwait,
3033 		       TxAnchor.tlocksInUse,
3034 		       jfs_tlocks_low,
3035 		       list_empty(&TxAnchor.unlock_queue) ? "" : "not ");
3036 
3037 	begin = offset;
3038 	*start = buffer + begin;
3039 	len -= begin;
3040 
3041 	if (len > length)
3042 		len = length;
3043 	else
3044 		*eof = 1;
3045 
3046 	if (len < 0)
3047 		len = 0;
3048 
3049 	return len;
3050 }
3051 #endif
3052 
3053 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_STATISTICS)
3054 int jfs_txstats_read(char *buffer, char **start, off_t offset, int length,
3055 		     int *eof, void *data)
3056 {
3057 	int len = 0;
3058 	off_t begin;
3059 
3060 	len += sprintf(buffer,
3061 		       "JFS TxStats\n"
3062 		       "===========\n"
3063 		       "calls to txBegin = %d\n"
3064 		       "txBegin blocked by sync barrier = %d\n"
3065 		       "txBegin blocked by tlocks low = %d\n"
3066 		       "txBegin blocked by no free tid = %d\n"
3067 		       "calls to txBeginAnon = %d\n"
3068 		       "txBeginAnon blocked by sync barrier = %d\n"
3069 		       "txBeginAnon blocked by tlocks low = %d\n"
3070 		       "calls to txLockAlloc = %d\n"
3071 		       "tLockAlloc blocked by no free lock = %d\n",
3072 		       TxStat.txBegin,
3073 		       TxStat.txBegin_barrier,
3074 		       TxStat.txBegin_lockslow,
3075 		       TxStat.txBegin_freetid,
3076 		       TxStat.txBeginAnon,
3077 		       TxStat.txBeginAnon_barrier,
3078 		       TxStat.txBeginAnon_lockslow,
3079 		       TxStat.txLockAlloc,
3080 		       TxStat.txLockAlloc_freelock);
3081 
3082 	begin = offset;
3083 	*start = buffer + begin;
3084 	len -= begin;
3085 
3086 	if (len > length)
3087 		len = length;
3088 	else
3089 		*eof = 1;
3090 
3091 	if (len < 0)
3092 		len = 0;
3093 
3094 	return len;
3095 }
3096 #endif
3097