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