xref: /openbmc/linux/fs/jfs/jfs_txnmgr.c (revision 64c70b1c)
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 		printk(KERN_ERR "txLock: trying to lock locked page!");
833 		print_hex_dump(KERN_ERR, "ip: ", DUMP_PREFIX_ADDRESS, 16, 4,
834 			       ip, sizeof(*ip), 0);
835 		print_hex_dump(KERN_ERR, "mp: ", DUMP_PREFIX_ADDRESS, 16, 4,
836 			       mp, sizeof(*mp), 0);
837 		print_hex_dump(KERN_ERR, "Locker's tblock: ",
838 			       DUMP_PREFIX_ADDRESS, 16, 4, tid_to_tblock(tid),
839 			       sizeof(struct tblock), 0);
840 		print_hex_dump(KERN_ERR, "Tlock: ", DUMP_PREFIX_ADDRESS, 16, 4,
841 			       tlck, sizeof(*tlck), 0);
842 		BUG();
843 	}
844 	INCREMENT(stattx.waitlock);	/* statistics */
845 	TXN_UNLOCK();
846 	release_metapage(mp);
847 	TXN_LOCK();
848 	xtid = tlck->tid;	/* reacquire after dropping TXN_LOCK */
849 
850 	jfs_info("txLock: in waitLock, tid = %d, xtid = %d, lid = %d",
851 		 tid, xtid, lid);
852 
853 	/* Recheck everything since dropping TXN_LOCK */
854 	if (xtid && (tlck->mp == mp) && (mp->lid == lid))
855 		TXN_SLEEP_DROP_LOCK(&tid_to_tblock(xtid)->waitor);
856 	else
857 		TXN_UNLOCK();
858 	jfs_info("txLock: awakened     tid = %d, lid = %d", tid, lid);
859 
860 	return NULL;
861 }
862 
863 /*
864  * NAME:	txRelease()
865  *
866  * FUNCTION:	Release buffers associated with transaction locks, but don't
867  *		mark homeok yet.  The allows other transactions to modify
868  *		buffers, but won't let them go to disk until commit record
869  *		actually gets written.
870  *
871  * PARAMETER:
872  *		tblk	-
873  *
874  * RETURN:	Errors from subroutines.
875  */
876 static void txRelease(struct tblock * tblk)
877 {
878 	struct metapage *mp;
879 	lid_t lid;
880 	struct tlock *tlck;
881 
882 	TXN_LOCK();
883 
884 	for (lid = tblk->next; lid; lid = tlck->next) {
885 		tlck = lid_to_tlock(lid);
886 		if ((mp = tlck->mp) != NULL &&
887 		    (tlck->type & tlckBTROOT) == 0) {
888 			assert(mp->xflag & COMMIT_PAGE);
889 			mp->lid = 0;
890 		}
891 	}
892 
893 	/*
894 	 * wakeup transactions waiting on a page locked
895 	 * by the current transaction
896 	 */
897 	TXN_WAKEUP(&tblk->waitor);
898 
899 	TXN_UNLOCK();
900 }
901 
902 /*
903  * NAME:	txUnlock()
904  *
905  * FUNCTION:	Initiates pageout of pages modified by tid in journalled
906  *		objects and frees their lockwords.
907  */
908 static void txUnlock(struct tblock * tblk)
909 {
910 	struct tlock *tlck;
911 	struct linelock *linelock;
912 	lid_t lid, next, llid, k;
913 	struct metapage *mp;
914 	struct jfs_log *log;
915 	int difft, diffp;
916 	unsigned long flags;
917 
918 	jfs_info("txUnlock: tblk = 0x%p", tblk);
919 	log = JFS_SBI(tblk->sb)->log;
920 
921 	/*
922 	 * mark page under tlock homeok (its log has been written):
923 	 */
924 	for (lid = tblk->next; lid; lid = next) {
925 		tlck = lid_to_tlock(lid);
926 		next = tlck->next;
927 
928 		jfs_info("unlocking lid = %d, tlck = 0x%p", lid, tlck);
929 
930 		/* unbind page from tlock */
931 		if ((mp = tlck->mp) != NULL &&
932 		    (tlck->type & tlckBTROOT) == 0) {
933 			assert(mp->xflag & COMMIT_PAGE);
934 
935 			/* hold buffer
936 			 */
937 			hold_metapage(mp);
938 
939 			assert(mp->nohomeok > 0);
940 			_metapage_homeok(mp);
941 
942 			/* inherit younger/larger clsn */
943 			LOGSYNC_LOCK(log, flags);
944 			if (mp->clsn) {
945 				logdiff(difft, tblk->clsn, log);
946 				logdiff(diffp, mp->clsn, log);
947 				if (difft > diffp)
948 					mp->clsn = tblk->clsn;
949 			} else
950 				mp->clsn = tblk->clsn;
951 			LOGSYNC_UNLOCK(log, flags);
952 
953 			assert(!(tlck->flag & tlckFREEPAGE));
954 
955 			put_metapage(mp);
956 		}
957 
958 		/* insert tlock, and linelock(s) of the tlock if any,
959 		 * at head of freelist
960 		 */
961 		TXN_LOCK();
962 
963 		llid = ((struct linelock *) & tlck->lock)->next;
964 		while (llid) {
965 			linelock = (struct linelock *) lid_to_tlock(llid);
966 			k = linelock->next;
967 			txLockFree(llid);
968 			llid = k;
969 		}
970 		txLockFree(lid);
971 
972 		TXN_UNLOCK();
973 	}
974 	tblk->next = tblk->last = 0;
975 
976 	/*
977 	 * remove tblock from logsynclist
978 	 * (allocation map pages inherited lsn of tblk and
979 	 * has been inserted in logsync list at txUpdateMap())
980 	 */
981 	if (tblk->lsn) {
982 		LOGSYNC_LOCK(log, flags);
983 		log->count--;
984 		list_del(&tblk->synclist);
985 		LOGSYNC_UNLOCK(log, flags);
986 	}
987 }
988 
989 /*
990  *	txMaplock()
991  *
992  * function: allocate a transaction lock for freed page/entry;
993  *	for freed page, maplock is used as xtlock/dtlock type;
994  */
995 struct tlock *txMaplock(tid_t tid, struct inode *ip, int type)
996 {
997 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
998 	lid_t lid;
999 	struct tblock *tblk;
1000 	struct tlock *tlck;
1001 	struct maplock *maplock;
1002 
1003 	TXN_LOCK();
1004 
1005 	/*
1006 	 * allocate a tlock
1007 	 */
1008 	lid = txLockAlloc();
1009 	tlck = lid_to_tlock(lid);
1010 
1011 	/*
1012 	 * initialize tlock
1013 	 */
1014 	tlck->tid = tid;
1015 
1016 	/* bind the tlock and the object */
1017 	tlck->flag = tlckINODELOCK;
1018 	if (S_ISDIR(ip->i_mode))
1019 		tlck->flag |= tlckDIRECTORY;
1020 	tlck->ip = ip;
1021 	tlck->mp = NULL;
1022 
1023 	tlck->type = type;
1024 
1025 	/*
1026 	 * enqueue transaction lock to transaction/inode
1027 	 */
1028 	/* insert the tlock at tail of transaction tlock list */
1029 	if (tid) {
1030 		tblk = tid_to_tblock(tid);
1031 		if (tblk->next)
1032 			lid_to_tlock(tblk->last)->next = lid;
1033 		else
1034 			tblk->next = lid;
1035 		tlck->next = 0;
1036 		tblk->last = lid;
1037 	}
1038 	/* anonymous transaction:
1039 	 * insert the tlock at head of inode anonymous tlock list
1040 	 */
1041 	else {
1042 		tlck->next = jfs_ip->atlhead;
1043 		jfs_ip->atlhead = lid;
1044 		if (tlck->next == 0) {
1045 			/* This inode's first anonymous transaction */
1046 			jfs_ip->atltail = lid;
1047 			list_add_tail(&jfs_ip->anon_inode_list,
1048 				      &TxAnchor.anon_list);
1049 		}
1050 	}
1051 
1052 	TXN_UNLOCK();
1053 
1054 	/* initialize type dependent area for maplock */
1055 	maplock = (struct maplock *) & tlck->lock;
1056 	maplock->next = 0;
1057 	maplock->maxcnt = 0;
1058 	maplock->index = 0;
1059 
1060 	return tlck;
1061 }
1062 
1063 /*
1064  *	txLinelock()
1065  *
1066  * function: allocate a transaction lock for log vector list
1067  */
1068 struct linelock *txLinelock(struct linelock * tlock)
1069 {
1070 	lid_t lid;
1071 	struct tlock *tlck;
1072 	struct linelock *linelock;
1073 
1074 	TXN_LOCK();
1075 
1076 	/* allocate a TxLock structure */
1077 	lid = txLockAlloc();
1078 	tlck = lid_to_tlock(lid);
1079 
1080 	TXN_UNLOCK();
1081 
1082 	/* initialize linelock */
1083 	linelock = (struct linelock *) tlck;
1084 	linelock->next = 0;
1085 	linelock->flag = tlckLINELOCK;
1086 	linelock->maxcnt = TLOCKLONG;
1087 	linelock->index = 0;
1088 	if (tlck->flag & tlckDIRECTORY)
1089 		linelock->flag |= tlckDIRECTORY;
1090 
1091 	/* append linelock after tlock */
1092 	linelock->next = tlock->next;
1093 	tlock->next = lid;
1094 
1095 	return linelock;
1096 }
1097 
1098 /*
1099  *		transaction commit management
1100  *		-----------------------------
1101  */
1102 
1103 /*
1104  * NAME:	txCommit()
1105  *
1106  * FUNCTION:	commit the changes to the objects specified in
1107  *		clist.  For journalled segments only the
1108  *		changes of the caller are committed, ie by tid.
1109  *		for non-journalled segments the data are flushed to
1110  *		disk and then the change to the disk inode and indirect
1111  *		blocks committed (so blocks newly allocated to the
1112  *		segment will be made a part of the segment atomically).
1113  *
1114  *		all of the segments specified in clist must be in
1115  *		one file system. no more than 6 segments are needed
1116  *		to handle all unix svcs.
1117  *
1118  *		if the i_nlink field (i.e. disk inode link count)
1119  *		is zero, and the type of inode is a regular file or
1120  *		directory, or symbolic link , the inode is truncated
1121  *		to zero length. the truncation is committed but the
1122  *		VM resources are unaffected until it is closed (see
1123  *		iput and iclose).
1124  *
1125  * PARAMETER:
1126  *
1127  * RETURN:
1128  *
1129  * serialization:
1130  *		on entry the inode lock on each segment is assumed
1131  *		to be held.
1132  *
1133  * i/o error:
1134  */
1135 int txCommit(tid_t tid,		/* transaction identifier */
1136 	     int nip,		/* number of inodes to commit */
1137 	     struct inode **iplist,	/* list of inode to commit */
1138 	     int flag)
1139 {
1140 	int rc = 0;
1141 	struct commit cd;
1142 	struct jfs_log *log;
1143 	struct tblock *tblk;
1144 	struct lrd *lrd;
1145 	int lsn;
1146 	struct inode *ip;
1147 	struct jfs_inode_info *jfs_ip;
1148 	int k, n;
1149 	ino_t top;
1150 	struct super_block *sb;
1151 
1152 	jfs_info("txCommit, tid = %d, flag = %d", tid, flag);
1153 	/* is read-only file system ? */
1154 	if (isReadOnly(iplist[0])) {
1155 		rc = -EROFS;
1156 		goto TheEnd;
1157 	}
1158 
1159 	sb = cd.sb = iplist[0]->i_sb;
1160 	cd.tid = tid;
1161 
1162 	if (tid == 0)
1163 		tid = txBegin(sb, 0);
1164 	tblk = tid_to_tblock(tid);
1165 
1166 	/*
1167 	 * initialize commit structure
1168 	 */
1169 	log = JFS_SBI(sb)->log;
1170 	cd.log = log;
1171 
1172 	/* initialize log record descriptor in commit */
1173 	lrd = &cd.lrd;
1174 	lrd->logtid = cpu_to_le32(tblk->logtid);
1175 	lrd->backchain = 0;
1176 
1177 	tblk->xflag |= flag;
1178 
1179 	if ((flag & (COMMIT_FORCE | COMMIT_SYNC)) == 0)
1180 		tblk->xflag |= COMMIT_LAZY;
1181 	/*
1182 	 *	prepare non-journaled objects for commit
1183 	 *
1184 	 * flush data pages of non-journaled file
1185 	 * to prevent the file getting non-initialized disk blocks
1186 	 * in case of crash.
1187 	 * (new blocks - )
1188 	 */
1189 	cd.iplist = iplist;
1190 	cd.nip = nip;
1191 
1192 	/*
1193 	 *	acquire transaction lock on (on-disk) inodes
1194 	 *
1195 	 * update on-disk inode from in-memory inode
1196 	 * acquiring transaction locks for AFTER records
1197 	 * on the on-disk inode of file object
1198 	 *
1199 	 * sort the inodes array by inode number in descending order
1200 	 * to prevent deadlock when acquiring transaction lock
1201 	 * of on-disk inodes on multiple on-disk inode pages by
1202 	 * multiple concurrent transactions
1203 	 */
1204 	for (k = 0; k < cd.nip; k++) {
1205 		top = (cd.iplist[k])->i_ino;
1206 		for (n = k + 1; n < cd.nip; n++) {
1207 			ip = cd.iplist[n];
1208 			if (ip->i_ino > top) {
1209 				top = ip->i_ino;
1210 				cd.iplist[n] = cd.iplist[k];
1211 				cd.iplist[k] = ip;
1212 			}
1213 		}
1214 
1215 		ip = cd.iplist[k];
1216 		jfs_ip = JFS_IP(ip);
1217 
1218 		/*
1219 		 * BUGBUG - This code has temporarily been removed.  The
1220 		 * intent is to ensure that any file data is written before
1221 		 * the metadata is committed to the journal.  This prevents
1222 		 * uninitialized data from appearing in a file after the
1223 		 * journal has been replayed.  (The uninitialized data
1224 		 * could be sensitive data removed by another user.)
1225 		 *
1226 		 * The problem now is that we are holding the IWRITELOCK
1227 		 * on the inode, and calling filemap_fdatawrite on an
1228 		 * unmapped page will cause a deadlock in jfs_get_block.
1229 		 *
1230 		 * The long term solution is to pare down the use of
1231 		 * IWRITELOCK.  We are currently holding it too long.
1232 		 * We could also be smarter about which data pages need
1233 		 * to be written before the transaction is committed and
1234 		 * when we don't need to worry about it at all.
1235 		 *
1236 		 * if ((!S_ISDIR(ip->i_mode))
1237 		 *    && (tblk->flag & COMMIT_DELETE) == 0)
1238 		 *	filemap_write_and_wait(ip->i_mapping);
1239 		 */
1240 
1241 		/*
1242 		 * Mark inode as not dirty.  It will still be on the dirty
1243 		 * inode list, but we'll know not to commit it again unless
1244 		 * it gets marked dirty again
1245 		 */
1246 		clear_cflag(COMMIT_Dirty, ip);
1247 
1248 		/* inherit anonymous tlock(s) of inode */
1249 		if (jfs_ip->atlhead) {
1250 			lid_to_tlock(jfs_ip->atltail)->next = tblk->next;
1251 			tblk->next = jfs_ip->atlhead;
1252 			if (!tblk->last)
1253 				tblk->last = jfs_ip->atltail;
1254 			jfs_ip->atlhead = jfs_ip->atltail = 0;
1255 			TXN_LOCK();
1256 			list_del_init(&jfs_ip->anon_inode_list);
1257 			TXN_UNLOCK();
1258 		}
1259 
1260 		/*
1261 		 * acquire transaction lock on on-disk inode page
1262 		 * (become first tlock of the tblk's tlock list)
1263 		 */
1264 		if (((rc = diWrite(tid, ip))))
1265 			goto out;
1266 	}
1267 
1268 	/*
1269 	 *	write log records from transaction locks
1270 	 *
1271 	 * txUpdateMap() resets XAD_NEW in XAD.
1272 	 */
1273 	if ((rc = txLog(log, tblk, &cd)))
1274 		goto TheEnd;
1275 
1276 	/*
1277 	 * Ensure that inode isn't reused before
1278 	 * lazy commit thread finishes processing
1279 	 */
1280 	if (tblk->xflag & COMMIT_DELETE) {
1281 		atomic_inc(&tblk->u.ip->i_count);
1282 		/*
1283 		 * Avoid a rare deadlock
1284 		 *
1285 		 * If the inode is locked, we may be blocked in
1286 		 * jfs_commit_inode.  If so, we don't want the
1287 		 * lazy_commit thread doing the last iput() on the inode
1288 		 * since that may block on the locked inode.  Instead,
1289 		 * commit the transaction synchronously, so the last iput
1290 		 * will be done by the calling thread (or later)
1291 		 */
1292 		if (tblk->u.ip->i_state & I_LOCK)
1293 			tblk->xflag &= ~COMMIT_LAZY;
1294 	}
1295 
1296 	ASSERT((!(tblk->xflag & COMMIT_DELETE)) ||
1297 	       ((tblk->u.ip->i_nlink == 0) &&
1298 		!test_cflag(COMMIT_Nolink, tblk->u.ip)));
1299 
1300 	/*
1301 	 *	write COMMIT log record
1302 	 */
1303 	lrd->type = cpu_to_le16(LOG_COMMIT);
1304 	lrd->length = 0;
1305 	lsn = lmLog(log, tblk, lrd, NULL);
1306 
1307 	lmGroupCommit(log, tblk);
1308 
1309 	/*
1310 	 *	- transaction is now committed -
1311 	 */
1312 
1313 	/*
1314 	 * force pages in careful update
1315 	 * (imap addressing structure update)
1316 	 */
1317 	if (flag & COMMIT_FORCE)
1318 		txForce(tblk);
1319 
1320 	/*
1321 	 *	update allocation map.
1322 	 *
1323 	 * update inode allocation map and inode:
1324 	 * free pager lock on memory object of inode if any.
1325 	 * update block allocation map.
1326 	 *
1327 	 * txUpdateMap() resets XAD_NEW in XAD.
1328 	 */
1329 	if (tblk->xflag & COMMIT_FORCE)
1330 		txUpdateMap(tblk);
1331 
1332 	/*
1333 	 *	free transaction locks and pageout/free pages
1334 	 */
1335 	txRelease(tblk);
1336 
1337 	if ((tblk->flag & tblkGC_LAZY) == 0)
1338 		txUnlock(tblk);
1339 
1340 
1341 	/*
1342 	 *	reset in-memory object state
1343 	 */
1344 	for (k = 0; k < cd.nip; k++) {
1345 		ip = cd.iplist[k];
1346 		jfs_ip = JFS_IP(ip);
1347 
1348 		/*
1349 		 * reset in-memory inode state
1350 		 */
1351 		jfs_ip->bxflag = 0;
1352 		jfs_ip->blid = 0;
1353 	}
1354 
1355       out:
1356 	if (rc != 0)
1357 		txAbort(tid, 1);
1358 
1359       TheEnd:
1360 	jfs_info("txCommit: tid = %d, returning %d", tid, rc);
1361 	return rc;
1362 }
1363 
1364 /*
1365  * NAME:	txLog()
1366  *
1367  * FUNCTION:	Writes AFTER log records for all lines modified
1368  *		by tid for segments specified by inodes in comdata.
1369  *		Code assumes only WRITELOCKS are recorded in lockwords.
1370  *
1371  * PARAMETERS:
1372  *
1373  * RETURN :
1374  */
1375 static int txLog(struct jfs_log * log, struct tblock * tblk, struct commit * cd)
1376 {
1377 	int rc = 0;
1378 	struct inode *ip;
1379 	lid_t lid;
1380 	struct tlock *tlck;
1381 	struct lrd *lrd = &cd->lrd;
1382 
1383 	/*
1384 	 * write log record(s) for each tlock of transaction,
1385 	 */
1386 	for (lid = tblk->next; lid; lid = tlck->next) {
1387 		tlck = lid_to_tlock(lid);
1388 
1389 		tlck->flag |= tlckLOG;
1390 
1391 		/* initialize lrd common */
1392 		ip = tlck->ip;
1393 		lrd->aggregate = cpu_to_le32(JFS_SBI(ip->i_sb)->aggregate);
1394 		lrd->log.redopage.fileset = cpu_to_le32(JFS_IP(ip)->fileset);
1395 		lrd->log.redopage.inode = cpu_to_le32(ip->i_ino);
1396 
1397 		/* write log record of page from the tlock */
1398 		switch (tlck->type & tlckTYPE) {
1399 		case tlckXTREE:
1400 			xtLog(log, tblk, lrd, tlck);
1401 			break;
1402 
1403 		case tlckDTREE:
1404 			dtLog(log, tblk, lrd, tlck);
1405 			break;
1406 
1407 		case tlckINODE:
1408 			diLog(log, tblk, lrd, tlck, cd);
1409 			break;
1410 
1411 		case tlckMAP:
1412 			mapLog(log, tblk, lrd, tlck);
1413 			break;
1414 
1415 		case tlckDATA:
1416 			dataLog(log, tblk, lrd, tlck);
1417 			break;
1418 
1419 		default:
1420 			jfs_err("UFO tlock:0x%p", tlck);
1421 		}
1422 	}
1423 
1424 	return rc;
1425 }
1426 
1427 /*
1428  *	diLog()
1429  *
1430  * function:	log inode tlock and format maplock to update bmap;
1431  */
1432 static int diLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1433 		 struct tlock * tlck, struct commit * cd)
1434 {
1435 	int rc = 0;
1436 	struct metapage *mp;
1437 	pxd_t *pxd;
1438 	struct pxd_lock *pxdlock;
1439 
1440 	mp = tlck->mp;
1441 
1442 	/* initialize as REDOPAGE record format */
1443 	lrd->log.redopage.type = cpu_to_le16(LOG_INODE);
1444 	lrd->log.redopage.l2linesize = cpu_to_le16(L2INODESLOTSIZE);
1445 
1446 	pxd = &lrd->log.redopage.pxd;
1447 
1448 	/*
1449 	 *	inode after image
1450 	 */
1451 	if (tlck->type & tlckENTRY) {
1452 		/* log after-image for logredo(): */
1453 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1454 		PXDaddress(pxd, mp->index);
1455 		PXDlength(pxd,
1456 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1457 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1458 
1459 		/* mark page as homeward bound */
1460 		tlck->flag |= tlckWRITEPAGE;
1461 	} else if (tlck->type & tlckFREE) {
1462 		/*
1463 		 *	free inode extent
1464 		 *
1465 		 * (pages of the freed inode extent have been invalidated and
1466 		 * a maplock for free of the extent has been formatted at
1467 		 * txLock() time);
1468 		 *
1469 		 * the tlock had been acquired on the inode allocation map page
1470 		 * (iag) that specifies the freed extent, even though the map
1471 		 * page is not itself logged, to prevent pageout of the map
1472 		 * page before the log;
1473 		 */
1474 
1475 		/* log LOG_NOREDOINOEXT of the freed inode extent for
1476 		 * logredo() to start NoRedoPage filters, and to update
1477 		 * imap and bmap for free of the extent;
1478 		 */
1479 		lrd->type = cpu_to_le16(LOG_NOREDOINOEXT);
1480 		/*
1481 		 * For the LOG_NOREDOINOEXT record, we need
1482 		 * to pass the IAG number and inode extent
1483 		 * index (within that IAG) from which the
1484 		 * the extent being released.  These have been
1485 		 * passed to us in the iplist[1] and iplist[2].
1486 		 */
1487 		lrd->log.noredoinoext.iagnum =
1488 		    cpu_to_le32((u32) (size_t) cd->iplist[1]);
1489 		lrd->log.noredoinoext.inoext_idx =
1490 		    cpu_to_le32((u32) (size_t) cd->iplist[2]);
1491 
1492 		pxdlock = (struct pxd_lock *) & tlck->lock;
1493 		*pxd = pxdlock->pxd;
1494 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1495 
1496 		/* update bmap */
1497 		tlck->flag |= tlckUPDATEMAP;
1498 
1499 		/* mark page as homeward bound */
1500 		tlck->flag |= tlckWRITEPAGE;
1501 	} else
1502 		jfs_err("diLog: UFO type tlck:0x%p", tlck);
1503 #ifdef  _JFS_WIP
1504 	/*
1505 	 *	alloc/free external EA extent
1506 	 *
1507 	 * a maplock for txUpdateMap() to update bPWMAP for alloc/free
1508 	 * of the extent has been formatted at txLock() time;
1509 	 */
1510 	else {
1511 		assert(tlck->type & tlckEA);
1512 
1513 		/* log LOG_UPDATEMAP for logredo() to update bmap for
1514 		 * alloc of new (and free of old) external EA extent;
1515 		 */
1516 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1517 		pxdlock = (struct pxd_lock *) & tlck->lock;
1518 		nlock = pxdlock->index;
1519 		for (i = 0; i < nlock; i++, pxdlock++) {
1520 			if (pxdlock->flag & mlckALLOCPXD)
1521 				lrd->log.updatemap.type =
1522 				    cpu_to_le16(LOG_ALLOCPXD);
1523 			else
1524 				lrd->log.updatemap.type =
1525 				    cpu_to_le16(LOG_FREEPXD);
1526 			lrd->log.updatemap.nxd = cpu_to_le16(1);
1527 			lrd->log.updatemap.pxd = pxdlock->pxd;
1528 			lrd->backchain =
1529 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1530 		}
1531 
1532 		/* update bmap */
1533 		tlck->flag |= tlckUPDATEMAP;
1534 	}
1535 #endif				/* _JFS_WIP */
1536 
1537 	return rc;
1538 }
1539 
1540 /*
1541  *	dataLog()
1542  *
1543  * function:	log data tlock
1544  */
1545 static int dataLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1546 	    struct tlock * tlck)
1547 {
1548 	struct metapage *mp;
1549 	pxd_t *pxd;
1550 
1551 	mp = tlck->mp;
1552 
1553 	/* initialize as REDOPAGE record format */
1554 	lrd->log.redopage.type = cpu_to_le16(LOG_DATA);
1555 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DATASLOTSIZE);
1556 
1557 	pxd = &lrd->log.redopage.pxd;
1558 
1559 	/* log after-image for logredo(): */
1560 	lrd->type = cpu_to_le16(LOG_REDOPAGE);
1561 
1562 	if (jfs_dirtable_inline(tlck->ip)) {
1563 		/*
1564 		 * The table has been truncated, we've must have deleted
1565 		 * the last entry, so don't bother logging this
1566 		 */
1567 		mp->lid = 0;
1568 		grab_metapage(mp);
1569 		metapage_homeok(mp);
1570 		discard_metapage(mp);
1571 		tlck->mp = NULL;
1572 		return 0;
1573 	}
1574 
1575 	PXDaddress(pxd, mp->index);
1576 	PXDlength(pxd, mp->logical_size >> tblk->sb->s_blocksize_bits);
1577 
1578 	lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1579 
1580 	/* mark page as homeward bound */
1581 	tlck->flag |= tlckWRITEPAGE;
1582 
1583 	return 0;
1584 }
1585 
1586 /*
1587  *	dtLog()
1588  *
1589  * function:	log dtree tlock and format maplock to update bmap;
1590  */
1591 static void dtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1592 	   struct tlock * tlck)
1593 {
1594 	struct metapage *mp;
1595 	struct pxd_lock *pxdlock;
1596 	pxd_t *pxd;
1597 
1598 	mp = tlck->mp;
1599 
1600 	/* initialize as REDOPAGE/NOREDOPAGE record format */
1601 	lrd->log.redopage.type = cpu_to_le16(LOG_DTREE);
1602 	lrd->log.redopage.l2linesize = cpu_to_le16(L2DTSLOTSIZE);
1603 
1604 	pxd = &lrd->log.redopage.pxd;
1605 
1606 	if (tlck->type & tlckBTROOT)
1607 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
1608 
1609 	/*
1610 	 *	page extension via relocation: entry insertion;
1611 	 *	page extension in-place: entry insertion;
1612 	 *	new right page from page split, reinitialized in-line
1613 	 *	root from root page split: entry insertion;
1614 	 */
1615 	if (tlck->type & (tlckNEW | tlckEXTEND)) {
1616 		/* log after-image of the new page for logredo():
1617 		 * mark log (LOG_NEW) for logredo() to initialize
1618 		 * freelist and update bmap for alloc of the new page;
1619 		 */
1620 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1621 		if (tlck->type & tlckEXTEND)
1622 			lrd->log.redopage.type |= cpu_to_le16(LOG_EXTEND);
1623 		else
1624 			lrd->log.redopage.type |= cpu_to_le16(LOG_NEW);
1625 		PXDaddress(pxd, mp->index);
1626 		PXDlength(pxd,
1627 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1628 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1629 
1630 		/* format a maplock for txUpdateMap() to update bPMAP for
1631 		 * alloc of the new page;
1632 		 */
1633 		if (tlck->type & tlckBTROOT)
1634 			return;
1635 		tlck->flag |= tlckUPDATEMAP;
1636 		pxdlock = (struct pxd_lock *) & tlck->lock;
1637 		pxdlock->flag = mlckALLOCPXD;
1638 		pxdlock->pxd = *pxd;
1639 
1640 		pxdlock->index = 1;
1641 
1642 		/* mark page as homeward bound */
1643 		tlck->flag |= tlckWRITEPAGE;
1644 		return;
1645 	}
1646 
1647 	/*
1648 	 *	entry insertion/deletion,
1649 	 *	sibling page link update (old right page before split);
1650 	 */
1651 	if (tlck->type & (tlckENTRY | tlckRELINK)) {
1652 		/* log after-image for logredo(): */
1653 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1654 		PXDaddress(pxd, mp->index);
1655 		PXDlength(pxd,
1656 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1657 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1658 
1659 		/* mark page as homeward bound */
1660 		tlck->flag |= tlckWRITEPAGE;
1661 		return;
1662 	}
1663 
1664 	/*
1665 	 *	page deletion: page has been invalidated
1666 	 *	page relocation: source extent
1667 	 *
1668 	 *	a maplock for free of the page has been formatted
1669 	 *	at txLock() time);
1670 	 */
1671 	if (tlck->type & (tlckFREE | tlckRELOCATE)) {
1672 		/* log LOG_NOREDOPAGE of the deleted page for logredo()
1673 		 * to start NoRedoPage filter and to update bmap for free
1674 		 * of the deletd page
1675 		 */
1676 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
1677 		pxdlock = (struct pxd_lock *) & tlck->lock;
1678 		*pxd = pxdlock->pxd;
1679 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1680 
1681 		/* a maplock for txUpdateMap() for free of the page
1682 		 * has been formatted at txLock() time;
1683 		 */
1684 		tlck->flag |= tlckUPDATEMAP;
1685 	}
1686 	return;
1687 }
1688 
1689 /*
1690  *	xtLog()
1691  *
1692  * function:	log xtree tlock and format maplock to update bmap;
1693  */
1694 static void xtLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
1695 	   struct tlock * tlck)
1696 {
1697 	struct inode *ip;
1698 	struct metapage *mp;
1699 	xtpage_t *p;
1700 	struct xtlock *xtlck;
1701 	struct maplock *maplock;
1702 	struct xdlistlock *xadlock;
1703 	struct pxd_lock *pxdlock;
1704 	pxd_t *page_pxd;
1705 	int next, lwm, hwm;
1706 
1707 	ip = tlck->ip;
1708 	mp = tlck->mp;
1709 
1710 	/* initialize as REDOPAGE/NOREDOPAGE record format */
1711 	lrd->log.redopage.type = cpu_to_le16(LOG_XTREE);
1712 	lrd->log.redopage.l2linesize = cpu_to_le16(L2XTSLOTSIZE);
1713 
1714 	page_pxd = &lrd->log.redopage.pxd;
1715 
1716 	if (tlck->type & tlckBTROOT) {
1717 		lrd->log.redopage.type |= cpu_to_le16(LOG_BTROOT);
1718 		p = &JFS_IP(ip)->i_xtroot;
1719 		if (S_ISDIR(ip->i_mode))
1720 			lrd->log.redopage.type |=
1721 			    cpu_to_le16(LOG_DIR_XTREE);
1722 	} else
1723 		p = (xtpage_t *) mp->data;
1724 	next = le16_to_cpu(p->header.nextindex);
1725 
1726 	xtlck = (struct xtlock *) & tlck->lock;
1727 
1728 	maplock = (struct maplock *) & tlck->lock;
1729 	xadlock = (struct xdlistlock *) maplock;
1730 
1731 	/*
1732 	 *	entry insertion/extension;
1733 	 *	sibling page link update (old right page before split);
1734 	 */
1735 	if (tlck->type & (tlckNEW | tlckGROW | tlckRELINK)) {
1736 		/* log after-image for logredo():
1737 		 * logredo() will update bmap for alloc of new/extended
1738 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
1739 		 * after-image of XADlist;
1740 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
1741 		 * applying the after-image to the meta-data page.
1742 		 */
1743 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1744 		PXDaddress(page_pxd, mp->index);
1745 		PXDlength(page_pxd,
1746 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1747 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1748 
1749 		/* format a maplock for txUpdateMap() to update bPMAP
1750 		 * for alloc of new/extended extents of XAD[lwm:next)
1751 		 * from the page itself;
1752 		 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
1753 		 */
1754 		lwm = xtlck->lwm.offset;
1755 		if (lwm == 0)
1756 			lwm = XTPAGEMAXSLOT;
1757 
1758 		if (lwm == next)
1759 			goto out;
1760 		if (lwm > next) {
1761 			jfs_err("xtLog: lwm > next\n");
1762 			goto out;
1763 		}
1764 		tlck->flag |= tlckUPDATEMAP;
1765 		xadlock->flag = mlckALLOCXADLIST;
1766 		xadlock->count = next - lwm;
1767 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
1768 			int i;
1769 			pxd_t *pxd;
1770 			/*
1771 			 * Lazy commit may allow xtree to be modified before
1772 			 * txUpdateMap runs.  Copy xad into linelock to
1773 			 * preserve correct data.
1774 			 *
1775 			 * We can fit twice as may pxd's as xads in the lock
1776 			 */
1777 			xadlock->flag = mlckALLOCPXDLIST;
1778 			pxd = xadlock->xdlist = &xtlck->pxdlock;
1779 			for (i = 0; i < xadlock->count; i++) {
1780 				PXDaddress(pxd, addressXAD(&p->xad[lwm + i]));
1781 				PXDlength(pxd, lengthXAD(&p->xad[lwm + i]));
1782 				p->xad[lwm + i].flag &=
1783 				    ~(XAD_NEW | XAD_EXTENDED);
1784 				pxd++;
1785 			}
1786 		} else {
1787 			/*
1788 			 * xdlist will point to into inode's xtree, ensure
1789 			 * that transaction is not committed lazily.
1790 			 */
1791 			xadlock->flag = mlckALLOCXADLIST;
1792 			xadlock->xdlist = &p->xad[lwm];
1793 			tblk->xflag &= ~COMMIT_LAZY;
1794 		}
1795 		jfs_info("xtLog: alloc ip:0x%p mp:0x%p tlck:0x%p lwm:%d "
1796 			 "count:%d", tlck->ip, mp, tlck, lwm, xadlock->count);
1797 
1798 		maplock->index = 1;
1799 
1800 	      out:
1801 		/* mark page as homeward bound */
1802 		tlck->flag |= tlckWRITEPAGE;
1803 
1804 		return;
1805 	}
1806 
1807 	/*
1808 	 *	page deletion: file deletion/truncation (ref. xtTruncate())
1809 	 *
1810 	 * (page will be invalidated after log is written and bmap
1811 	 * is updated from the page);
1812 	 */
1813 	if (tlck->type & tlckFREE) {
1814 		/* LOG_NOREDOPAGE log for NoRedoPage filter:
1815 		 * if page free from file delete, NoRedoFile filter from
1816 		 * inode image of zero link count will subsume NoRedoPage
1817 		 * filters for each page;
1818 		 * if page free from file truncattion, write NoRedoPage
1819 		 * filter;
1820 		 *
1821 		 * upadte of block allocation map for the page itself:
1822 		 * if page free from deletion and truncation, LOG_UPDATEMAP
1823 		 * log for the page itself is generated from processing
1824 		 * its parent page xad entries;
1825 		 */
1826 		/* if page free from file truncation, log LOG_NOREDOPAGE
1827 		 * of the deleted page for logredo() to start NoRedoPage
1828 		 * filter for the page;
1829 		 */
1830 		if (tblk->xflag & COMMIT_TRUNCATE) {
1831 			/* write NOREDOPAGE for the page */
1832 			lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
1833 			PXDaddress(page_pxd, mp->index);
1834 			PXDlength(page_pxd,
1835 				  mp->logical_size >> tblk->sb->
1836 				  s_blocksize_bits);
1837 			lrd->backchain =
1838 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1839 
1840 			if (tlck->type & tlckBTROOT) {
1841 				/* Empty xtree must be logged */
1842 				lrd->type = cpu_to_le16(LOG_REDOPAGE);
1843 				lrd->backchain =
1844 				    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1845 			}
1846 		}
1847 
1848 		/* init LOG_UPDATEMAP of the freed extents
1849 		 * XAD[XTENTRYSTART:hwm) from the deleted page itself
1850 		 * for logredo() to update bmap;
1851 		 */
1852 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1853 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEXADLIST);
1854 		xtlck = (struct xtlock *) & tlck->lock;
1855 		hwm = xtlck->hwm.offset;
1856 		lrd->log.updatemap.nxd =
1857 		    cpu_to_le16(hwm - XTENTRYSTART + 1);
1858 		/* reformat linelock for lmLog() */
1859 		xtlck->header.offset = XTENTRYSTART;
1860 		xtlck->header.length = hwm - XTENTRYSTART + 1;
1861 		xtlck->index = 1;
1862 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1863 
1864 		/* format a maplock for txUpdateMap() to update bmap
1865 		 * to free extents of XAD[XTENTRYSTART:hwm) from the
1866 		 * deleted page itself;
1867 		 */
1868 		tlck->flag |= tlckUPDATEMAP;
1869 		xadlock->count = hwm - XTENTRYSTART + 1;
1870 		if ((xadlock->count <= 4) && (tblk->xflag & COMMIT_LAZY)) {
1871 			int i;
1872 			pxd_t *pxd;
1873 			/*
1874 			 * Lazy commit may allow xtree to be modified before
1875 			 * txUpdateMap runs.  Copy xad into linelock to
1876 			 * preserve correct data.
1877 			 *
1878 			 * We can fit twice as may pxd's as xads in the lock
1879 			 */
1880 			xadlock->flag = mlckFREEPXDLIST;
1881 			pxd = xadlock->xdlist = &xtlck->pxdlock;
1882 			for (i = 0; i < xadlock->count; i++) {
1883 				PXDaddress(pxd,
1884 					addressXAD(&p->xad[XTENTRYSTART + i]));
1885 				PXDlength(pxd,
1886 					lengthXAD(&p->xad[XTENTRYSTART + i]));
1887 				pxd++;
1888 			}
1889 		} else {
1890 			/*
1891 			 * xdlist will point to into inode's xtree, ensure
1892 			 * that transaction is not committed lazily.
1893 			 */
1894 			xadlock->flag = mlckFREEXADLIST;
1895 			xadlock->xdlist = &p->xad[XTENTRYSTART];
1896 			tblk->xflag &= ~COMMIT_LAZY;
1897 		}
1898 		jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d lwm:2",
1899 			 tlck->ip, mp, xadlock->count);
1900 
1901 		maplock->index = 1;
1902 
1903 		/* mark page as invalid */
1904 		if (((tblk->xflag & COMMIT_PWMAP) || S_ISDIR(ip->i_mode))
1905 		    && !(tlck->type & tlckBTROOT))
1906 			tlck->flag |= tlckFREEPAGE;
1907 		/*
1908 		   else (tblk->xflag & COMMIT_PMAP)
1909 		   ? release the page;
1910 		 */
1911 		return;
1912 	}
1913 
1914 	/*
1915 	 *	page/entry truncation: file truncation (ref. xtTruncate())
1916 	 *
1917 	 *	|----------+------+------+---------------|
1918 	 *		   |      |      |
1919 	 *		   |      |     hwm - hwm before truncation
1920 	 *		   |     next - truncation point
1921 	 *		  lwm - lwm before truncation
1922 	 * header ?
1923 	 */
1924 	if (tlck->type & tlckTRUNCATE) {
1925 		/* This odd declaration suppresses a bogus gcc warning */
1926 		pxd_t pxd = pxd;	/* truncated extent of xad */
1927 		int twm;
1928 
1929 		/*
1930 		 * For truncation the entire linelock may be used, so it would
1931 		 * be difficult to store xad list in linelock itself.
1932 		 * Therefore, we'll just force transaction to be committed
1933 		 * synchronously, so that xtree pages won't be changed before
1934 		 * txUpdateMap runs.
1935 		 */
1936 		tblk->xflag &= ~COMMIT_LAZY;
1937 		lwm = xtlck->lwm.offset;
1938 		if (lwm == 0)
1939 			lwm = XTPAGEMAXSLOT;
1940 		hwm = xtlck->hwm.offset;
1941 		twm = xtlck->twm.offset;
1942 
1943 		/*
1944 		 *	write log records
1945 		 */
1946 		/* log after-image for logredo():
1947 		 *
1948 		 * logredo() will update bmap for alloc of new/extended
1949 		 * extents (XAD_NEW|XAD_EXTEND) of XAD[lwm:next) from
1950 		 * after-image of XADlist;
1951 		 * logredo() resets (XAD_NEW|XAD_EXTEND) flag when
1952 		 * applying the after-image to the meta-data page.
1953 		 */
1954 		lrd->type = cpu_to_le16(LOG_REDOPAGE);
1955 		PXDaddress(page_pxd, mp->index);
1956 		PXDlength(page_pxd,
1957 			  mp->logical_size >> tblk->sb->s_blocksize_bits);
1958 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, tlck));
1959 
1960 		/*
1961 		 * truncate entry XAD[twm == next - 1]:
1962 		 */
1963 		if (twm == next - 1) {
1964 			/* init LOG_UPDATEMAP for logredo() to update bmap for
1965 			 * free of truncated delta extent of the truncated
1966 			 * entry XAD[next - 1]:
1967 			 * (xtlck->pxdlock = truncated delta extent);
1968 			 */
1969 			pxdlock = (struct pxd_lock *) & xtlck->pxdlock;
1970 			/* assert(pxdlock->type & tlckTRUNCATE); */
1971 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1972 			lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
1973 			lrd->log.updatemap.nxd = cpu_to_le16(1);
1974 			lrd->log.updatemap.pxd = pxdlock->pxd;
1975 			pxd = pxdlock->pxd;	/* save to format maplock */
1976 			lrd->backchain =
1977 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
1978 		}
1979 
1980 		/*
1981 		 * free entries XAD[next:hwm]:
1982 		 */
1983 		if (hwm >= next) {
1984 			/* init LOG_UPDATEMAP of the freed extents
1985 			 * XAD[next:hwm] from the deleted page itself
1986 			 * for logredo() to update bmap;
1987 			 */
1988 			lrd->type = cpu_to_le16(LOG_UPDATEMAP);
1989 			lrd->log.updatemap.type =
1990 			    cpu_to_le16(LOG_FREEXADLIST);
1991 			xtlck = (struct xtlock *) & tlck->lock;
1992 			hwm = xtlck->hwm.offset;
1993 			lrd->log.updatemap.nxd =
1994 			    cpu_to_le16(hwm - next + 1);
1995 			/* reformat linelock for lmLog() */
1996 			xtlck->header.offset = next;
1997 			xtlck->header.length = hwm - next + 1;
1998 			xtlck->index = 1;
1999 			lrd->backchain =
2000 			    cpu_to_le32(lmLog(log, tblk, lrd, tlck));
2001 		}
2002 
2003 		/*
2004 		 *	format maplock(s) for txUpdateMap() to update bmap
2005 		 */
2006 		maplock->index = 0;
2007 
2008 		/*
2009 		 * allocate entries XAD[lwm:next):
2010 		 */
2011 		if (lwm < next) {
2012 			/* format a maplock for txUpdateMap() to update bPMAP
2013 			 * for alloc of new/extended extents of XAD[lwm:next)
2014 			 * from the page itself;
2015 			 * txUpdateMap() resets (XAD_NEW|XAD_EXTEND) flag.
2016 			 */
2017 			tlck->flag |= tlckUPDATEMAP;
2018 			xadlock->flag = mlckALLOCXADLIST;
2019 			xadlock->count = next - lwm;
2020 			xadlock->xdlist = &p->xad[lwm];
2021 
2022 			jfs_info("xtLog: alloc ip:0x%p mp:0x%p count:%d "
2023 				 "lwm:%d next:%d",
2024 				 tlck->ip, mp, xadlock->count, lwm, next);
2025 			maplock->index++;
2026 			xadlock++;
2027 		}
2028 
2029 		/*
2030 		 * truncate entry XAD[twm == next - 1]:
2031 		 */
2032 		if (twm == next - 1) {
2033 			/* format a maplock for txUpdateMap() to update bmap
2034 			 * to free truncated delta extent of the truncated
2035 			 * entry XAD[next - 1];
2036 			 * (xtlck->pxdlock = truncated delta extent);
2037 			 */
2038 			tlck->flag |= tlckUPDATEMAP;
2039 			pxdlock = (struct pxd_lock *) xadlock;
2040 			pxdlock->flag = mlckFREEPXD;
2041 			pxdlock->count = 1;
2042 			pxdlock->pxd = pxd;
2043 
2044 			jfs_info("xtLog: truncate ip:0x%p mp:0x%p count:%d "
2045 				 "hwm:%d", ip, mp, pxdlock->count, hwm);
2046 			maplock->index++;
2047 			xadlock++;
2048 		}
2049 
2050 		/*
2051 		 * free entries XAD[next:hwm]:
2052 		 */
2053 		if (hwm >= next) {
2054 			/* format a maplock for txUpdateMap() to update bmap
2055 			 * to free extents of XAD[next:hwm] from thedeleted
2056 			 * page itself;
2057 			 */
2058 			tlck->flag |= tlckUPDATEMAP;
2059 			xadlock->flag = mlckFREEXADLIST;
2060 			xadlock->count = hwm - next + 1;
2061 			xadlock->xdlist = &p->xad[next];
2062 
2063 			jfs_info("xtLog: free ip:0x%p mp:0x%p count:%d "
2064 				 "next:%d hwm:%d",
2065 				 tlck->ip, mp, xadlock->count, next, hwm);
2066 			maplock->index++;
2067 		}
2068 
2069 		/* mark page as homeward bound */
2070 		tlck->flag |= tlckWRITEPAGE;
2071 	}
2072 	return;
2073 }
2074 
2075 /*
2076  *	mapLog()
2077  *
2078  * function:	log from maplock of freed data extents;
2079  */
2080 static void mapLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
2081 		   struct tlock * tlck)
2082 {
2083 	struct pxd_lock *pxdlock;
2084 	int i, nlock;
2085 	pxd_t *pxd;
2086 
2087 	/*
2088 	 *	page relocation: free the source page extent
2089 	 *
2090 	 * a maplock for txUpdateMap() for free of the page
2091 	 * has been formatted at txLock() time saving the src
2092 	 * relocated page address;
2093 	 */
2094 	if (tlck->type & tlckRELOCATE) {
2095 		/* log LOG_NOREDOPAGE of the old relocated page
2096 		 * for logredo() to start NoRedoPage filter;
2097 		 */
2098 		lrd->type = cpu_to_le16(LOG_NOREDOPAGE);
2099 		pxdlock = (struct pxd_lock *) & tlck->lock;
2100 		pxd = &lrd->log.redopage.pxd;
2101 		*pxd = pxdlock->pxd;
2102 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2103 
2104 		/* (N.B. currently, logredo() does NOT update bmap
2105 		 * for free of the page itself for (LOG_XTREE|LOG_NOREDOPAGE);
2106 		 * if page free from relocation, LOG_UPDATEMAP log is
2107 		 * specifically generated now for logredo()
2108 		 * to update bmap for free of src relocated page;
2109 		 * (new flag LOG_RELOCATE may be introduced which will
2110 		 * inform logredo() to start NORedoPage filter and also
2111 		 * update block allocation map at the same time, thus
2112 		 * avoiding an extra log write);
2113 		 */
2114 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
2115 		lrd->log.updatemap.type = cpu_to_le16(LOG_FREEPXD);
2116 		lrd->log.updatemap.nxd = cpu_to_le16(1);
2117 		lrd->log.updatemap.pxd = pxdlock->pxd;
2118 		lrd->backchain = cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2119 
2120 		/* a maplock for txUpdateMap() for free of the page
2121 		 * has been formatted at txLock() time;
2122 		 */
2123 		tlck->flag |= tlckUPDATEMAP;
2124 		return;
2125 	}
2126 	/*
2127 
2128 	 * Otherwise it's not a relocate request
2129 	 *
2130 	 */
2131 	else {
2132 		/* log LOG_UPDATEMAP for logredo() to update bmap for
2133 		 * free of truncated/relocated delta extent of the data;
2134 		 * e.g.: external EA extent, relocated/truncated extent
2135 		 * from xtTailgate();
2136 		 */
2137 		lrd->type = cpu_to_le16(LOG_UPDATEMAP);
2138 		pxdlock = (struct pxd_lock *) & tlck->lock;
2139 		nlock = pxdlock->index;
2140 		for (i = 0; i < nlock; i++, pxdlock++) {
2141 			if (pxdlock->flag & mlckALLOCPXD)
2142 				lrd->log.updatemap.type =
2143 				    cpu_to_le16(LOG_ALLOCPXD);
2144 			else
2145 				lrd->log.updatemap.type =
2146 				    cpu_to_le16(LOG_FREEPXD);
2147 			lrd->log.updatemap.nxd = cpu_to_le16(1);
2148 			lrd->log.updatemap.pxd = pxdlock->pxd;
2149 			lrd->backchain =
2150 			    cpu_to_le32(lmLog(log, tblk, lrd, NULL));
2151 			jfs_info("mapLog: xaddr:0x%lx xlen:0x%x",
2152 				 (ulong) addressPXD(&pxdlock->pxd),
2153 				 lengthPXD(&pxdlock->pxd));
2154 		}
2155 
2156 		/* update bmap */
2157 		tlck->flag |= tlckUPDATEMAP;
2158 	}
2159 }
2160 
2161 /*
2162  *	txEA()
2163  *
2164  * function:	acquire maplock for EA/ACL extents or
2165  *		set COMMIT_INLINE flag;
2166  */
2167 void txEA(tid_t tid, struct inode *ip, dxd_t * oldea, dxd_t * newea)
2168 {
2169 	struct tlock *tlck = NULL;
2170 	struct pxd_lock *maplock = NULL, *pxdlock = NULL;
2171 
2172 	/*
2173 	 * format maplock for alloc of new EA extent
2174 	 */
2175 	if (newea) {
2176 		/* Since the newea could be a completely zeroed entry we need to
2177 		 * check for the two flags which indicate we should actually
2178 		 * commit new EA data
2179 		 */
2180 		if (newea->flag & DXD_EXTENT) {
2181 			tlck = txMaplock(tid, ip, tlckMAP);
2182 			maplock = (struct pxd_lock *) & tlck->lock;
2183 			pxdlock = (struct pxd_lock *) maplock;
2184 			pxdlock->flag = mlckALLOCPXD;
2185 			PXDaddress(&pxdlock->pxd, addressDXD(newea));
2186 			PXDlength(&pxdlock->pxd, lengthDXD(newea));
2187 			pxdlock++;
2188 			maplock->index = 1;
2189 		} else if (newea->flag & DXD_INLINE) {
2190 			tlck = NULL;
2191 
2192 			set_cflag(COMMIT_Inlineea, ip);
2193 		}
2194 	}
2195 
2196 	/*
2197 	 * format maplock for free of old EA extent
2198 	 */
2199 	if (!test_cflag(COMMIT_Nolink, ip) && oldea->flag & DXD_EXTENT) {
2200 		if (tlck == NULL) {
2201 			tlck = txMaplock(tid, ip, tlckMAP);
2202 			maplock = (struct pxd_lock *) & tlck->lock;
2203 			pxdlock = (struct pxd_lock *) maplock;
2204 			maplock->index = 0;
2205 		}
2206 		pxdlock->flag = mlckFREEPXD;
2207 		PXDaddress(&pxdlock->pxd, addressDXD(oldea));
2208 		PXDlength(&pxdlock->pxd, lengthDXD(oldea));
2209 		maplock->index++;
2210 	}
2211 }
2212 
2213 /*
2214  *	txForce()
2215  *
2216  * function: synchronously write pages locked by transaction
2217  *	     after txLog() but before txUpdateMap();
2218  */
2219 static void txForce(struct tblock * tblk)
2220 {
2221 	struct tlock *tlck;
2222 	lid_t lid, next;
2223 	struct metapage *mp;
2224 
2225 	/*
2226 	 * reverse the order of transaction tlocks in
2227 	 * careful update order of address index pages
2228 	 * (right to left, bottom up)
2229 	 */
2230 	tlck = lid_to_tlock(tblk->next);
2231 	lid = tlck->next;
2232 	tlck->next = 0;
2233 	while (lid) {
2234 		tlck = lid_to_tlock(lid);
2235 		next = tlck->next;
2236 		tlck->next = tblk->next;
2237 		tblk->next = lid;
2238 		lid = next;
2239 	}
2240 
2241 	/*
2242 	 * synchronously write the page, and
2243 	 * hold the page for txUpdateMap();
2244 	 */
2245 	for (lid = tblk->next; lid; lid = next) {
2246 		tlck = lid_to_tlock(lid);
2247 		next = tlck->next;
2248 
2249 		if ((mp = tlck->mp) != NULL &&
2250 		    (tlck->type & tlckBTROOT) == 0) {
2251 			assert(mp->xflag & COMMIT_PAGE);
2252 
2253 			if (tlck->flag & tlckWRITEPAGE) {
2254 				tlck->flag &= ~tlckWRITEPAGE;
2255 
2256 				/* do not release page to freelist */
2257 				force_metapage(mp);
2258 #if 0
2259 				/*
2260 				 * The "right" thing to do here is to
2261 				 * synchronously write the metadata.
2262 				 * With the current implementation this
2263 				 * is hard since write_metapage requires
2264 				 * us to kunmap & remap the page.  If we
2265 				 * have tlocks pointing into the metadata
2266 				 * pages, we don't want to do this.  I think
2267 				 * we can get by with synchronously writing
2268 				 * the pages when they are released.
2269 				 */
2270 				assert(mp->nohomeok);
2271 				set_bit(META_dirty, &mp->flag);
2272 				set_bit(META_sync, &mp->flag);
2273 #endif
2274 			}
2275 		}
2276 	}
2277 }
2278 
2279 /*
2280  *	txUpdateMap()
2281  *
2282  * function:	update persistent allocation map (and working map
2283  *		if appropriate);
2284  *
2285  * parameter:
2286  */
2287 static void txUpdateMap(struct tblock * tblk)
2288 {
2289 	struct inode *ip;
2290 	struct inode *ipimap;
2291 	lid_t lid;
2292 	struct tlock *tlck;
2293 	struct maplock *maplock;
2294 	struct pxd_lock pxdlock;
2295 	int maptype;
2296 	int k, nlock;
2297 	struct metapage *mp = NULL;
2298 
2299 	ipimap = JFS_SBI(tblk->sb)->ipimap;
2300 
2301 	maptype = (tblk->xflag & COMMIT_PMAP) ? COMMIT_PMAP : COMMIT_PWMAP;
2302 
2303 
2304 	/*
2305 	 *	update block allocation map
2306 	 *
2307 	 * update allocation state in pmap (and wmap) and
2308 	 * update lsn of the pmap page;
2309 	 */
2310 	/*
2311 	 * scan each tlock/page of transaction for block allocation/free:
2312 	 *
2313 	 * for each tlock/page of transaction, update map.
2314 	 *  ? are there tlock for pmap and pwmap at the same time ?
2315 	 */
2316 	for (lid = tblk->next; lid; lid = tlck->next) {
2317 		tlck = lid_to_tlock(lid);
2318 
2319 		if ((tlck->flag & tlckUPDATEMAP) == 0)
2320 			continue;
2321 
2322 		if (tlck->flag & tlckFREEPAGE) {
2323 			/*
2324 			 * Another thread may attempt to reuse freed space
2325 			 * immediately, so we want to get rid of the metapage
2326 			 * before anyone else has a chance to get it.
2327 			 * Lock metapage, update maps, then invalidate
2328 			 * the metapage.
2329 			 */
2330 			mp = tlck->mp;
2331 			ASSERT(mp->xflag & COMMIT_PAGE);
2332 			grab_metapage(mp);
2333 		}
2334 
2335 		/*
2336 		 * extent list:
2337 		 * . in-line PXD list:
2338 		 * . out-of-line XAD list:
2339 		 */
2340 		maplock = (struct maplock *) & tlck->lock;
2341 		nlock = maplock->index;
2342 
2343 		for (k = 0; k < nlock; k++, maplock++) {
2344 			/*
2345 			 * allocate blocks in persistent map:
2346 			 *
2347 			 * blocks have been allocated from wmap at alloc time;
2348 			 */
2349 			if (maplock->flag & mlckALLOC) {
2350 				txAllocPMap(ipimap, maplock, tblk);
2351 			}
2352 			/*
2353 			 * free blocks in persistent and working map:
2354 			 * blocks will be freed in pmap and then in wmap;
2355 			 *
2356 			 * ? tblock specifies the PMAP/PWMAP based upon
2357 			 * transaction
2358 			 *
2359 			 * free blocks in persistent map:
2360 			 * blocks will be freed from wmap at last reference
2361 			 * release of the object for regular files;
2362 			 *
2363 			 * Alway free blocks from both persistent & working
2364 			 * maps for directories
2365 			 */
2366 			else {	/* (maplock->flag & mlckFREE) */
2367 
2368 				if (tlck->flag & tlckDIRECTORY)
2369 					txFreeMap(ipimap, maplock,
2370 						  tblk, COMMIT_PWMAP);
2371 				else
2372 					txFreeMap(ipimap, maplock,
2373 						  tblk, maptype);
2374 			}
2375 		}
2376 		if (tlck->flag & tlckFREEPAGE) {
2377 			if (!(tblk->flag & tblkGC_LAZY)) {
2378 				/* This is equivalent to txRelease */
2379 				ASSERT(mp->lid == lid);
2380 				tlck->mp->lid = 0;
2381 			}
2382 			assert(mp->nohomeok == 1);
2383 			metapage_homeok(mp);
2384 			discard_metapage(mp);
2385 			tlck->mp = NULL;
2386 		}
2387 	}
2388 	/*
2389 	 *	update inode allocation map
2390 	 *
2391 	 * update allocation state in pmap and
2392 	 * update lsn of the pmap page;
2393 	 * update in-memory inode flag/state
2394 	 *
2395 	 * unlock mapper/write lock
2396 	 */
2397 	if (tblk->xflag & COMMIT_CREATE) {
2398 		diUpdatePMap(ipimap, tblk->ino, false, tblk);
2399 		/* update persistent block allocation map
2400 		 * for the allocation of inode extent;
2401 		 */
2402 		pxdlock.flag = mlckALLOCPXD;
2403 		pxdlock.pxd = tblk->u.ixpxd;
2404 		pxdlock.index = 1;
2405 		txAllocPMap(ipimap, (struct maplock *) & pxdlock, tblk);
2406 	} else if (tblk->xflag & COMMIT_DELETE) {
2407 		ip = tblk->u.ip;
2408 		diUpdatePMap(ipimap, ip->i_ino, true, tblk);
2409 		iput(ip);
2410 	}
2411 }
2412 
2413 /*
2414  *	txAllocPMap()
2415  *
2416  * function: allocate from persistent map;
2417  *
2418  * parameter:
2419  *	ipbmap	-
2420  *	malock	-
2421  *		xad list:
2422  *		pxd:
2423  *
2424  *	maptype -
2425  *		allocate from persistent map;
2426  *		free from persistent map;
2427  *		(e.g., tmp file - free from working map at releae
2428  *		 of last reference);
2429  *		free from persistent and working map;
2430  *
2431  *	lsn	- log sequence number;
2432  */
2433 static void txAllocPMap(struct inode *ip, struct maplock * maplock,
2434 			struct tblock * tblk)
2435 {
2436 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
2437 	struct xdlistlock *xadlistlock;
2438 	xad_t *xad;
2439 	s64 xaddr;
2440 	int xlen;
2441 	struct pxd_lock *pxdlock;
2442 	struct xdlistlock *pxdlistlock;
2443 	pxd_t *pxd;
2444 	int n;
2445 
2446 	/*
2447 	 * allocate from persistent map;
2448 	 */
2449 	if (maplock->flag & mlckALLOCXADLIST) {
2450 		xadlistlock = (struct xdlistlock *) maplock;
2451 		xad = xadlistlock->xdlist;
2452 		for (n = 0; n < xadlistlock->count; n++, xad++) {
2453 			if (xad->flag & (XAD_NEW | XAD_EXTENDED)) {
2454 				xaddr = addressXAD(xad);
2455 				xlen = lengthXAD(xad);
2456 				dbUpdatePMap(ipbmap, false, xaddr,
2457 					     (s64) xlen, tblk);
2458 				xad->flag &= ~(XAD_NEW | XAD_EXTENDED);
2459 				jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
2460 					 (ulong) xaddr, xlen);
2461 			}
2462 		}
2463 	} else if (maplock->flag & mlckALLOCPXD) {
2464 		pxdlock = (struct pxd_lock *) maplock;
2465 		xaddr = addressPXD(&pxdlock->pxd);
2466 		xlen = lengthPXD(&pxdlock->pxd);
2467 		dbUpdatePMap(ipbmap, false, xaddr, (s64) xlen, tblk);
2468 		jfs_info("allocPMap: xaddr:0x%lx xlen:%d", (ulong) xaddr, xlen);
2469 	} else {		/* (maplock->flag & mlckALLOCPXDLIST) */
2470 
2471 		pxdlistlock = (struct xdlistlock *) maplock;
2472 		pxd = pxdlistlock->xdlist;
2473 		for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2474 			xaddr = addressPXD(pxd);
2475 			xlen = lengthPXD(pxd);
2476 			dbUpdatePMap(ipbmap, false, xaddr, (s64) xlen,
2477 				     tblk);
2478 			jfs_info("allocPMap: xaddr:0x%lx xlen:%d",
2479 				 (ulong) xaddr, xlen);
2480 		}
2481 	}
2482 }
2483 
2484 /*
2485  *	txFreeMap()
2486  *
2487  * function:	free from persistent and/or working map;
2488  *
2489  * todo: optimization
2490  */
2491 void txFreeMap(struct inode *ip,
2492 	       struct maplock * maplock, struct tblock * tblk, int maptype)
2493 {
2494 	struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap;
2495 	struct xdlistlock *xadlistlock;
2496 	xad_t *xad;
2497 	s64 xaddr;
2498 	int xlen;
2499 	struct pxd_lock *pxdlock;
2500 	struct xdlistlock *pxdlistlock;
2501 	pxd_t *pxd;
2502 	int n;
2503 
2504 	jfs_info("txFreeMap: tblk:0x%p maplock:0x%p maptype:0x%x",
2505 		 tblk, maplock, maptype);
2506 
2507 	/*
2508 	 * free from persistent map;
2509 	 */
2510 	if (maptype == COMMIT_PMAP || maptype == COMMIT_PWMAP) {
2511 		if (maplock->flag & mlckFREEXADLIST) {
2512 			xadlistlock = (struct xdlistlock *) maplock;
2513 			xad = xadlistlock->xdlist;
2514 			for (n = 0; n < xadlistlock->count; n++, xad++) {
2515 				if (!(xad->flag & XAD_NEW)) {
2516 					xaddr = addressXAD(xad);
2517 					xlen = lengthXAD(xad);
2518 					dbUpdatePMap(ipbmap, true, xaddr,
2519 						     (s64) xlen, tblk);
2520 					jfs_info("freePMap: xaddr:0x%lx "
2521 						 "xlen:%d",
2522 						 (ulong) xaddr, xlen);
2523 				}
2524 			}
2525 		} else if (maplock->flag & mlckFREEPXD) {
2526 			pxdlock = (struct pxd_lock *) maplock;
2527 			xaddr = addressPXD(&pxdlock->pxd);
2528 			xlen = lengthPXD(&pxdlock->pxd);
2529 			dbUpdatePMap(ipbmap, true, xaddr, (s64) xlen,
2530 				     tblk);
2531 			jfs_info("freePMap: xaddr:0x%lx xlen:%d",
2532 				 (ulong) xaddr, xlen);
2533 		} else {	/* (maplock->flag & mlckALLOCPXDLIST) */
2534 
2535 			pxdlistlock = (struct xdlistlock *) maplock;
2536 			pxd = pxdlistlock->xdlist;
2537 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2538 				xaddr = addressPXD(pxd);
2539 				xlen = lengthPXD(pxd);
2540 				dbUpdatePMap(ipbmap, true, xaddr,
2541 					     (s64) xlen, tblk);
2542 				jfs_info("freePMap: xaddr:0x%lx xlen:%d",
2543 					 (ulong) xaddr, xlen);
2544 			}
2545 		}
2546 	}
2547 
2548 	/*
2549 	 * free from working map;
2550 	 */
2551 	if (maptype == COMMIT_PWMAP || maptype == COMMIT_WMAP) {
2552 		if (maplock->flag & mlckFREEXADLIST) {
2553 			xadlistlock = (struct xdlistlock *) maplock;
2554 			xad = xadlistlock->xdlist;
2555 			for (n = 0; n < xadlistlock->count; n++, xad++) {
2556 				xaddr = addressXAD(xad);
2557 				xlen = lengthXAD(xad);
2558 				dbFree(ip, xaddr, (s64) xlen);
2559 				xad->flag = 0;
2560 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2561 					 (ulong) xaddr, xlen);
2562 			}
2563 		} else if (maplock->flag & mlckFREEPXD) {
2564 			pxdlock = (struct pxd_lock *) maplock;
2565 			xaddr = addressPXD(&pxdlock->pxd);
2566 			xlen = lengthPXD(&pxdlock->pxd);
2567 			dbFree(ip, xaddr, (s64) xlen);
2568 			jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2569 				 (ulong) xaddr, xlen);
2570 		} else {	/* (maplock->flag & mlckFREEPXDLIST) */
2571 
2572 			pxdlistlock = (struct xdlistlock *) maplock;
2573 			pxd = pxdlistlock->xdlist;
2574 			for (n = 0; n < pxdlistlock->count; n++, pxd++) {
2575 				xaddr = addressPXD(pxd);
2576 				xlen = lengthPXD(pxd);
2577 				dbFree(ip, xaddr, (s64) xlen);
2578 				jfs_info("freeWMap: xaddr:0x%lx xlen:%d",
2579 					 (ulong) xaddr, xlen);
2580 			}
2581 		}
2582 	}
2583 }
2584 
2585 /*
2586  *	txFreelock()
2587  *
2588  * function:	remove tlock from inode anonymous locklist
2589  */
2590 void txFreelock(struct inode *ip)
2591 {
2592 	struct jfs_inode_info *jfs_ip = JFS_IP(ip);
2593 	struct tlock *xtlck, *tlck;
2594 	lid_t xlid = 0, lid;
2595 
2596 	if (!jfs_ip->atlhead)
2597 		return;
2598 
2599 	TXN_LOCK();
2600 	xtlck = (struct tlock *) &jfs_ip->atlhead;
2601 
2602 	while ((lid = xtlck->next) != 0) {
2603 		tlck = lid_to_tlock(lid);
2604 		if (tlck->flag & tlckFREELOCK) {
2605 			xtlck->next = tlck->next;
2606 			txLockFree(lid);
2607 		} else {
2608 			xtlck = tlck;
2609 			xlid = lid;
2610 		}
2611 	}
2612 
2613 	if (jfs_ip->atlhead)
2614 		jfs_ip->atltail = xlid;
2615 	else {
2616 		jfs_ip->atltail = 0;
2617 		/*
2618 		 * If inode was on anon_list, remove it
2619 		 */
2620 		list_del_init(&jfs_ip->anon_inode_list);
2621 	}
2622 	TXN_UNLOCK();
2623 }
2624 
2625 /*
2626  *	txAbort()
2627  *
2628  * function: abort tx before commit;
2629  *
2630  * frees line-locks and segment locks for all
2631  * segments in comdata structure.
2632  * Optionally sets state of file-system to FM_DIRTY in super-block.
2633  * log age of page-frames in memory for which caller has
2634  * are reset to 0 (to avoid logwarap).
2635  */
2636 void txAbort(tid_t tid, int dirty)
2637 {
2638 	lid_t lid, next;
2639 	struct metapage *mp;
2640 	struct tblock *tblk = tid_to_tblock(tid);
2641 	struct tlock *tlck;
2642 
2643 	/*
2644 	 * free tlocks of the transaction
2645 	 */
2646 	for (lid = tblk->next; lid; lid = next) {
2647 		tlck = lid_to_tlock(lid);
2648 		next = tlck->next;
2649 		mp = tlck->mp;
2650 		JFS_IP(tlck->ip)->xtlid = 0;
2651 
2652 		if (mp) {
2653 			mp->lid = 0;
2654 
2655 			/*
2656 			 * reset lsn of page to avoid logwarap:
2657 			 *
2658 			 * (page may have been previously committed by another
2659 			 * transaction(s) but has not been paged, i.e.,
2660 			 * it may be on logsync list even though it has not
2661 			 * been logged for the current tx.)
2662 			 */
2663 			if (mp->xflag & COMMIT_PAGE && mp->lsn)
2664 				LogSyncRelease(mp);
2665 		}
2666 		/* insert tlock at head of freelist */
2667 		TXN_LOCK();
2668 		txLockFree(lid);
2669 		TXN_UNLOCK();
2670 	}
2671 
2672 	/* caller will free the transaction block */
2673 
2674 	tblk->next = tblk->last = 0;
2675 
2676 	/*
2677 	 * mark filesystem dirty
2678 	 */
2679 	if (dirty)
2680 		jfs_error(tblk->sb, "txAbort");
2681 
2682 	return;
2683 }
2684 
2685 /*
2686  *	txLazyCommit(void)
2687  *
2688  *	All transactions except those changing ipimap (COMMIT_FORCE) are
2689  *	processed by this routine.  This insures that the inode and block
2690  *	allocation maps are updated in order.  For synchronous transactions,
2691  *	let the user thread finish processing after txUpdateMap() is called.
2692  */
2693 static void txLazyCommit(struct tblock * tblk)
2694 {
2695 	struct jfs_log *log;
2696 
2697 	while (((tblk->flag & tblkGC_READY) == 0) &&
2698 	       ((tblk->flag & tblkGC_UNLOCKED) == 0)) {
2699 		/* We must have gotten ahead of the user thread
2700 		 */
2701 		jfs_info("jfs_lazycommit: tblk 0x%p not unlocked", tblk);
2702 		yield();
2703 	}
2704 
2705 	jfs_info("txLazyCommit: processing tblk 0x%p", tblk);
2706 
2707 	txUpdateMap(tblk);
2708 
2709 	log = (struct jfs_log *) JFS_SBI(tblk->sb)->log;
2710 
2711 	spin_lock_irq(&log->gclock);	// LOGGC_LOCK
2712 
2713 	tblk->flag |= tblkGC_COMMITTED;
2714 
2715 	if (tblk->flag & tblkGC_READY)
2716 		log->gcrtc--;
2717 
2718 	wake_up_all(&tblk->gcwait);	// LOGGC_WAKEUP
2719 
2720 	/*
2721 	 * Can't release log->gclock until we've tested tblk->flag
2722 	 */
2723 	if (tblk->flag & tblkGC_LAZY) {
2724 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
2725 		txUnlock(tblk);
2726 		tblk->flag &= ~tblkGC_LAZY;
2727 		txEnd(tblk - TxBlock);	/* Convert back to tid */
2728 	} else
2729 		spin_unlock_irq(&log->gclock);	// LOGGC_UNLOCK
2730 
2731 	jfs_info("txLazyCommit: done: tblk = 0x%p", tblk);
2732 }
2733 
2734 /*
2735  *	jfs_lazycommit(void)
2736  *
2737  *	To be run as a kernel daemon.  If lbmIODone is called in an interrupt
2738  *	context, or where blocking is not wanted, this routine will process
2739  *	committed transactions from the unlock queue.
2740  */
2741 int jfs_lazycommit(void *arg)
2742 {
2743 	int WorkDone;
2744 	struct tblock *tblk;
2745 	unsigned long flags;
2746 	struct jfs_sb_info *sbi;
2747 
2748 	do {
2749 		LAZY_LOCK(flags);
2750 		jfs_commit_thread_waking = 0;	/* OK to wake another thread */
2751 		while (!list_empty(&TxAnchor.unlock_queue)) {
2752 			WorkDone = 0;
2753 			list_for_each_entry(tblk, &TxAnchor.unlock_queue,
2754 					    cqueue) {
2755 
2756 				sbi = JFS_SBI(tblk->sb);
2757 				/*
2758 				 * For each volume, the transactions must be
2759 				 * handled in order.  If another commit thread
2760 				 * is handling a tblk for this superblock,
2761 				 * skip it
2762 				 */
2763 				if (sbi->commit_state & IN_LAZYCOMMIT)
2764 					continue;
2765 
2766 				sbi->commit_state |= IN_LAZYCOMMIT;
2767 				WorkDone = 1;
2768 
2769 				/*
2770 				 * Remove transaction from queue
2771 				 */
2772 				list_del(&tblk->cqueue);
2773 
2774 				LAZY_UNLOCK(flags);
2775 				txLazyCommit(tblk);
2776 				LAZY_LOCK(flags);
2777 
2778 				sbi->commit_state &= ~IN_LAZYCOMMIT;
2779 				/*
2780 				 * Don't continue in the for loop.  (We can't
2781 				 * anyway, it's unsafe!)  We want to go back to
2782 				 * the beginning of the list.
2783 				 */
2784 				break;
2785 			}
2786 
2787 			/* If there was nothing to do, don't continue */
2788 			if (!WorkDone)
2789 				break;
2790 		}
2791 		/* In case a wakeup came while all threads were active */
2792 		jfs_commit_thread_waking = 0;
2793 
2794 		if (freezing(current)) {
2795 			LAZY_UNLOCK(flags);
2796 			refrigerator();
2797 		} else {
2798 			DECLARE_WAITQUEUE(wq, current);
2799 
2800 			add_wait_queue(&jfs_commit_thread_wait, &wq);
2801 			set_current_state(TASK_INTERRUPTIBLE);
2802 			LAZY_UNLOCK(flags);
2803 			schedule();
2804 			__set_current_state(TASK_RUNNING);
2805 			remove_wait_queue(&jfs_commit_thread_wait, &wq);
2806 		}
2807 	} while (!kthread_should_stop());
2808 
2809 	if (!list_empty(&TxAnchor.unlock_queue))
2810 		jfs_err("jfs_lazycommit being killed w/pending transactions!");
2811 	else
2812 		jfs_info("jfs_lazycommit being killed\n");
2813 	return 0;
2814 }
2815 
2816 void txLazyUnlock(struct tblock * tblk)
2817 {
2818 	unsigned long flags;
2819 
2820 	LAZY_LOCK(flags);
2821 
2822 	list_add_tail(&tblk->cqueue, &TxAnchor.unlock_queue);
2823 	/*
2824 	 * Don't wake up a commit thread if there is already one servicing
2825 	 * this superblock, or if the last one we woke up hasn't started yet.
2826 	 */
2827 	if (!(JFS_SBI(tblk->sb)->commit_state & IN_LAZYCOMMIT) &&
2828 	    !jfs_commit_thread_waking) {
2829 		jfs_commit_thread_waking = 1;
2830 		wake_up(&jfs_commit_thread_wait);
2831 	}
2832 	LAZY_UNLOCK(flags);
2833 }
2834 
2835 static void LogSyncRelease(struct metapage * mp)
2836 {
2837 	struct jfs_log *log = mp->log;
2838 
2839 	assert(mp->nohomeok);
2840 	assert(log);
2841 	metapage_homeok(mp);
2842 }
2843 
2844 /*
2845  *	txQuiesce
2846  *
2847  *	Block all new transactions and push anonymous transactions to
2848  *	completion
2849  *
2850  *	This does almost the same thing as jfs_sync below.  We don't
2851  *	worry about deadlocking when jfs_tlocks_low is set, since we would
2852  *	expect jfs_sync to get us out of that jam.
2853  */
2854 void txQuiesce(struct super_block *sb)
2855 {
2856 	struct inode *ip;
2857 	struct jfs_inode_info *jfs_ip;
2858 	struct jfs_log *log = JFS_SBI(sb)->log;
2859 	tid_t tid;
2860 
2861 	set_bit(log_QUIESCE, &log->flag);
2862 
2863 	TXN_LOCK();
2864 restart:
2865 	while (!list_empty(&TxAnchor.anon_list)) {
2866 		jfs_ip = list_entry(TxAnchor.anon_list.next,
2867 				    struct jfs_inode_info,
2868 				    anon_inode_list);
2869 		ip = &jfs_ip->vfs_inode;
2870 
2871 		/*
2872 		 * inode will be removed from anonymous list
2873 		 * when it is committed
2874 		 */
2875 		TXN_UNLOCK();
2876 		tid = txBegin(ip->i_sb, COMMIT_INODE | COMMIT_FORCE);
2877 		mutex_lock(&jfs_ip->commit_mutex);
2878 		txCommit(tid, 1, &ip, 0);
2879 		txEnd(tid);
2880 		mutex_unlock(&jfs_ip->commit_mutex);
2881 		/*
2882 		 * Just to be safe.  I don't know how
2883 		 * long we can run without blocking
2884 		 */
2885 		cond_resched();
2886 		TXN_LOCK();
2887 	}
2888 
2889 	/*
2890 	 * If jfs_sync is running in parallel, there could be some inodes
2891 	 * on anon_list2.  Let's check.
2892 	 */
2893 	if (!list_empty(&TxAnchor.anon_list2)) {
2894 		list_splice(&TxAnchor.anon_list2, &TxAnchor.anon_list);
2895 		INIT_LIST_HEAD(&TxAnchor.anon_list2);
2896 		goto restart;
2897 	}
2898 	TXN_UNLOCK();
2899 
2900 	/*
2901 	 * We may need to kick off the group commit
2902 	 */
2903 	jfs_flush_journal(log, 0);
2904 }
2905 
2906 /*
2907  * txResume()
2908  *
2909  * Allows transactions to start again following txQuiesce
2910  */
2911 void txResume(struct super_block *sb)
2912 {
2913 	struct jfs_log *log = JFS_SBI(sb)->log;
2914 
2915 	clear_bit(log_QUIESCE, &log->flag);
2916 	TXN_WAKEUP(&log->syncwait);
2917 }
2918 
2919 /*
2920  *	jfs_sync(void)
2921  *
2922  *	To be run as a kernel daemon.  This is awakened when tlocks run low.
2923  *	We write any inodes that have anonymous tlocks so they will become
2924  *	available.
2925  */
2926 int jfs_sync(void *arg)
2927 {
2928 	struct inode *ip;
2929 	struct jfs_inode_info *jfs_ip;
2930 	int rc;
2931 	tid_t tid;
2932 
2933 	do {
2934 		/*
2935 		 * write each inode on the anonymous inode list
2936 		 */
2937 		TXN_LOCK();
2938 		while (jfs_tlocks_low && !list_empty(&TxAnchor.anon_list)) {
2939 			jfs_ip = list_entry(TxAnchor.anon_list.next,
2940 					    struct jfs_inode_info,
2941 					    anon_inode_list);
2942 			ip = &jfs_ip->vfs_inode;
2943 
2944 			if (! igrab(ip)) {
2945 				/*
2946 				 * Inode is being freed
2947 				 */
2948 				list_del_init(&jfs_ip->anon_inode_list);
2949 			} else if (mutex_trylock(&jfs_ip->commit_mutex)) {
2950 				/*
2951 				 * inode will be removed from anonymous list
2952 				 * when it is committed
2953 				 */
2954 				TXN_UNLOCK();
2955 				tid = txBegin(ip->i_sb, COMMIT_INODE);
2956 				rc = txCommit(tid, 1, &ip, 0);
2957 				txEnd(tid);
2958 				mutex_unlock(&jfs_ip->commit_mutex);
2959 
2960 				iput(ip);
2961 				/*
2962 				 * Just to be safe.  I don't know how
2963 				 * long we can run without blocking
2964 				 */
2965 				cond_resched();
2966 				TXN_LOCK();
2967 			} else {
2968 				/* We can't get the commit mutex.  It may
2969 				 * be held by a thread waiting for tlock's
2970 				 * so let's not block here.  Save it to
2971 				 * put back on the anon_list.
2972 				 */
2973 
2974 				/* Take off anon_list */
2975 				list_del(&jfs_ip->anon_inode_list);
2976 
2977 				/* Put on anon_list2 */
2978 				list_add(&jfs_ip->anon_inode_list,
2979 					 &TxAnchor.anon_list2);
2980 
2981 				TXN_UNLOCK();
2982 				iput(ip);
2983 				TXN_LOCK();
2984 			}
2985 		}
2986 		/* Add anon_list2 back to anon_list */
2987 		list_splice_init(&TxAnchor.anon_list2, &TxAnchor.anon_list);
2988 
2989 		if (freezing(current)) {
2990 			TXN_UNLOCK();
2991 			refrigerator();
2992 		} else {
2993 			set_current_state(TASK_INTERRUPTIBLE);
2994 			TXN_UNLOCK();
2995 			schedule();
2996 			__set_current_state(TASK_RUNNING);
2997 		}
2998 	} while (!kthread_should_stop());
2999 
3000 	jfs_info("jfs_sync being killed");
3001 	return 0;
3002 }
3003 
3004 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_DEBUG)
3005 int jfs_txanchor_read(char *buffer, char **start, off_t offset, int length,
3006 		      int *eof, void *data)
3007 {
3008 	int len = 0;
3009 	off_t begin;
3010 	char *freewait;
3011 	char *freelockwait;
3012 	char *lowlockwait;
3013 
3014 	freewait =
3015 	    waitqueue_active(&TxAnchor.freewait) ? "active" : "empty";
3016 	freelockwait =
3017 	    waitqueue_active(&TxAnchor.freelockwait) ? "active" : "empty";
3018 	lowlockwait =
3019 	    waitqueue_active(&TxAnchor.lowlockwait) ? "active" : "empty";
3020 
3021 	len += sprintf(buffer,
3022 		       "JFS TxAnchor\n"
3023 		       "============\n"
3024 		       "freetid = %d\n"
3025 		       "freewait = %s\n"
3026 		       "freelock = %d\n"
3027 		       "freelockwait = %s\n"
3028 		       "lowlockwait = %s\n"
3029 		       "tlocksInUse = %d\n"
3030 		       "jfs_tlocks_low = %d\n"
3031 		       "unlock_queue is %sempty\n",
3032 		       TxAnchor.freetid,
3033 		       freewait,
3034 		       TxAnchor.freelock,
3035 		       freelockwait,
3036 		       lowlockwait,
3037 		       TxAnchor.tlocksInUse,
3038 		       jfs_tlocks_low,
3039 		       list_empty(&TxAnchor.unlock_queue) ? "" : "not ");
3040 
3041 	begin = offset;
3042 	*start = buffer + begin;
3043 	len -= begin;
3044 
3045 	if (len > length)
3046 		len = length;
3047 	else
3048 		*eof = 1;
3049 
3050 	if (len < 0)
3051 		len = 0;
3052 
3053 	return len;
3054 }
3055 #endif
3056 
3057 #if defined(CONFIG_PROC_FS) && defined(CONFIG_JFS_STATISTICS)
3058 int jfs_txstats_read(char *buffer, char **start, off_t offset, int length,
3059 		     int *eof, void *data)
3060 {
3061 	int len = 0;
3062 	off_t begin;
3063 
3064 	len += sprintf(buffer,
3065 		       "JFS TxStats\n"
3066 		       "===========\n"
3067 		       "calls to txBegin = %d\n"
3068 		       "txBegin blocked by sync barrier = %d\n"
3069 		       "txBegin blocked by tlocks low = %d\n"
3070 		       "txBegin blocked by no free tid = %d\n"
3071 		       "calls to txBeginAnon = %d\n"
3072 		       "txBeginAnon blocked by sync barrier = %d\n"
3073 		       "txBeginAnon blocked by tlocks low = %d\n"
3074 		       "calls to txLockAlloc = %d\n"
3075 		       "tLockAlloc blocked by no free lock = %d\n",
3076 		       TxStat.txBegin,
3077 		       TxStat.txBegin_barrier,
3078 		       TxStat.txBegin_lockslow,
3079 		       TxStat.txBegin_freetid,
3080 		       TxStat.txBeginAnon,
3081 		       TxStat.txBeginAnon_barrier,
3082 		       TxStat.txBeginAnon_lockslow,
3083 		       TxStat.txLockAlloc,
3084 		       TxStat.txLockAlloc_freelock);
3085 
3086 	begin = offset;
3087 	*start = buffer + begin;
3088 	len -= begin;
3089 
3090 	if (len > length)
3091 		len = length;
3092 	else
3093 		*eof = 1;
3094 
3095 	if (len < 0)
3096 		len = 0;
3097 
3098 	return len;
3099 }
3100 #endif
3101