[PATCH] JFS: Changes for larger page size
[linux-3.10.git] / fs / jfs / jfs_logmgr.c
1 /*
2  *   Copyright (C) International Business Machines Corp., 2000-2004
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_logmgr.c: log manager
22  *
23  * for related information, see transaction manager (jfs_txnmgr.c), and
24  * recovery manager (jfs_logredo.c).
25  *
26  * note: for detail, RTFS.
27  *
28  *      log buffer manager:
29  * special purpose buffer manager supporting log i/o requirements.
30  * per log serial pageout of logpage
31  * queuing i/o requests and redrive i/o at iodone
32  * maintain current logpage buffer
33  * no caching since append only
34  * appropriate jfs buffer cache buffers as needed
35  *
36  *      group commit:
37  * transactions which wrote COMMIT records in the same in-memory
38  * log page during the pageout of previous/current log page(s) are
39  * committed together by the pageout of the page.
40  *
41  *      TBD lazy commit:
42  * transactions are committed asynchronously when the log page
43  * containing it COMMIT is paged out when it becomes full;
44  *
45  *      serialization:
46  * . a per log lock serialize log write.
47  * . a per log lock serialize group commit.
48  * . a per log lock serialize log open/close;
49  *
50  *      TBD log integrity:
51  * careful-write (ping-pong) of last logpage to recover from crash
52  * in overwrite.
53  * detection of split (out-of-order) write of physical sectors
54  * of last logpage via timestamp at end of each sector
55  * with its mirror data array at trailer).
56  *
57  *      alternatives:
58  * lsn - 64-bit monotonically increasing integer vs
59  * 32-bit lspn and page eor.
60  */
61
62 #include <linux/fs.h>
63 #include <linux/blkdev.h>
64 #include <linux/interrupt.h>
65 #include <linux/smp_lock.h>
66 #include <linux/completion.h>
67 #include <linux/buffer_head.h>          /* for sync_blockdev() */
68 #include <linux/bio.h>
69 #include <linux/suspend.h>
70 #include <linux/delay.h>
71 #include "jfs_incore.h"
72 #include "jfs_filsys.h"
73 #include "jfs_metapage.h"
74 #include "jfs_txnmgr.h"
75 #include "jfs_debug.h"
76
77
78 /*
79  * lbuf's ready to be redriven.  Protected by log_redrive_lock (jfsIO thread)
80  */
81 static struct lbuf *log_redrive_list;
82 static DEFINE_SPINLOCK(log_redrive_lock);
83 DECLARE_WAIT_QUEUE_HEAD(jfs_IO_thread_wait);
84
85
86 /*
87  *      log read/write serialization (per log)
88  */
89 #define LOG_LOCK_INIT(log)      init_MUTEX(&(log)->loglock)
90 #define LOG_LOCK(log)           down(&((log)->loglock))
91 #define LOG_UNLOCK(log)         up(&((log)->loglock))
92
93
94 /*
95  *      log group commit serialization (per log)
96  */
97
98 #define LOGGC_LOCK_INIT(log)    spin_lock_init(&(log)->gclock)
99 #define LOGGC_LOCK(log)         spin_lock_irq(&(log)->gclock)
100 #define LOGGC_UNLOCK(log)       spin_unlock_irq(&(log)->gclock)
101 #define LOGGC_WAKEUP(tblk)      wake_up_all(&(tblk)->gcwait)
102
103 /*
104  *      log sync serialization (per log)
105  */
106 #define LOGSYNC_DELTA(logsize)          min((logsize)/8, 128*LOGPSIZE)
107 #define LOGSYNC_BARRIER(logsize)        ((logsize)/4)
108 /*
109 #define LOGSYNC_DELTA(logsize)          min((logsize)/4, 256*LOGPSIZE)
110 #define LOGSYNC_BARRIER(logsize)        ((logsize)/2)
111 */
112
113
114 /*
115  *      log buffer cache synchronization
116  */
117 static DEFINE_SPINLOCK(jfsLCacheLock);
118
119 #define LCACHE_LOCK(flags)      spin_lock_irqsave(&jfsLCacheLock, flags)
120 #define LCACHE_UNLOCK(flags)    spin_unlock_irqrestore(&jfsLCacheLock, flags)
121
122 /*
123  * See __SLEEP_COND in jfs_locks.h
124  */
125 #define LCACHE_SLEEP_COND(wq, cond, flags)      \
126 do {                                            \
127         if (cond)                               \
128                 break;                          \
129         __SLEEP_COND(wq, cond, LCACHE_LOCK(flags), LCACHE_UNLOCK(flags)); \
130 } while (0)
131
132 #define LCACHE_WAKEUP(event)    wake_up(event)
133
134
135 /*
136  *      lbuf buffer cache (lCache) control
137  */
138 /* log buffer manager pageout control (cumulative, inclusive) */
139 #define lbmREAD         0x0001
140 #define lbmWRITE        0x0002  /* enqueue at tail of write queue;
141                                  * init pageout if at head of queue;
142                                  */
143 #define lbmRELEASE      0x0004  /* remove from write queue
144                                  * at completion of pageout;
145                                  * do not free/recycle it yet:
146                                  * caller will free it;
147                                  */
148 #define lbmSYNC         0x0008  /* do not return to freelist
149                                  * when removed from write queue;
150                                  */
151 #define lbmFREE         0x0010  /* return to freelist
152                                  * at completion of pageout;
153                                  * the buffer may be recycled;
154                                  */
155 #define lbmDONE         0x0020
156 #define lbmERROR        0x0040
157 #define lbmGC           0x0080  /* lbmIODone to perform post-GC processing
158                                  * of log page
159                                  */
160 #define lbmDIRECT       0x0100
161
162 /*
163  * Global list of active external journals
164  */
165 static LIST_HEAD(jfs_external_logs);
166 static struct jfs_log *dummy_log = NULL;
167 static DECLARE_MUTEX(jfs_log_sem);
168
169 /*
170  * external references
171  */
172 extern void txLazyUnlock(struct tblock * tblk);
173 extern int jfs_stop_threads;
174 extern struct completion jfsIOwait;
175 extern int jfs_tlocks_low;
176
177 /*
178  * forward references
179  */
180 static int lmWriteRecord(struct jfs_log * log, struct tblock * tblk,
181                          struct lrd * lrd, struct tlock * tlck);
182
183 static int lmNextPage(struct jfs_log * log);
184 static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
185                            int activate);
186
187 static int open_inline_log(struct super_block *sb);
188 static int open_dummy_log(struct super_block *sb);
189 static int lbmLogInit(struct jfs_log * log);
190 static void lbmLogShutdown(struct jfs_log * log);
191 static struct lbuf *lbmAllocate(struct jfs_log * log, int);
192 static void lbmFree(struct lbuf * bp);
193 static void lbmfree(struct lbuf * bp);
194 static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp);
195 static void lbmWrite(struct jfs_log * log, struct lbuf * bp, int flag, int cant_block);
196 static void lbmDirectWrite(struct jfs_log * log, struct lbuf * bp, int flag);
197 static int lbmIOWait(struct lbuf * bp, int flag);
198 static bio_end_io_t lbmIODone;
199 static void lbmStartIO(struct lbuf * bp);
200 static void lmGCwrite(struct jfs_log * log, int cant_block);
201 static int lmLogSync(struct jfs_log * log, int nosyncwait);
202
203
204
205 /*
206  *      statistics
207  */
208 #ifdef CONFIG_JFS_STATISTICS
209 static struct lmStat {
210         uint commit;            /* # of commit */
211         uint pagedone;          /* # of page written */
212         uint submitted;         /* # of pages submitted */
213         uint full_page;         /* # of full pages submitted */
214         uint partial_page;      /* # of partial pages submitted */
215 } lmStat;
216 #endif
217
218
219 /*
220  * NAME:        lmLog()
221  *
222  * FUNCTION:    write a log record;
223  *
224  * PARAMETER:
225  *
226  * RETURN:      lsn - offset to the next log record to write (end-of-log);
227  *              -1  - error;
228  *
229  * note: todo: log error handler
230  */
231 int lmLog(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
232           struct tlock * tlck)
233 {
234         int lsn;
235         int diffp, difft;
236         struct metapage *mp = NULL;
237
238         jfs_info("lmLog: log:0x%p tblk:0x%p, lrd:0x%p tlck:0x%p",
239                  log, tblk, lrd, tlck);
240
241         LOG_LOCK(log);
242
243         /* log by (out-of-transaction) JFS ? */
244         if (tblk == NULL)
245                 goto writeRecord;
246
247         /* log from page ? */
248         if (tlck == NULL ||
249             tlck->type & tlckBTROOT || (mp = tlck->mp) == NULL)
250                 goto writeRecord;
251
252         /*
253          *      initialize/update page/transaction recovery lsn
254          */
255         lsn = log->lsn;
256
257         LOGSYNC_LOCK(log);
258
259         /*
260          * initialize page lsn if first log write of the page
261          */
262         if (mp->lsn == 0) {
263                 mp->log = log;
264                 mp->lsn = lsn;
265                 log->count++;
266
267                 /* insert page at tail of logsynclist */
268                 list_add_tail(&mp->synclist, &log->synclist);
269         }
270
271         /*
272          *      initialize/update lsn of tblock of the page
273          *
274          * transaction inherits oldest lsn of pages associated
275          * with allocation/deallocation of resources (their
276          * log records are used to reconstruct allocation map
277          * at recovery time: inode for inode allocation map,
278          * B+-tree index of extent descriptors for block
279          * allocation map);
280          * allocation map pages inherit transaction lsn at
281          * commit time to allow forwarding log syncpt past log
282          * records associated with allocation/deallocation of
283          * resources only after persistent map of these map pages
284          * have been updated and propagated to home.
285          */
286         /*
287          * initialize transaction lsn:
288          */
289         if (tblk->lsn == 0) {
290                 /* inherit lsn of its first page logged */
291                 tblk->lsn = mp->lsn;
292                 log->count++;
293
294                 /* insert tblock after the page on logsynclist */
295                 list_add(&tblk->synclist, &mp->synclist);
296         }
297         /*
298          * update transaction lsn:
299          */
300         else {
301                 /* inherit oldest/smallest lsn of page */
302                 logdiff(diffp, mp->lsn, log);
303                 logdiff(difft, tblk->lsn, log);
304                 if (diffp < difft) {
305                         /* update tblock lsn with page lsn */
306                         tblk->lsn = mp->lsn;
307
308                         /* move tblock after page on logsynclist */
309                         list_move(&tblk->synclist, &mp->synclist);
310                 }
311         }
312
313         LOGSYNC_UNLOCK(log);
314
315         /*
316          *      write the log record
317          */
318       writeRecord:
319         lsn = lmWriteRecord(log, tblk, lrd, tlck);
320
321         /*
322          * forward log syncpt if log reached next syncpt trigger
323          */
324         logdiff(diffp, lsn, log);
325         if (diffp >= log->nextsync)
326                 lsn = lmLogSync(log, 0);
327
328         /* update end-of-log lsn */
329         log->lsn = lsn;
330
331         LOG_UNLOCK(log);
332
333         /* return end-of-log address */
334         return lsn;
335 }
336
337
338 /*
339  * NAME:        lmWriteRecord()
340  *
341  * FUNCTION:    move the log record to current log page
342  *
343  * PARAMETER:   cd      - commit descriptor
344  *
345  * RETURN:      end-of-log address
346  *                      
347  * serialization: LOG_LOCK() held on entry/exit
348  */
349 static int
350 lmWriteRecord(struct jfs_log * log, struct tblock * tblk, struct lrd * lrd,
351               struct tlock * tlck)
352 {
353         int lsn = 0;            /* end-of-log address */
354         struct lbuf *bp;        /* dst log page buffer */
355         struct logpage *lp;     /* dst log page */
356         caddr_t dst;            /* destination address in log page */
357         int dstoffset;          /* end-of-log offset in log page */
358         int freespace;          /* free space in log page */
359         caddr_t p;              /* src meta-data page */
360         caddr_t src;
361         int srclen;
362         int nbytes;             /* number of bytes to move */
363         int i;
364         int len;
365         struct linelock *linelock;
366         struct lv *lv;
367         struct lvd *lvd;
368         int l2linesize;
369
370         len = 0;
371
372         /* retrieve destination log page to write */
373         bp = (struct lbuf *) log->bp;
374         lp = (struct logpage *) bp->l_ldata;
375         dstoffset = log->eor;
376
377         /* any log data to write ? */
378         if (tlck == NULL)
379                 goto moveLrd;
380
381         /*
382          *      move log record data
383          */
384         /* retrieve source meta-data page to log */
385         if (tlck->flag & tlckPAGELOCK) {
386                 p = (caddr_t) (tlck->mp->data);
387                 linelock = (struct linelock *) & tlck->lock;
388         }
389         /* retrieve source in-memory inode to log */
390         else if (tlck->flag & tlckINODELOCK) {
391                 if (tlck->type & tlckDTREE)
392                         p = (caddr_t) &JFS_IP(tlck->ip)->i_dtroot;
393                 else
394                         p = (caddr_t) &JFS_IP(tlck->ip)->i_xtroot;
395                 linelock = (struct linelock *) & tlck->lock;
396         }
397 #ifdef  _JFS_WIP
398         else if (tlck->flag & tlckINLINELOCK) {
399
400                 inlinelock = (struct inlinelock *) & tlck;
401                 p = (caddr_t) & inlinelock->pxd;
402                 linelock = (struct linelock *) & tlck;
403         }
404 #endif                          /* _JFS_WIP */
405         else {
406                 jfs_err("lmWriteRecord: UFO tlck:0x%p", tlck);
407                 return 0;       /* Probably should trap */
408         }
409         l2linesize = linelock->l2linesize;
410
411       moveData:
412         ASSERT(linelock->index <= linelock->maxcnt);
413
414         lv = linelock->lv;
415         for (i = 0; i < linelock->index; i++, lv++) {
416                 if (lv->length == 0)
417                         continue;
418
419                 /* is page full ? */
420                 if (dstoffset >= LOGPSIZE - LOGPTLRSIZE) {
421                         /* page become full: move on to next page */
422                         lmNextPage(log);
423
424                         bp = log->bp;
425                         lp = (struct logpage *) bp->l_ldata;
426                         dstoffset = LOGPHDRSIZE;
427                 }
428
429                 /*
430                  * move log vector data
431                  */
432                 src = (u8 *) p + (lv->offset << l2linesize);
433                 srclen = lv->length << l2linesize;
434                 len += srclen;
435                 while (srclen > 0) {
436                         freespace = (LOGPSIZE - LOGPTLRSIZE) - dstoffset;
437                         nbytes = min(freespace, srclen);
438                         dst = (caddr_t) lp + dstoffset;
439                         memcpy(dst, src, nbytes);
440                         dstoffset += nbytes;
441
442                         /* is page not full ? */
443                         if (dstoffset < LOGPSIZE - LOGPTLRSIZE)
444                                 break;
445
446                         /* page become full: move on to next page */
447                         lmNextPage(log);
448
449                         bp = (struct lbuf *) log->bp;
450                         lp = (struct logpage *) bp->l_ldata;
451                         dstoffset = LOGPHDRSIZE;
452
453                         srclen -= nbytes;
454                         src += nbytes;
455                 }
456
457                 /*
458                  * move log vector descriptor
459                  */
460                 len += 4;
461                 lvd = (struct lvd *) ((caddr_t) lp + dstoffset);
462                 lvd->offset = cpu_to_le16(lv->offset);
463                 lvd->length = cpu_to_le16(lv->length);
464                 dstoffset += 4;
465                 jfs_info("lmWriteRecord: lv offset:%d length:%d",
466                          lv->offset, lv->length);
467         }
468
469         if ((i = linelock->next)) {
470                 linelock = (struct linelock *) lid_to_tlock(i);
471                 goto moveData;
472         }
473
474         /*
475          *      move log record descriptor
476          */
477       moveLrd:
478         lrd->length = cpu_to_le16(len);
479
480         src = (caddr_t) lrd;
481         srclen = LOGRDSIZE;
482
483         while (srclen > 0) {
484                 freespace = (LOGPSIZE - LOGPTLRSIZE) - dstoffset;
485                 nbytes = min(freespace, srclen);
486                 dst = (caddr_t) lp + dstoffset;
487                 memcpy(dst, src, nbytes);
488
489                 dstoffset += nbytes;
490                 srclen -= nbytes;
491
492                 /* are there more to move than freespace of page ? */
493                 if (srclen)
494                         goto pageFull;
495
496                 /*
497                  * end of log record descriptor
498                  */
499
500                 /* update last log record eor */
501                 log->eor = dstoffset;
502                 bp->l_eor = dstoffset;
503                 lsn = (log->page << L2LOGPSIZE) + dstoffset;
504
505                 if (lrd->type & cpu_to_le16(LOG_COMMIT)) {
506                         tblk->clsn = lsn;
507                         jfs_info("wr: tclsn:0x%x, beor:0x%x", tblk->clsn,
508                                  bp->l_eor);
509
510                         INCREMENT(lmStat.commit);       /* # of commit */
511
512                         /*
513                          * enqueue tblock for group commit:
514                          *
515                          * enqueue tblock of non-trivial/synchronous COMMIT
516                          * at tail of group commit queue
517                          * (trivial/asynchronous COMMITs are ignored by
518                          * group commit.)
519                          */
520                         LOGGC_LOCK(log);
521
522                         /* init tblock gc state */
523                         tblk->flag = tblkGC_QUEUE;
524                         tblk->bp = log->bp;
525                         tblk->pn = log->page;
526                         tblk->eor = log->eor;
527
528                         /* enqueue transaction to commit queue */
529                         list_add_tail(&tblk->cqueue, &log->cqueue);
530
531                         LOGGC_UNLOCK(log);
532                 }
533
534                 jfs_info("lmWriteRecord: lrd:0x%04x bp:0x%p pn:%d eor:0x%x",
535                         le16_to_cpu(lrd->type), log->bp, log->page, dstoffset);
536
537                 /* page not full ? */
538                 if (dstoffset < LOGPSIZE - LOGPTLRSIZE)
539                         return lsn;
540
541               pageFull:
542                 /* page become full: move on to next page */
543                 lmNextPage(log);
544
545                 bp = (struct lbuf *) log->bp;
546                 lp = (struct logpage *) bp->l_ldata;
547                 dstoffset = LOGPHDRSIZE;
548                 src += nbytes;
549         }
550
551         return lsn;
552 }
553
554
555 /*
556  * NAME:        lmNextPage()
557  *
558  * FUNCTION:    write current page and allocate next page.
559  *
560  * PARAMETER:   log
561  *
562  * RETURN:      0
563  *                      
564  * serialization: LOG_LOCK() held on entry/exit
565  */
566 static int lmNextPage(struct jfs_log * log)
567 {
568         struct logpage *lp;
569         int lspn;               /* log sequence page number */
570         int pn;                 /* current page number */
571         struct lbuf *bp;
572         struct lbuf *nextbp;
573         struct tblock *tblk;
574
575         /* get current log page number and log sequence page number */
576         pn = log->page;
577         bp = log->bp;
578         lp = (struct logpage *) bp->l_ldata;
579         lspn = le32_to_cpu(lp->h.page);
580
581         LOGGC_LOCK(log);
582
583         /*
584          *      write or queue the full page at the tail of write queue
585          */
586         /* get the tail tblk on commit queue */
587         if (list_empty(&log->cqueue))
588                 tblk = NULL;
589         else
590                 tblk = list_entry(log->cqueue.prev, struct tblock, cqueue);
591
592         /* every tblk who has COMMIT record on the current page,
593          * and has not been committed, must be on commit queue
594          * since tblk is queued at commit queueu at the time
595          * of writing its COMMIT record on the page before
596          * page becomes full (even though the tblk thread
597          * who wrote COMMIT record may have been suspended
598          * currently);
599          */
600
601         /* is page bound with outstanding tail tblk ? */
602         if (tblk && tblk->pn == pn) {
603                 /* mark tblk for end-of-page */
604                 tblk->flag |= tblkGC_EOP;
605
606                 if (log->cflag & logGC_PAGEOUT) {
607                         /* if page is not already on write queue,
608                          * just enqueue (no lbmWRITE to prevent redrive)
609                          * buffer to wqueue to ensure correct serial order
610                          * of the pages since log pages will be added
611                          * continuously
612                          */
613                         if (bp->l_wqnext == NULL)
614                                 lbmWrite(log, bp, 0, 0);
615                 } else {
616                         /*
617                          * No current GC leader, initiate group commit
618                          */
619                         log->cflag |= logGC_PAGEOUT;
620                         lmGCwrite(log, 0);
621                 }
622         }
623         /* page is not bound with outstanding tblk:
624          * init write or mark it to be redriven (lbmWRITE)
625          */
626         else {
627                 /* finalize the page */
628                 bp->l_ceor = bp->l_eor;
629                 lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
630                 lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmFREE, 0);
631         }
632         LOGGC_UNLOCK(log);
633
634         /*
635          *      allocate/initialize next page
636          */
637         /* if log wraps, the first data page of log is 2
638          * (0 never used, 1 is superblock).
639          */
640         log->page = (pn == log->size - 1) ? 2 : pn + 1;
641         log->eor = LOGPHDRSIZE; /* ? valid page empty/full at logRedo() */
642
643         /* allocate/initialize next log page buffer */
644         nextbp = lbmAllocate(log, log->page);
645         nextbp->l_eor = log->eor;
646         log->bp = nextbp;
647
648         /* initialize next log page */
649         lp = (struct logpage *) nextbp->l_ldata;
650         lp->h.page = lp->t.page = cpu_to_le32(lspn + 1);
651         lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE);
652
653         return 0;
654 }
655
656
657 /*
658  * NAME:        lmGroupCommit()
659  *
660  * FUNCTION:    group commit
661  *      initiate pageout of the pages with COMMIT in the order of
662  *      page number - redrive pageout of the page at the head of
663  *      pageout queue until full page has been written.
664  *
665  * RETURN:      
666  *
667  * NOTE:
668  *      LOGGC_LOCK serializes log group commit queue, and
669  *      transaction blocks on the commit queue.
670  *      N.B. LOG_LOCK is NOT held during lmGroupCommit().
671  */
672 int lmGroupCommit(struct jfs_log * log, struct tblock * tblk)
673 {
674         int rc = 0;
675
676         LOGGC_LOCK(log);
677
678         /* group committed already ? */
679         if (tblk->flag & tblkGC_COMMITTED) {
680                 if (tblk->flag & tblkGC_ERROR)
681                         rc = -EIO;
682
683                 LOGGC_UNLOCK(log);
684                 return rc;
685         }
686         jfs_info("lmGroup Commit: tblk = 0x%p, gcrtc = %d", tblk, log->gcrtc);
687
688         if (tblk->xflag & COMMIT_LAZY)
689                 tblk->flag |= tblkGC_LAZY;
690
691         if ((!(log->cflag & logGC_PAGEOUT)) && (!list_empty(&log->cqueue)) &&
692             (!(tblk->xflag & COMMIT_LAZY) || test_bit(log_FLUSH, &log->flag)
693              || jfs_tlocks_low)) {
694                 /*
695                  * No pageout in progress
696                  *
697                  * start group commit as its group leader.
698                  */
699                 log->cflag |= logGC_PAGEOUT;
700
701                 lmGCwrite(log, 0);
702         }
703
704         if (tblk->xflag & COMMIT_LAZY) {
705                 /*
706                  * Lazy transactions can leave now
707                  */
708                 LOGGC_UNLOCK(log);
709                 return 0;
710         }
711
712         /* lmGCwrite gives up LOGGC_LOCK, check again */
713
714         if (tblk->flag & tblkGC_COMMITTED) {
715                 if (tblk->flag & tblkGC_ERROR)
716                         rc = -EIO;
717
718                 LOGGC_UNLOCK(log);
719                 return rc;
720         }
721
722         /* upcount transaction waiting for completion
723          */
724         log->gcrtc++;
725         tblk->flag |= tblkGC_READY;
726
727         __SLEEP_COND(tblk->gcwait, (tblk->flag & tblkGC_COMMITTED),
728                      LOGGC_LOCK(log), LOGGC_UNLOCK(log));
729
730         /* removed from commit queue */
731         if (tblk->flag & tblkGC_ERROR)
732                 rc = -EIO;
733
734         LOGGC_UNLOCK(log);
735         return rc;
736 }
737
738 /*
739  * NAME:        lmGCwrite()
740  *
741  * FUNCTION:    group commit write
742  *      initiate write of log page, building a group of all transactions
743  *      with commit records on that page.
744  *
745  * RETURN:      None
746  *
747  * NOTE:
748  *      LOGGC_LOCK must be held by caller.
749  *      N.B. LOG_LOCK is NOT held during lmGroupCommit().
750  */
751 static void lmGCwrite(struct jfs_log * log, int cant_write)
752 {
753         struct lbuf *bp;
754         struct logpage *lp;
755         int gcpn;               /* group commit page number */
756         struct tblock *tblk;
757         struct tblock *xtblk = NULL;
758
759         /*
760          * build the commit group of a log page
761          *
762          * scan commit queue and make a commit group of all
763          * transactions with COMMIT records on the same log page.
764          */
765         /* get the head tblk on the commit queue */
766         gcpn = list_entry(log->cqueue.next, struct tblock, cqueue)->pn;
767
768         list_for_each_entry(tblk, &log->cqueue, cqueue) {
769                 if (tblk->pn != gcpn)
770                         break;
771
772                 xtblk = tblk;
773
774                 /* state transition: (QUEUE, READY) -> COMMIT */
775                 tblk->flag |= tblkGC_COMMIT;
776         }
777         tblk = xtblk;           /* last tblk of the page */
778
779         /*
780          * pageout to commit transactions on the log page.
781          */
782         bp = (struct lbuf *) tblk->bp;
783         lp = (struct logpage *) bp->l_ldata;
784         /* is page already full ? */
785         if (tblk->flag & tblkGC_EOP) {
786                 /* mark page to free at end of group commit of the page */
787                 tblk->flag &= ~tblkGC_EOP;
788                 tblk->flag |= tblkGC_FREE;
789                 bp->l_ceor = bp->l_eor;
790                 lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
791                 lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmGC,
792                          cant_write);
793                 INCREMENT(lmStat.full_page);
794         }
795         /* page is not yet full */
796         else {
797                 bp->l_ceor = tblk->eor; /* ? bp->l_ceor = bp->l_eor; */
798                 lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_ceor);
799                 lbmWrite(log, bp, lbmWRITE | lbmGC, cant_write);
800                 INCREMENT(lmStat.partial_page);
801         }
802 }
803
804 /*
805  * NAME:        lmPostGC()
806  *
807  * FUNCTION:    group commit post-processing
808  *      Processes transactions after their commit records have been written
809  *      to disk, redriving log I/O if necessary.
810  *
811  * RETURN:      None
812  *
813  * NOTE:
814  *      This routine is called a interrupt time by lbmIODone
815  */
816 static void lmPostGC(struct lbuf * bp)
817 {
818         unsigned long flags;
819         struct jfs_log *log = bp->l_log;
820         struct logpage *lp;
821         struct tblock *tblk, *temp;
822
823         //LOGGC_LOCK(log);
824         spin_lock_irqsave(&log->gclock, flags);
825         /*
826          * current pageout of group commit completed.
827          *
828          * remove/wakeup transactions from commit queue who were
829          * group committed with the current log page
830          */
831         list_for_each_entry_safe(tblk, temp, &log->cqueue, cqueue) {
832                 if (!(tblk->flag & tblkGC_COMMIT))
833                         break;
834                 /* if transaction was marked GC_COMMIT then
835                  * it has been shipped in the current pageout
836                  * and made it to disk - it is committed.
837                  */
838
839                 if (bp->l_flag & lbmERROR)
840                         tblk->flag |= tblkGC_ERROR;
841
842                 /* remove it from the commit queue */
843                 list_del(&tblk->cqueue);
844                 tblk->flag &= ~tblkGC_QUEUE;
845
846                 if (tblk == log->flush_tblk) {
847                         /* we can stop flushing the log now */
848                         clear_bit(log_FLUSH, &log->flag);
849                         log->flush_tblk = NULL;
850                 }
851
852                 jfs_info("lmPostGC: tblk = 0x%p, flag = 0x%x", tblk,
853                          tblk->flag);
854
855                 if (!(tblk->xflag & COMMIT_FORCE))
856                         /*
857                          * Hand tblk over to lazy commit thread
858                          */
859                         txLazyUnlock(tblk);
860                 else {
861                         /* state transition: COMMIT -> COMMITTED */
862                         tblk->flag |= tblkGC_COMMITTED;
863
864                         if (tblk->flag & tblkGC_READY)
865                                 log->gcrtc--;
866
867                         LOGGC_WAKEUP(tblk);
868                 }
869
870                 /* was page full before pageout ?
871                  * (and this is the last tblk bound with the page)
872                  */
873                 if (tblk->flag & tblkGC_FREE)
874                         lbmFree(bp);
875                 /* did page become full after pageout ?
876                  * (and this is the last tblk bound with the page)
877                  */
878                 else if (tblk->flag & tblkGC_EOP) {
879                         /* finalize the page */
880                         lp = (struct logpage *) bp->l_ldata;
881                         bp->l_ceor = bp->l_eor;
882                         lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
883                         jfs_info("lmPostGC: calling lbmWrite");
884                         lbmWrite(log, bp, lbmWRITE | lbmRELEASE | lbmFREE,
885                                  1);
886                 }
887
888         }
889
890         /* are there any transactions who have entered lnGroupCommit()
891          * (whose COMMITs are after that of the last log page written.
892          * They are waiting for new group commit (above at (SLEEP 1))
893          * or lazy transactions are on a full (queued) log page,
894          * select the latest ready transaction as new group leader and
895          * wake her up to lead her group.
896          */
897         if ((!list_empty(&log->cqueue)) &&
898             ((log->gcrtc > 0) || (tblk->bp->l_wqnext != NULL) ||
899              test_bit(log_FLUSH, &log->flag) || jfs_tlocks_low))
900                 /*
901                  * Call lmGCwrite with new group leader
902                  */
903                 lmGCwrite(log, 1);
904
905         /* no transaction are ready yet (transactions are only just
906          * queued (GC_QUEUE) and not entered for group commit yet).
907          * the first transaction entering group commit
908          * will elect herself as new group leader.
909          */
910         else
911                 log->cflag &= ~logGC_PAGEOUT;
912
913         //LOGGC_UNLOCK(log);
914         spin_unlock_irqrestore(&log->gclock, flags);
915         return;
916 }
917
918 /*
919  * NAME:        lmLogSync()
920  *
921  * FUNCTION:    write log SYNCPT record for specified log
922  *      if new sync address is available
923  *      (normally the case if sync() is executed by back-ground
924  *      process).
925  *      if not, explicitly run jfs_blogsync() to initiate
926  *      getting of new sync address.
927  *      calculate new value of i_nextsync which determines when
928  *      this code is called again.
929  *
930  *      this is called only from lmLog().
931  *
932  * PARAMETER:   ip      - pointer to logs inode.
933  *
934  * RETURN:      0
935  *                      
936  * serialization: LOG_LOCK() held on entry/exit
937  */
938 static int lmLogSync(struct jfs_log * log, int nosyncwait)
939 {
940         int logsize;
941         int written;            /* written since last syncpt */
942         int free;               /* free space left available */
943         int delta;              /* additional delta to write normally */
944         int more;               /* additional write granted */
945         struct lrd lrd;
946         int lsn;
947         struct logsyncblk *lp;
948
949         /*
950          *      forward syncpt
951          */
952         /* if last sync is same as last syncpt,
953          * invoke sync point forward processing to update sync.
954          */
955
956         if (log->sync == log->syncpt) {
957                 LOGSYNC_LOCK(log);
958                 /* ToDo: push dirty metapages out to disk */
959 //              bmLogSync(log);
960
961                 if (list_empty(&log->synclist))
962                         log->sync = log->lsn;
963                 else {
964                         lp = list_entry(log->synclist.next,
965                                         struct logsyncblk, synclist);
966                         log->sync = lp->lsn;
967                 }
968                 LOGSYNC_UNLOCK(log);
969
970         }
971
972         /* if sync is different from last syncpt,
973          * write a SYNCPT record with syncpt = sync.
974          * reset syncpt = sync
975          */
976         if (log->sync != log->syncpt) {
977                 struct jfs_sb_info *sbi;
978
979                 /*
980                  * We need to make sure all of the "written" metapages
981                  * actually make it to disk
982                  */
983                 list_for_each_entry(sbi, &log->sb_list, log_list) {
984                         if (sbi->flag & JFS_NOINTEGRITY)
985                                 continue;
986                         filemap_fdatawrite(sbi->ipbmap->i_mapping);
987                         filemap_fdatawrite(sbi->ipimap->i_mapping);
988                         filemap_fdatawrite(sbi->sb->s_bdev->bd_inode->i_mapping);
989                 }
990                 list_for_each_entry(sbi, &log->sb_list, log_list) {
991                         if (sbi->flag & JFS_NOINTEGRITY)
992                                 continue;
993                         filemap_fdatawait(sbi->ipbmap->i_mapping);
994                         filemap_fdatawait(sbi->ipimap->i_mapping);
995                         filemap_fdatawait(sbi->sb->s_bdev->bd_inode->i_mapping);
996                 }
997
998                 lrd.logtid = 0;
999                 lrd.backchain = 0;
1000                 lrd.type = cpu_to_le16(LOG_SYNCPT);
1001                 lrd.length = 0;
1002                 lrd.log.syncpt.sync = cpu_to_le32(log->sync);
1003                 lsn = lmWriteRecord(log, NULL, &lrd, NULL);
1004
1005                 log->syncpt = log->sync;
1006         } else
1007                 lsn = log->lsn;
1008
1009         /*
1010          *      setup next syncpt trigger (SWAG)
1011          */
1012         logsize = log->logsize;
1013
1014         logdiff(written, lsn, log);
1015         free = logsize - written;
1016         delta = LOGSYNC_DELTA(logsize);
1017         more = min(free / 2, delta);
1018         if (more < 2 * LOGPSIZE) {
1019                 jfs_warn("\n ... Log Wrap ... Log Wrap ... Log Wrap ...\n");
1020                 /*
1021                  *      log wrapping
1022                  *
1023                  * option 1 - panic ? No.!
1024                  * option 2 - shutdown file systems
1025                  *            associated with log ?
1026                  * option 3 - extend log ?
1027                  */
1028                 /*
1029                  * option 4 - second chance
1030                  *
1031                  * mark log wrapped, and continue.
1032                  * when all active transactions are completed,
1033                  * mark log vaild for recovery.
1034                  * if crashed during invalid state, log state
1035                  * implies invald log, forcing fsck().
1036                  */
1037                 /* mark log state log wrap in log superblock */
1038                 /* log->state = LOGWRAP; */
1039
1040                 /* reset sync point computation */
1041                 log->syncpt = log->sync = lsn;
1042                 log->nextsync = delta;
1043         } else
1044                 /* next syncpt trigger = written + more */
1045                 log->nextsync = written + more;
1046
1047         /* return if lmLogSync() from outside of transaction, e.g., sync() */
1048         if (nosyncwait)
1049                 return lsn;
1050
1051         /* if number of bytes written from last sync point is more
1052          * than 1/4 of the log size, stop new transactions from
1053          * starting until all current transactions are completed
1054          * by setting syncbarrier flag.
1055          */
1056         if (written > LOGSYNC_BARRIER(logsize) && logsize > 32 * LOGPSIZE) {
1057                 set_bit(log_SYNCBARRIER, &log->flag);
1058                 jfs_info("log barrier on: lsn=0x%x syncpt=0x%x", lsn,
1059                          log->syncpt);
1060                 /*
1061                  * We may have to initiate group commit
1062                  */
1063                 jfs_flush_journal(log, 0);
1064         }
1065
1066         return lsn;
1067 }
1068
1069
1070 /*
1071  * NAME:        lmLogOpen()
1072  *
1073  * FUNCTION:    open the log on first open;
1074  *      insert filesystem in the active list of the log.
1075  *
1076  * PARAMETER:   ipmnt   - file system mount inode
1077  *              iplog   - log inode (out)
1078  *
1079  * RETURN:
1080  *
1081  * serialization:
1082  */
1083 int lmLogOpen(struct super_block *sb)
1084 {
1085         int rc;
1086         struct block_device *bdev;
1087         struct jfs_log *log;
1088         struct jfs_sb_info *sbi = JFS_SBI(sb);
1089
1090         if (sbi->flag & JFS_NOINTEGRITY)
1091                 return open_dummy_log(sb);
1092         
1093         if (sbi->mntflag & JFS_INLINELOG)
1094                 return open_inline_log(sb);
1095
1096         down(&jfs_log_sem);
1097         list_for_each_entry(log, &jfs_external_logs, journal_list) {
1098                 if (log->bdev->bd_dev == sbi->logdev) {
1099                         if (memcmp(log->uuid, sbi->loguuid,
1100                                    sizeof(log->uuid))) {
1101                                 jfs_warn("wrong uuid on JFS journal\n");
1102                                 up(&jfs_log_sem);
1103                                 return -EINVAL;
1104                         }
1105                         /*
1106                          * add file system to log active file system list
1107                          */
1108                         if ((rc = lmLogFileSystem(log, sbi, 1))) {
1109                                 up(&jfs_log_sem);
1110                                 return rc;
1111                         }
1112                         goto journal_found;
1113                 }
1114         }
1115
1116         if (!(log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL))) {
1117                 up(&jfs_log_sem);
1118                 return -ENOMEM;
1119         }
1120         memset(log, 0, sizeof(struct jfs_log));
1121         INIT_LIST_HEAD(&log->sb_list);
1122         init_waitqueue_head(&log->syncwait);
1123
1124         /*
1125          *      external log as separate logical volume
1126          *
1127          * file systems to log may have n-to-1 relationship;
1128          */
1129
1130         bdev = open_by_devnum(sbi->logdev, FMODE_READ|FMODE_WRITE);
1131         if (IS_ERR(bdev)) {
1132                 rc = -PTR_ERR(bdev);
1133                 goto free;
1134         }
1135
1136         if ((rc = bd_claim(bdev, log))) {
1137                 goto close;
1138         }
1139
1140         log->bdev = bdev;
1141         memcpy(log->uuid, sbi->loguuid, sizeof(log->uuid));
1142         
1143         /*
1144          * initialize log:
1145          */
1146         if ((rc = lmLogInit(log)))
1147                 goto unclaim;
1148
1149         list_add(&log->journal_list, &jfs_external_logs);
1150
1151         /*
1152          * add file system to log active file system list
1153          */
1154         if ((rc = lmLogFileSystem(log, sbi, 1)))
1155                 goto shutdown;
1156
1157 journal_found:
1158         LOG_LOCK(log);
1159         list_add(&sbi->log_list, &log->sb_list);
1160         sbi->log = log;
1161         LOG_UNLOCK(log);
1162
1163         up(&jfs_log_sem);
1164         return 0;
1165
1166         /*
1167          *      unwind on error
1168          */
1169       shutdown:         /* unwind lbmLogInit() */
1170         list_del(&log->journal_list);
1171         lbmLogShutdown(log);
1172
1173       unclaim:
1174         bd_release(bdev);
1175
1176       close:            /* close external log device */
1177         blkdev_put(bdev);
1178
1179       free:             /* free log descriptor */
1180         up(&jfs_log_sem);
1181         kfree(log);
1182
1183         jfs_warn("lmLogOpen: exit(%d)", rc);
1184         return rc;
1185 }
1186
1187 static int open_inline_log(struct super_block *sb)
1188 {
1189         struct jfs_log *log;
1190         int rc;
1191
1192         if (!(log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL)))
1193                 return -ENOMEM;
1194         memset(log, 0, sizeof(struct jfs_log));
1195         INIT_LIST_HEAD(&log->sb_list);
1196         init_waitqueue_head(&log->syncwait);
1197
1198         set_bit(log_INLINELOG, &log->flag);
1199         log->bdev = sb->s_bdev;
1200         log->base = addressPXD(&JFS_SBI(sb)->logpxd);
1201         log->size = lengthPXD(&JFS_SBI(sb)->logpxd) >>
1202             (L2LOGPSIZE - sb->s_blocksize_bits);
1203         log->l2bsize = sb->s_blocksize_bits;
1204         ASSERT(L2LOGPSIZE >= sb->s_blocksize_bits);
1205
1206         /*
1207          * initialize log.
1208          */
1209         if ((rc = lmLogInit(log))) {
1210                 kfree(log);
1211                 jfs_warn("lmLogOpen: exit(%d)", rc);
1212                 return rc;
1213         }
1214
1215         list_add(&JFS_SBI(sb)->log_list, &log->sb_list);
1216         JFS_SBI(sb)->log = log;
1217
1218         return rc;
1219 }
1220
1221 static int open_dummy_log(struct super_block *sb)
1222 {
1223         int rc;
1224
1225         down(&jfs_log_sem);
1226         if (!dummy_log) {
1227                 dummy_log = kmalloc(sizeof(struct jfs_log), GFP_KERNEL);
1228                 if (!dummy_log) {
1229                         up(&jfs_log_sem);
1230                         return -ENOMEM;
1231                 }
1232                 memset(dummy_log, 0, sizeof(struct jfs_log));
1233                 INIT_LIST_HEAD(&dummy_log->sb_list);
1234                 init_waitqueue_head(&dummy_log->syncwait);
1235                 dummy_log->no_integrity = 1;
1236                 /* Make up some stuff */
1237                 dummy_log->base = 0;
1238                 dummy_log->size = 1024;
1239                 rc = lmLogInit(dummy_log);
1240                 if (rc) {
1241                         kfree(dummy_log);
1242                         dummy_log = NULL;
1243                         up(&jfs_log_sem);
1244                         return rc;
1245                 }
1246         }
1247
1248         LOG_LOCK(dummy_log);
1249         list_add(&JFS_SBI(sb)->log_list, &dummy_log->sb_list);
1250         JFS_SBI(sb)->log = dummy_log;
1251         LOG_UNLOCK(dummy_log);
1252         up(&jfs_log_sem);
1253
1254         return 0;
1255 }
1256
1257 /*
1258  * NAME:        lmLogInit()
1259  *
1260  * FUNCTION:    log initialization at first log open.
1261  *
1262  *      logredo() (or logformat()) should have been run previously.
1263  *      initialize the log from log superblock.
1264  *      set the log state in the superblock to LOGMOUNT and
1265  *      write SYNCPT log record.
1266  *              
1267  * PARAMETER:   log     - log structure
1268  *
1269  * RETURN:      0       - if ok
1270  *              -EINVAL - bad log magic number or superblock dirty
1271  *              error returned from logwait()
1272  *                      
1273  * serialization: single first open thread
1274  */
1275 int lmLogInit(struct jfs_log * log)
1276 {
1277         int rc = 0;
1278         struct lrd lrd;
1279         struct logsuper *logsuper;
1280         struct lbuf *bpsuper;
1281         struct lbuf *bp;
1282         struct logpage *lp;
1283         int lsn = 0;
1284
1285         jfs_info("lmLogInit: log:0x%p", log);
1286
1287         /* initialize the group commit serialization lock */
1288         LOGGC_LOCK_INIT(log);
1289
1290         /* allocate/initialize the log write serialization lock */
1291         LOG_LOCK_INIT(log);
1292
1293         LOGSYNC_LOCK_INIT(log);
1294
1295         INIT_LIST_HEAD(&log->synclist);
1296
1297         INIT_LIST_HEAD(&log->cqueue);
1298         log->flush_tblk = NULL;
1299
1300         log->count = 0;
1301
1302         /*
1303          * initialize log i/o
1304          */
1305         if ((rc = lbmLogInit(log)))
1306                 return rc;
1307
1308         if (!test_bit(log_INLINELOG, &log->flag))
1309                 log->l2bsize = L2LOGPSIZE;
1310         
1311         /* check for disabled journaling to disk */
1312         if (log->no_integrity) {
1313                 /*
1314                  * Journal pages will still be filled.  When the time comes
1315                  * to actually do the I/O, the write is not done, and the
1316                  * endio routine is called directly.
1317                  */
1318                 bp = lbmAllocate(log , 0);
1319                 log->bp = bp;
1320                 bp->l_pn = bp->l_eor = 0;
1321         } else {
1322                 /*
1323                  * validate log superblock
1324                  */
1325                 if ((rc = lbmRead(log, 1, &bpsuper)))
1326                         goto errout10;
1327
1328                 logsuper = (struct logsuper *) bpsuper->l_ldata;
1329
1330                 if (logsuper->magic != cpu_to_le32(LOGMAGIC)) {
1331                         jfs_warn("*** Log Format Error ! ***");
1332                         rc = -EINVAL;
1333                         goto errout20;
1334                 }
1335
1336                 /* logredo() should have been run successfully. */
1337                 if (logsuper->state != cpu_to_le32(LOGREDONE)) {
1338                         jfs_warn("*** Log Is Dirty ! ***");
1339                         rc = -EINVAL;
1340                         goto errout20;
1341                 }
1342
1343                 /* initialize log from log superblock */
1344                 if (test_bit(log_INLINELOG,&log->flag)) {
1345                         if (log->size != le32_to_cpu(logsuper->size)) {
1346                                 rc = -EINVAL;
1347                                 goto errout20;
1348                         }
1349                         jfs_info("lmLogInit: inline log:0x%p base:0x%Lx "
1350                                  "size:0x%x", log,
1351                                  (unsigned long long) log->base, log->size);
1352                 } else {
1353                         if (memcmp(logsuper->uuid, log->uuid, 16)) {
1354                                 jfs_warn("wrong uuid on JFS log device");
1355                                 goto errout20;
1356                         }
1357                         log->size = le32_to_cpu(logsuper->size);
1358                         log->l2bsize = le32_to_cpu(logsuper->l2bsize);
1359                         jfs_info("lmLogInit: external log:0x%p base:0x%Lx "
1360                                  "size:0x%x", log,
1361                                  (unsigned long long) log->base, log->size);
1362                 }
1363
1364                 log->page = le32_to_cpu(logsuper->end) / LOGPSIZE;
1365                 log->eor = le32_to_cpu(logsuper->end) - (LOGPSIZE * log->page);
1366
1367                 /*
1368                  * initialize for log append write mode
1369                  */
1370                 /* establish current/end-of-log page/buffer */
1371                 if ((rc = lbmRead(log, log->page, &bp)))
1372                         goto errout20;
1373
1374                 lp = (struct logpage *) bp->l_ldata;
1375
1376                 jfs_info("lmLogInit: lsn:0x%x page:%d eor:%d:%d",
1377                          le32_to_cpu(logsuper->end), log->page, log->eor,
1378                          le16_to_cpu(lp->h.eor));
1379
1380                 log->bp = bp;
1381                 bp->l_pn = log->page;
1382                 bp->l_eor = log->eor;
1383
1384                 /* if current page is full, move on to next page */
1385                 if (log->eor >= LOGPSIZE - LOGPTLRSIZE)
1386                         lmNextPage(log);
1387
1388                 /*
1389                  * initialize log syncpoint
1390                  */
1391                 /*
1392                  * write the first SYNCPT record with syncpoint = 0
1393                  * (i.e., log redo up to HERE !);
1394                  * remove current page from lbm write queue at end of pageout
1395                  * (to write log superblock update), but do not release to
1396                  * freelist;
1397                  */
1398                 lrd.logtid = 0;
1399                 lrd.backchain = 0;
1400                 lrd.type = cpu_to_le16(LOG_SYNCPT);
1401                 lrd.length = 0;
1402                 lrd.log.syncpt.sync = 0;
1403                 lsn = lmWriteRecord(log, NULL, &lrd, NULL);
1404                 bp = log->bp;
1405                 bp->l_ceor = bp->l_eor;
1406                 lp = (struct logpage *) bp->l_ldata;
1407                 lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
1408                 lbmWrite(log, bp, lbmWRITE | lbmSYNC, 0);
1409                 if ((rc = lbmIOWait(bp, 0)))
1410                         goto errout30;
1411
1412                 /*
1413                  * update/write superblock
1414                  */
1415                 logsuper->state = cpu_to_le32(LOGMOUNT);
1416                 log->serial = le32_to_cpu(logsuper->serial) + 1;
1417                 logsuper->serial = cpu_to_le32(log->serial);
1418                 lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
1419                 if ((rc = lbmIOWait(bpsuper, lbmFREE)))
1420                         goto errout30;
1421         }
1422
1423         /* initialize logsync parameters */
1424         log->logsize = (log->size - 2) << L2LOGPSIZE;
1425         log->lsn = lsn;
1426         log->syncpt = lsn;
1427         log->sync = log->syncpt;
1428         log->nextsync = LOGSYNC_DELTA(log->logsize);
1429
1430         jfs_info("lmLogInit: lsn:0x%x syncpt:0x%x sync:0x%x",
1431                  log->lsn, log->syncpt, log->sync);
1432
1433         /*
1434          * initialize for lazy/group commit
1435          */
1436         log->clsn = lsn;
1437
1438         return 0;
1439
1440         /*
1441          *      unwind on error
1442          */
1443       errout30:         /* release log page */
1444         log->wqueue = NULL;
1445         bp->l_wqnext = NULL;
1446         lbmFree(bp);
1447
1448       errout20:         /* release log superblock */
1449         lbmFree(bpsuper);
1450
1451       errout10:         /* unwind lbmLogInit() */
1452         lbmLogShutdown(log);
1453
1454         jfs_warn("lmLogInit: exit(%d)", rc);
1455         return rc;
1456 }
1457
1458
1459 /*
1460  * NAME:        lmLogClose()
1461  *
1462  * FUNCTION:    remove file system <ipmnt> from active list of log <iplog>
1463  *              and close it on last close.
1464  *
1465  * PARAMETER:   sb      - superblock
1466  *
1467  * RETURN:      errors from subroutines
1468  *
1469  * serialization:
1470  */
1471 int lmLogClose(struct super_block *sb)
1472 {
1473         struct jfs_sb_info *sbi = JFS_SBI(sb);
1474         struct jfs_log *log = sbi->log;
1475         struct block_device *bdev;
1476         int rc = 0;
1477
1478         jfs_info("lmLogClose: log:0x%p", log);
1479
1480         down(&jfs_log_sem);
1481         LOG_LOCK(log);
1482         list_del(&sbi->log_list);
1483         LOG_UNLOCK(log);
1484         sbi->log = NULL;
1485
1486         /*
1487          * We need to make sure all of the "written" metapages
1488          * actually make it to disk
1489          */
1490         sync_blockdev(sb->s_bdev);
1491
1492         if (test_bit(log_INLINELOG, &log->flag)) {
1493                 /*
1494                  *      in-line log in host file system
1495                  */
1496                 rc = lmLogShutdown(log);
1497                 kfree(log);
1498                 goto out;
1499         }
1500
1501         if (!log->no_integrity)
1502                 lmLogFileSystem(log, sbi, 0);
1503
1504         if (!list_empty(&log->sb_list))
1505                 goto out;
1506
1507         /*
1508          * TODO: ensure that the dummy_log is in a state to allow
1509          * lbmLogShutdown to deallocate all the buffers and call
1510          * kfree against dummy_log.  For now, leave dummy_log & its
1511          * buffers in memory, and resuse if another no-integrity mount
1512          * is requested.
1513          */
1514         if (log->no_integrity)
1515                 goto out;
1516
1517         /*
1518          *      external log as separate logical volume
1519          */
1520         list_del(&log->journal_list);
1521         bdev = log->bdev;
1522         rc = lmLogShutdown(log);
1523
1524         bd_release(bdev);
1525         blkdev_put(bdev);
1526
1527         kfree(log);
1528
1529       out:
1530         up(&jfs_log_sem);
1531         jfs_info("lmLogClose: exit(%d)", rc);
1532         return rc;
1533 }
1534
1535
1536 /*
1537  * NAME:        jfs_flush_journal()
1538  *
1539  * FUNCTION:    initiate write of any outstanding transactions to the journal
1540  *              and optionally wait until they are all written to disk
1541  *
1542  *              wait == 0  flush until latest txn is committed, don't wait
1543  *              wait == 1  flush until latest txn is committed, wait
1544  *              wait > 1   flush until all txn's are complete, wait
1545  */
1546 void jfs_flush_journal(struct jfs_log *log, int wait)
1547 {
1548         int i;
1549         struct tblock *target = NULL;
1550
1551         /* jfs_write_inode may call us during read-only mount */
1552         if (!log)
1553                 return;
1554
1555         jfs_info("jfs_flush_journal: log:0x%p wait=%d", log, wait);
1556
1557         LOGGC_LOCK(log);
1558
1559         if (!list_empty(&log->cqueue)) {
1560                 /*
1561                  * This ensures that we will keep writing to the journal as long
1562                  * as there are unwritten commit records
1563                  */
1564                 target = list_entry(log->cqueue.prev, struct tblock, cqueue);
1565
1566                 if (test_bit(log_FLUSH, &log->flag)) {
1567                         /*
1568                          * We're already flushing.
1569                          * if flush_tblk is NULL, we are flushing everything,
1570                          * so leave it that way.  Otherwise, update it to the
1571                          * latest transaction
1572                          */
1573                         if (log->flush_tblk)
1574                                 log->flush_tblk = target;
1575                 } else {
1576                         /* Only flush until latest transaction is committed */
1577                         log->flush_tblk = target;
1578                         set_bit(log_FLUSH, &log->flag);
1579
1580                         /*
1581                          * Initiate I/O on outstanding transactions
1582                          */
1583                         if (!(log->cflag & logGC_PAGEOUT)) {
1584                                 log->cflag |= logGC_PAGEOUT;
1585                                 lmGCwrite(log, 0);
1586                         }
1587                 }
1588         }
1589         if ((wait > 1) || test_bit(log_SYNCBARRIER, &log->flag)) {
1590                 /* Flush until all activity complete */
1591                 set_bit(log_FLUSH, &log->flag);
1592                 log->flush_tblk = NULL;
1593         }
1594
1595         if (wait && target && !(target->flag & tblkGC_COMMITTED)) {
1596                 DECLARE_WAITQUEUE(__wait, current);
1597
1598                 add_wait_queue(&target->gcwait, &__wait);
1599                 set_current_state(TASK_UNINTERRUPTIBLE);
1600                 LOGGC_UNLOCK(log);
1601                 schedule();
1602                 current->state = TASK_RUNNING;
1603                 LOGGC_LOCK(log);
1604                 remove_wait_queue(&target->gcwait, &__wait);
1605         }
1606         LOGGC_UNLOCK(log);
1607
1608         if (wait < 2)
1609                 return;
1610
1611         /*
1612          * If there was recent activity, we may need to wait
1613          * for the lazycommit thread to catch up
1614          */
1615         if ((!list_empty(&log->cqueue)) || !list_empty(&log->synclist)) {
1616                 for (i = 0; i < 800; i++) {     /* Too much? */
1617                         msleep(250);
1618                         if (list_empty(&log->cqueue) &&
1619                             list_empty(&log->synclist))
1620                                 break;
1621                 }
1622         }
1623         assert(list_empty(&log->cqueue));
1624         assert(list_empty(&log->synclist));
1625         clear_bit(log_FLUSH, &log->flag);
1626 }
1627
1628 /*
1629  * NAME:        lmLogShutdown()
1630  *
1631  * FUNCTION:    log shutdown at last LogClose().
1632  *
1633  *              write log syncpt record.
1634  *              update super block to set redone flag to 0.
1635  *
1636  * PARAMETER:   log     - log inode
1637  *
1638  * RETURN:      0       - success
1639  *                      
1640  * serialization: single last close thread
1641  */
1642 int lmLogShutdown(struct jfs_log * log)
1643 {
1644         int rc;
1645         struct lrd lrd;
1646         int lsn;
1647         struct logsuper *logsuper;
1648         struct lbuf *bpsuper;
1649         struct lbuf *bp;
1650         struct logpage *lp;
1651
1652         jfs_info("lmLogShutdown: log:0x%p", log);
1653
1654         jfs_flush_journal(log, 2);
1655
1656         /*
1657          * write the last SYNCPT record with syncpoint = 0
1658          * (i.e., log redo up to HERE !)
1659          */
1660         lrd.logtid = 0;
1661         lrd.backchain = 0;
1662         lrd.type = cpu_to_le16(LOG_SYNCPT);
1663         lrd.length = 0;
1664         lrd.log.syncpt.sync = 0;
1665         
1666         lsn = lmWriteRecord(log, NULL, &lrd, NULL);
1667         bp = log->bp;
1668         lp = (struct logpage *) bp->l_ldata;
1669         lp->h.eor = lp->t.eor = cpu_to_le16(bp->l_eor);
1670         lbmWrite(log, log->bp, lbmWRITE | lbmRELEASE | lbmSYNC, 0);
1671         lbmIOWait(log->bp, lbmFREE);
1672         log->bp = NULL;
1673
1674         /*
1675          * synchronous update log superblock
1676          * mark log state as shutdown cleanly
1677          * (i.e., Log does not need to be replayed).
1678          */
1679         if ((rc = lbmRead(log, 1, &bpsuper)))
1680                 goto out;
1681
1682         logsuper = (struct logsuper *) bpsuper->l_ldata;
1683         logsuper->state = cpu_to_le32(LOGREDONE);
1684         logsuper->end = cpu_to_le32(lsn);
1685         lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
1686         rc = lbmIOWait(bpsuper, lbmFREE);
1687
1688         jfs_info("lmLogShutdown: lsn:0x%x page:%d eor:%d",
1689                  lsn, log->page, log->eor);
1690
1691       out:    
1692         /*
1693          * shutdown per log i/o
1694          */
1695         lbmLogShutdown(log);
1696
1697         if (rc) {
1698                 jfs_warn("lmLogShutdown: exit(%d)", rc);
1699         }
1700         return rc;
1701 }
1702
1703
1704 /*
1705  * NAME:        lmLogFileSystem()
1706  *
1707  * FUNCTION:    insert (<activate> = true)/remove (<activate> = false)
1708  *      file system into/from log active file system list.
1709  *
1710  * PARAMETE:    log     - pointer to logs inode.
1711  *              fsdev   - kdev_t of filesystem.
1712  *              serial  - pointer to returned log serial number
1713  *              activate - insert/remove device from active list.
1714  *
1715  * RETURN:      0       - success
1716  *              errors returned by vms_iowait().
1717  */
1718 static int lmLogFileSystem(struct jfs_log * log, struct jfs_sb_info *sbi,
1719                            int activate)
1720 {
1721         int rc = 0;
1722         int i;
1723         struct logsuper *logsuper;
1724         struct lbuf *bpsuper;
1725         char *uuid = sbi->uuid;
1726
1727         /*
1728          * insert/remove file system device to log active file system list.
1729          */
1730         if ((rc = lbmRead(log, 1, &bpsuper)))
1731                 return rc;
1732
1733         logsuper = (struct logsuper *) bpsuper->l_ldata;
1734         if (activate) {
1735                 for (i = 0; i < MAX_ACTIVE; i++)
1736                         if (!memcmp(logsuper->active[i].uuid, NULL_UUID, 16)) {
1737                                 memcpy(logsuper->active[i].uuid, uuid, 16);
1738                                 sbi->aggregate = i;
1739                                 break;
1740                         }
1741                 if (i == MAX_ACTIVE) {
1742                         jfs_warn("Too many file systems sharing journal!");
1743                         lbmFree(bpsuper);
1744                         return -EMFILE; /* Is there a better rc? */
1745                 }
1746         } else {
1747                 for (i = 0; i < MAX_ACTIVE; i++)
1748                         if (!memcmp(logsuper->active[i].uuid, uuid, 16)) {
1749                                 memcpy(logsuper->active[i].uuid, NULL_UUID, 16);
1750                                 break;
1751                         }
1752                 if (i == MAX_ACTIVE) {
1753                         jfs_warn("Somebody stomped on the journal!");
1754                         lbmFree(bpsuper);
1755                         return -EIO;
1756                 }
1757                 
1758         }
1759
1760         /*
1761          * synchronous write log superblock:
1762          *
1763          * write sidestream bypassing write queue:
1764          * at file system mount, log super block is updated for
1765          * activation of the file system before any log record
1766          * (MOUNT record) of the file system, and at file system
1767          * unmount, all meta data for the file system has been
1768          * flushed before log super block is updated for deactivation
1769          * of the file system.
1770          */
1771         lbmDirectWrite(log, bpsuper, lbmWRITE | lbmRELEASE | lbmSYNC);
1772         rc = lbmIOWait(bpsuper, lbmFREE);
1773
1774         return rc;
1775 }
1776
1777 /*
1778  *              log buffer manager (lbm)
1779  *              ------------------------
1780  *
1781  * special purpose buffer manager supporting log i/o requirements.
1782  *
1783  * per log write queue:
1784  * log pageout occurs in serial order by fifo write queue and
1785  * restricting to a single i/o in pregress at any one time.
1786  * a circular singly-linked list
1787  * (log->wrqueue points to the tail, and buffers are linked via
1788  * bp->wrqueue field), and
1789  * maintains log page in pageout ot waiting for pageout in serial pageout.
1790  */
1791
1792 /*
1793  *      lbmLogInit()
1794  *
1795  * initialize per log I/O setup at lmLogInit()
1796  */
1797 static int lbmLogInit(struct jfs_log * log)
1798 {                               /* log inode */
1799         int i;
1800         struct lbuf *lbuf;
1801
1802         jfs_info("lbmLogInit: log:0x%p", log);
1803
1804         /* initialize current buffer cursor */
1805         log->bp = NULL;
1806
1807         /* initialize log device write queue */
1808         log->wqueue = NULL;
1809
1810         /*
1811          * Each log has its own buffer pages allocated to it.  These are
1812          * not managed by the page cache.  This ensures that a transaction
1813          * writing to the log does not block trying to allocate a page from
1814          * the page cache (for the log).  This would be bad, since page
1815          * allocation waits on the kswapd thread that may be committing inodes
1816          * which would cause log activity.  Was that clear?  I'm trying to
1817          * avoid deadlock here.
1818          */
1819         init_waitqueue_head(&log->free_wait);
1820
1821         log->lbuf_free = NULL;
1822
1823         for (i = 0; i < LOGPAGES;) {
1824                 char *buffer;
1825                 uint offset;
1826                 struct page *page;
1827
1828                 buffer = (char *) get_zeroed_page(GFP_KERNEL);
1829                 if (buffer == NULL)
1830                         goto error;
1831                 page = virt_to_page(buffer);
1832                 for (offset = 0; offset < PAGE_SIZE; offset += LOGPSIZE) {
1833                         lbuf = kmalloc(sizeof(struct lbuf), GFP_KERNEL);
1834                         if (lbuf == NULL) {
1835                                 if (offset == 0)
1836                                         free_page((unsigned long) buffer);
1837                                 goto error;
1838                         }
1839                         if (offset) /* we already have one reference */
1840                                 get_page(page);
1841                         lbuf->l_offset = offset;
1842                         lbuf->l_ldata = buffer + offset;
1843                         lbuf->l_page = page;
1844                         lbuf->l_log = log;
1845                         init_waitqueue_head(&lbuf->l_ioevent);
1846
1847                         lbuf->l_freelist = log->lbuf_free;
1848                         log->lbuf_free = lbuf;
1849                         i++;
1850                 }
1851         }
1852
1853         return (0);
1854
1855       error:
1856         lbmLogShutdown(log);
1857         return -ENOMEM;
1858 }
1859
1860
1861 /*
1862  *      lbmLogShutdown()
1863  *
1864  * finalize per log I/O setup at lmLogShutdown()
1865  */
1866 static void lbmLogShutdown(struct jfs_log * log)
1867 {
1868         struct lbuf *lbuf;
1869
1870         jfs_info("lbmLogShutdown: log:0x%p", log);
1871
1872         lbuf = log->lbuf_free;
1873         while (lbuf) {
1874                 struct lbuf *next = lbuf->l_freelist;
1875                 __free_page(lbuf->l_page);
1876                 kfree(lbuf);
1877                 lbuf = next;
1878         }
1879 }
1880
1881
1882 /*
1883  *      lbmAllocate()
1884  *
1885  * allocate an empty log buffer
1886  */
1887 static struct lbuf *lbmAllocate(struct jfs_log * log, int pn)
1888 {
1889         struct lbuf *bp;
1890         unsigned long flags;
1891
1892         /*
1893          * recycle from log buffer freelist if any
1894          */
1895         LCACHE_LOCK(flags);
1896         LCACHE_SLEEP_COND(log->free_wait, (bp = log->lbuf_free), flags);
1897         log->lbuf_free = bp->l_freelist;
1898         LCACHE_UNLOCK(flags);
1899
1900         bp->l_flag = 0;
1901
1902         bp->l_wqnext = NULL;
1903         bp->l_freelist = NULL;
1904
1905         bp->l_pn = pn;
1906         bp->l_blkno = log->base + (pn << (L2LOGPSIZE - log->l2bsize));
1907         bp->l_ceor = 0;
1908
1909         return bp;
1910 }
1911
1912
1913 /*
1914  *      lbmFree()
1915  *
1916  * release a log buffer to freelist
1917  */
1918 static void lbmFree(struct lbuf * bp)
1919 {
1920         unsigned long flags;
1921
1922         LCACHE_LOCK(flags);
1923
1924         lbmfree(bp);
1925
1926         LCACHE_UNLOCK(flags);
1927 }
1928
1929 static void lbmfree(struct lbuf * bp)
1930 {
1931         struct jfs_log *log = bp->l_log;
1932
1933         assert(bp->l_wqnext == NULL);
1934
1935         /*
1936          * return the buffer to head of freelist
1937          */
1938         bp->l_freelist = log->lbuf_free;
1939         log->lbuf_free = bp;
1940
1941         wake_up(&log->free_wait);
1942         return;
1943 }
1944
1945
1946 /*
1947  * NAME:        lbmRedrive
1948  *
1949  * FUNCTION:    add a log buffer to the the log redrive list
1950  *
1951  * PARAMETER:
1952  *     bp       - log buffer
1953  *
1954  * NOTES:
1955  *      Takes log_redrive_lock.
1956  */
1957 static inline void lbmRedrive(struct lbuf *bp)
1958 {
1959         unsigned long flags;
1960
1961         spin_lock_irqsave(&log_redrive_lock, flags);
1962         bp->l_redrive_next = log_redrive_list;
1963         log_redrive_list = bp;
1964         spin_unlock_irqrestore(&log_redrive_lock, flags);
1965
1966         wake_up(&jfs_IO_thread_wait);
1967 }
1968
1969
1970 /*
1971  *      lbmRead()
1972  */
1973 static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp)
1974 {
1975         struct bio *bio;
1976         struct lbuf *bp;
1977
1978         /*
1979          * allocate a log buffer
1980          */
1981         *bpp = bp = lbmAllocate(log, pn);
1982         jfs_info("lbmRead: bp:0x%p pn:0x%x", bp, pn);
1983
1984         bp->l_flag |= lbmREAD;
1985
1986         bio = bio_alloc(GFP_NOFS, 1);
1987
1988         bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
1989         bio->bi_bdev = log->bdev;
1990         bio->bi_io_vec[0].bv_page = bp->l_page;
1991         bio->bi_io_vec[0].bv_len = LOGPSIZE;
1992         bio->bi_io_vec[0].bv_offset = bp->l_offset;
1993
1994         bio->bi_vcnt = 1;
1995         bio->bi_idx = 0;
1996         bio->bi_size = LOGPSIZE;
1997
1998         bio->bi_end_io = lbmIODone;
1999         bio->bi_private = bp;
2000         submit_bio(READ_SYNC, bio);
2001
2002         wait_event(bp->l_ioevent, (bp->l_flag != lbmREAD));
2003
2004         return 0;
2005 }
2006
2007
2008 /*
2009  *      lbmWrite()
2010  *
2011  * buffer at head of pageout queue stays after completion of
2012  * partial-page pageout and redriven by explicit initiation of
2013  * pageout by caller until full-page pageout is completed and
2014  * released.
2015  *
2016  * device driver i/o done redrives pageout of new buffer at
2017  * head of pageout queue when current buffer at head of pageout
2018  * queue is released at the completion of its full-page pageout.
2019  *
2020  * LOGGC_LOCK() serializes lbmWrite() by lmNextPage() and lmGroupCommit().
2021  * LCACHE_LOCK() serializes xflag between lbmWrite() and lbmIODone()
2022  */
2023 static void lbmWrite(struct jfs_log * log, struct lbuf * bp, int flag,
2024                      int cant_block)
2025 {
2026         struct lbuf *tail;
2027         unsigned long flags;
2028
2029         jfs_info("lbmWrite: bp:0x%p flag:0x%x pn:0x%x", bp, flag, bp->l_pn);
2030
2031         /* map the logical block address to physical block address */
2032         bp->l_blkno =
2033             log->base + (bp->l_pn << (L2LOGPSIZE - log->l2bsize));
2034
2035         LCACHE_LOCK(flags);             /* disable+lock */
2036
2037         /*
2038          * initialize buffer for device driver
2039          */
2040         bp->l_flag = flag;
2041
2042         /*
2043          *      insert bp at tail of write queue associated with log
2044          *
2045          * (request is either for bp already/currently at head of queue
2046          * or new bp to be inserted at tail)
2047          */
2048         tail = log->wqueue;
2049
2050         /* is buffer not already on write queue ? */
2051         if (bp->l_wqnext == NULL) {
2052                 /* insert at tail of wqueue */
2053                 if (tail == NULL) {
2054                         log->wqueue = bp;
2055                         bp->l_wqnext = bp;
2056                 } else {
2057                         log->wqueue = bp;
2058                         bp->l_wqnext = tail->l_wqnext;
2059                         tail->l_wqnext = bp;
2060                 }
2061
2062                 tail = bp;
2063         }
2064
2065         /* is buffer at head of wqueue and for write ? */
2066         if ((bp != tail->l_wqnext) || !(flag & lbmWRITE)) {
2067                 LCACHE_UNLOCK(flags);   /* unlock+enable */
2068                 return;
2069         }
2070
2071         LCACHE_UNLOCK(flags);   /* unlock+enable */
2072
2073         if (cant_block)
2074                 lbmRedrive(bp);
2075         else if (flag & lbmSYNC)
2076                 lbmStartIO(bp);
2077         else {
2078                 LOGGC_UNLOCK(log);
2079                 lbmStartIO(bp);
2080                 LOGGC_LOCK(log);
2081         }
2082 }
2083
2084
2085 /*
2086  *      lbmDirectWrite()
2087  *
2088  * initiate pageout bypassing write queue for sidestream
2089  * (e.g., log superblock) write;
2090  */
2091 static void lbmDirectWrite(struct jfs_log * log, struct lbuf * bp, int flag)
2092 {
2093         jfs_info("lbmDirectWrite: bp:0x%p flag:0x%x pn:0x%x",
2094                  bp, flag, bp->l_pn);
2095
2096         /*
2097          * initialize buffer for device driver
2098          */
2099         bp->l_flag = flag | lbmDIRECT;
2100
2101         /* map the logical block address to physical block address */
2102         bp->l_blkno =
2103             log->base + (bp->l_pn << (L2LOGPSIZE - log->l2bsize));
2104
2105         /*
2106          *      initiate pageout of the page
2107          */
2108         lbmStartIO(bp);
2109 }
2110
2111
2112 /*
2113  * NAME:        lbmStartIO()
2114  *
2115  * FUNCTION:    Interface to DD strategy routine
2116  *
2117  * RETURN:      none
2118  *
2119  * serialization: LCACHE_LOCK() is NOT held during log i/o;
2120  */
2121 static void lbmStartIO(struct lbuf * bp)
2122 {
2123         struct bio *bio;
2124         struct jfs_log *log = bp->l_log;
2125
2126         jfs_info("lbmStartIO\n");
2127
2128         bio = bio_alloc(GFP_NOFS, 1);
2129         bio->bi_sector = bp->l_blkno << (log->l2bsize - 9);
2130         bio->bi_bdev = log->bdev;
2131         bio->bi_io_vec[0].bv_page = bp->l_page;
2132         bio->bi_io_vec[0].bv_len = LOGPSIZE;
2133         bio->bi_io_vec[0].bv_offset = bp->l_offset;
2134
2135         bio->bi_vcnt = 1;
2136         bio->bi_idx = 0;
2137         bio->bi_size = LOGPSIZE;
2138
2139         bio->bi_end_io = lbmIODone;
2140         bio->bi_private = bp;
2141
2142         /* check if journaling to disk has been disabled */
2143         if (log->no_integrity) {
2144                 bio->bi_size = 0;
2145                 lbmIODone(bio, 0, 0);
2146         } else {
2147                 submit_bio(WRITE_SYNC, bio);
2148                 INCREMENT(lmStat.submitted);
2149         }
2150 }
2151
2152
2153 /*
2154  *      lbmIOWait()
2155  */
2156 static int lbmIOWait(struct lbuf * bp, int flag)
2157 {
2158         unsigned long flags;
2159         int rc = 0;
2160
2161         jfs_info("lbmIOWait1: bp:0x%p flag:0x%x:0x%x", bp, bp->l_flag, flag);
2162
2163         LCACHE_LOCK(flags);             /* disable+lock */
2164
2165         LCACHE_SLEEP_COND(bp->l_ioevent, (bp->l_flag & lbmDONE), flags);
2166
2167         rc = (bp->l_flag & lbmERROR) ? -EIO : 0;
2168
2169         if (flag & lbmFREE)
2170                 lbmfree(bp);
2171
2172         LCACHE_UNLOCK(flags);   /* unlock+enable */
2173
2174         jfs_info("lbmIOWait2: bp:0x%p flag:0x%x:0x%x", bp, bp->l_flag, flag);
2175         return rc;
2176 }
2177
2178 /*
2179  *      lbmIODone()
2180  *
2181  * executed at INTIODONE level
2182  */
2183 static int lbmIODone(struct bio *bio, unsigned int bytes_done, int error)
2184 {
2185         struct lbuf *bp = bio->bi_private;
2186         struct lbuf *nextbp, *tail;
2187         struct jfs_log *log;
2188         unsigned long flags;
2189
2190         if (bio->bi_size)
2191                 return 1;
2192
2193         /*
2194          * get back jfs buffer bound to the i/o buffer
2195          */
2196         jfs_info("lbmIODone: bp:0x%p flag:0x%x", bp, bp->l_flag);
2197
2198         LCACHE_LOCK(flags);             /* disable+lock */
2199
2200         bp->l_flag |= lbmDONE;
2201
2202         if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
2203                 bp->l_flag |= lbmERROR;
2204
2205                 jfs_err("lbmIODone: I/O error in JFS log");
2206         }
2207
2208         bio_put(bio);
2209
2210         /*
2211          *      pagein completion
2212          */
2213         if (bp->l_flag & lbmREAD) {
2214                 bp->l_flag &= ~lbmREAD;
2215
2216                 LCACHE_UNLOCK(flags);   /* unlock+enable */
2217
2218                 /* wakeup I/O initiator */
2219                 LCACHE_WAKEUP(&bp->l_ioevent);
2220
2221                 return 0;
2222         }
2223
2224         /*
2225          *      pageout completion
2226          *
2227          * the bp at the head of write queue has completed pageout.
2228          *
2229          * if single-commit/full-page pageout, remove the current buffer
2230          * from head of pageout queue, and redrive pageout with
2231          * the new buffer at head of pageout queue;
2232          * otherwise, the partial-page pageout buffer stays at
2233          * the head of pageout queue to be redriven for pageout
2234          * by lmGroupCommit() until full-page pageout is completed.
2235          */
2236         bp->l_flag &= ~lbmWRITE;
2237         INCREMENT(lmStat.pagedone);
2238
2239         /* update committed lsn */
2240         log = bp->l_log;
2241         log->clsn = (bp->l_pn << L2LOGPSIZE) + bp->l_ceor;
2242
2243         if (bp->l_flag & lbmDIRECT) {
2244                 LCACHE_WAKEUP(&bp->l_ioevent);
2245                 LCACHE_UNLOCK(flags);
2246                 return 0;
2247         }
2248
2249         tail = log->wqueue;
2250
2251         /* single element queue */
2252         if (bp == tail) {
2253                 /* remove head buffer of full-page pageout
2254                  * from log device write queue
2255                  */
2256                 if (bp->l_flag & lbmRELEASE) {
2257                         log->wqueue = NULL;
2258                         bp->l_wqnext = NULL;
2259                 }
2260         }
2261         /* multi element queue */
2262         else {
2263                 /* remove head buffer of full-page pageout
2264                  * from log device write queue
2265                  */
2266                 if (bp->l_flag & lbmRELEASE) {
2267                         nextbp = tail->l_wqnext = bp->l_wqnext;
2268                         bp->l_wqnext = NULL;
2269
2270                         /*
2271                          * redrive pageout of next page at head of write queue:
2272                          * redrive next page without any bound tblk
2273                          * (i.e., page w/o any COMMIT records), or
2274                          * first page of new group commit which has been
2275                          * queued after current page (subsequent pageout
2276                          * is performed synchronously, except page without
2277                          * any COMMITs) by lmGroupCommit() as indicated
2278                          * by lbmWRITE flag;
2279                          */
2280                         if (nextbp->l_flag & lbmWRITE) {
2281                                 /*
2282                                  * We can't do the I/O at interrupt time.
2283                                  * The jfsIO thread can do it
2284                                  */
2285                                 lbmRedrive(nextbp);
2286                         }
2287                 }
2288         }
2289
2290         /*
2291          *      synchronous pageout:
2292          *
2293          * buffer has not necessarily been removed from write queue
2294          * (e.g., synchronous write of partial-page with COMMIT):
2295          * leave buffer for i/o initiator to dispose
2296          */
2297         if (bp->l_flag & lbmSYNC) {
2298                 LCACHE_UNLOCK(flags);   /* unlock+enable */
2299
2300                 /* wakeup I/O initiator */
2301                 LCACHE_WAKEUP(&bp->l_ioevent);
2302         }
2303
2304         /*
2305          *      Group Commit pageout:
2306          */
2307         else if (bp->l_flag & lbmGC) {
2308                 LCACHE_UNLOCK(flags);
2309                 lmPostGC(bp);
2310         }
2311
2312         /*
2313          *      asynchronous pageout:
2314          *
2315          * buffer must have been removed from write queue:
2316          * insert buffer at head of freelist where it can be recycled
2317          */
2318         else {
2319                 assert(bp->l_flag & lbmRELEASE);
2320                 assert(bp->l_flag & lbmFREE);
2321                 lbmfree(bp);
2322
2323                 LCACHE_UNLOCK(flags);   /* unlock+enable */
2324         }
2325
2326         return 0;
2327 }
2328
2329 int jfsIOWait(void *arg)
2330 {
2331         struct lbuf *bp;
2332
2333         daemonize("jfsIO");
2334
2335         complete(&jfsIOwait);
2336
2337         do {
2338                 DECLARE_WAITQUEUE(wq, current);
2339
2340                 spin_lock_irq(&log_redrive_lock);
2341                 while ((bp = log_redrive_list) != 0) {
2342                         log_redrive_list = bp->l_redrive_next;
2343                         bp->l_redrive_next = NULL;
2344                         spin_unlock_irq(&log_redrive_lock);
2345                         lbmStartIO(bp);
2346                         spin_lock_irq(&log_redrive_lock);
2347                 }
2348                 if (current->flags & PF_FREEZE) {
2349                         spin_unlock_irq(&log_redrive_lock);
2350                         refrigerator(PF_FREEZE);
2351                 } else {
2352                         add_wait_queue(&jfs_IO_thread_wait, &wq);
2353                         set_current_state(TASK_INTERRUPTIBLE);
2354                         spin_unlock_irq(&log_redrive_lock);
2355                         schedule();
2356                         current->state = TASK_RUNNING;
2357                         remove_wait_queue(&jfs_IO_thread_wait, &wq);
2358                 }
2359         } while (!jfs_stop_threads);
2360
2361         jfs_info("jfsIOWait being killed!");
2362         complete_and_exit(&jfsIOwait, 0);
2363 }
2364
2365 /*
2366  * NAME:        lmLogFormat()/jfs_logform()
2367  *
2368  * FUNCTION:    format file system log
2369  *
2370  * PARAMETERS:
2371  *      log     - volume log
2372  *      logAddress - start address of log space in FS block
2373  *      logSize - length of log space in FS block;
2374  *
2375  * RETURN:      0       - success
2376  *              -EIO    - i/o error
2377  *
2378  * XXX: We're synchronously writing one page at a time.  This needs to
2379  *      be improved by writing multiple pages at once.
2380  */
2381 int lmLogFormat(struct jfs_log *log, s64 logAddress, int logSize)
2382 {
2383         int rc = -EIO;
2384         struct jfs_sb_info *sbi;
2385         struct logsuper *logsuper;
2386         struct logpage *lp;
2387         int lspn;               /* log sequence page number */
2388         struct lrd *lrd_ptr;
2389         int npages = 0;
2390         struct lbuf *bp;
2391
2392         jfs_info("lmLogFormat: logAddress:%Ld logSize:%d",
2393                  (long long)logAddress, logSize);
2394
2395         sbi = list_entry(log->sb_list.next, struct jfs_sb_info, log_list);
2396
2397         /* allocate a log buffer */
2398         bp = lbmAllocate(log, 1);
2399
2400         npages = logSize >> sbi->l2nbperpage;
2401
2402         /*
2403          *      log space:
2404          *
2405          * page 0 - reserved;
2406          * page 1 - log superblock;
2407          * page 2 - log data page: A SYNC log record is written
2408          *          into this page at logform time;
2409          * pages 3-N - log data page: set to empty log data pages;
2410          */
2411         /*
2412          *      init log superblock: log page 1
2413          */
2414         logsuper = (struct logsuper *) bp->l_ldata;
2415
2416         logsuper->magic = cpu_to_le32(LOGMAGIC);
2417         logsuper->version = cpu_to_le32(LOGVERSION);
2418         logsuper->state = cpu_to_le32(LOGREDONE);
2419         logsuper->flag = cpu_to_le32(sbi->mntflag);     /* ? */
2420         logsuper->size = cpu_to_le32(npages);
2421         logsuper->bsize = cpu_to_le32(sbi->bsize);
2422         logsuper->l2bsize = cpu_to_le32(sbi->l2bsize);
2423         logsuper->end = cpu_to_le32(2 * LOGPSIZE + LOGPHDRSIZE + LOGRDSIZE);
2424
2425         bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
2426         bp->l_blkno = logAddress + sbi->nbperpage;
2427         lbmStartIO(bp);
2428         if ((rc = lbmIOWait(bp, 0)))
2429                 goto exit;
2430
2431         /*
2432          *      init pages 2 to npages-1 as log data pages:
2433          *
2434          * log page sequence number (lpsn) initialization:
2435          *
2436          * pn:   0     1     2     3                 n-1
2437          *       +-----+-----+=====+=====+===.....===+=====+
2438          * lspn:             N-1   0     1           N-2
2439          *                   <--- N page circular file ---->
2440          *
2441          * the N (= npages-2) data pages of the log is maintained as
2442          * a circular file for the log records;
2443          * lpsn grows by 1 monotonically as each log page is written
2444          * to the circular file of the log;
2445          * and setLogpage() will not reset the page number even if
2446          * the eor is equal to LOGPHDRSIZE. In order for binary search
2447          * still work in find log end process, we have to simulate the
2448          * log wrap situation at the log format time.
2449          * The 1st log page written will have the highest lpsn. Then
2450          * the succeeding log pages will have ascending order of
2451          * the lspn starting from 0, ... (N-2)
2452          */
2453         lp = (struct logpage *) bp->l_ldata;
2454         /*
2455          * initialize 1st log page to be written: lpsn = N - 1,
2456          * write a SYNCPT log record is written to this page
2457          */
2458         lp->h.page = lp->t.page = cpu_to_le32(npages - 3);
2459         lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE + LOGRDSIZE);
2460
2461         lrd_ptr = (struct lrd *) &lp->data;
2462         lrd_ptr->logtid = 0;
2463         lrd_ptr->backchain = 0;
2464         lrd_ptr->type = cpu_to_le16(LOG_SYNCPT);
2465         lrd_ptr->length = 0;
2466         lrd_ptr->log.syncpt.sync = 0;
2467
2468         bp->l_blkno += sbi->nbperpage;
2469         bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
2470         lbmStartIO(bp);
2471         if ((rc = lbmIOWait(bp, 0)))
2472                 goto exit;
2473
2474         /*
2475          *      initialize succeeding log pages: lpsn = 0, 1, ..., (N-2)
2476          */
2477         for (lspn = 0; lspn < npages - 3; lspn++) {
2478                 lp->h.page = lp->t.page = cpu_to_le32(lspn);
2479                 lp->h.eor = lp->t.eor = cpu_to_le16(LOGPHDRSIZE);
2480
2481                 bp->l_blkno += sbi->nbperpage;
2482                 bp->l_flag = lbmWRITE | lbmSYNC | lbmDIRECT;
2483                 lbmStartIO(bp);
2484                 if ((rc = lbmIOWait(bp, 0)))
2485                         goto exit;
2486         }
2487
2488         rc = 0;
2489 exit:
2490         /*
2491          *      finalize log
2492          */
2493         /* release the buffer */
2494         lbmFree(bp);
2495
2496         return rc;
2497 }
2498
2499 #ifdef CONFIG_JFS_STATISTICS
2500 int jfs_lmstats_read(char *buffer, char **start, off_t offset, int length,
2501                       int *eof, void *data)
2502 {
2503         int len = 0;
2504         off_t begin;
2505
2506         len += sprintf(buffer,
2507                        "JFS Logmgr stats\n"
2508                        "================\n"
2509                        "commits = %d\n"
2510                        "writes submitted = %d\n"
2511                        "writes completed = %d\n"
2512                        "full pages submitted = %d\n"
2513                        "partial pages submitted = %d\n",
2514                        lmStat.commit,
2515                        lmStat.submitted,
2516                        lmStat.pagedone,
2517                        lmStat.full_page,
2518                        lmStat.partial_page);
2519
2520         begin = offset;
2521         *start = buffer + begin;
2522         len -= begin;
2523
2524         if (len > length)
2525                 len = length;
2526         else
2527                 *eof = 1;
2528
2529         if (len < 0)
2530                 len = 0;
2531
2532         return len;
2533 }
2534 #endif /* CONFIG_JFS_STATISTICS */