[PATCH] JFS: Support page sizes greater than 4K
[linux-2.6.git] / fs / jfs / jfs_logmgr.h
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 #ifndef _H_JFS_LOGMGR
20 #define _H_JFS_LOGMGR
21
22 #include "jfs_filsys.h"
23 #include "jfs_lock.h"
24
25 /*
26  *      log manager configuration parameters
27  */
28
29 /* log page size */
30 #define LOGPSIZE        4096
31 #define L2LOGPSIZE      12
32
33 #define LOGPAGES        16      /* Log pages per mounted file system */
34
35 /*
36  *      log logical volume
37  *
38  * a log is used to make the commit operation on journalled 
39  * files within the same logical volume group atomic.
40  * a log is implemented with a logical volume.
41  * there is one log per logical volume group. 
42  *
43  * block 0 of the log logical volume is not used (ipl etc).
44  * block 1 contains a log "superblock" and is used by logFormat(),
45  * lmLogInit(), lmLogShutdown(), and logRedo() to record status 
46  * of the log but is not otherwise used during normal processing. 
47  * blocks 2 - (N-1) are used to contain log records.
48  *
49  * when a volume group is varied-on-line, logRedo() must have 
50  * been executed before the file systems (logical volumes) in 
51  * the volume group can be mounted.
52  */
53 /*
54  *      log superblock (block 1 of logical volume)
55  */
56 #define LOGSUPER_B      1
57 #define LOGSTART_B      2
58
59 #define LOGMAGIC        0x87654321
60 #define LOGVERSION      1
61
62 #define MAX_ACTIVE      128     /* Max active file systems sharing log */
63
64 struct logsuper {
65         __le32 magic;           /* 4: log lv identifier */
66         __le32 version;         /* 4: version number */
67         __le32 serial;          /* 4: log open/mount counter */
68         __le32 size;            /* 4: size in number of LOGPSIZE blocks */
69         __le32 bsize;           /* 4: logical block size in byte */
70         __le32 l2bsize;         /* 4: log2 of bsize */
71
72         __le32 flag;            /* 4: option */
73         __le32 state;           /* 4: state - see below */
74
75         __le32 end;             /* 4: addr of last log record set by logredo */
76         char uuid[16];          /* 16: 128-bit journal uuid */
77         char label[16];         /* 16: journal label */
78         struct {
79                 char uuid[16];
80         } active[MAX_ACTIVE];   /* 2048: active file systems list */
81 };
82
83 #define NULL_UUID "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
84
85 /* log flag: commit option (see jfs_filsys.h) */
86
87 /* log state */
88 #define LOGMOUNT        0       /* log mounted by lmLogInit() */
89 #define LOGREDONE       1       /* log shutdown by lmLogShutdown().
90                                  * log redo completed by logredo().
91                                  */
92 #define LOGWRAP         2       /* log wrapped */
93 #define LOGREADERR      3       /* log read error detected in logredo() */
94
95
96 /*
97  *      log logical page
98  *
99  * (this comment should be rewritten !)
100  * the header and trailer structures (h,t) will normally have 
101  * the same page and eor value.
102  * An exception to this occurs when a complete page write is not 
103  * accomplished on a power failure. Since the hardware may "split write"
104  * sectors in the page, any out of order sequence may occur during powerfail 
105  * and needs to be recognized during log replay.  The xor value is
106  * an "exclusive or" of all log words in the page up to eor.  This
107  * 32 bit eor is stored with the top 16 bits in the header and the
108  * bottom 16 bits in the trailer.  logredo can easily recognize pages
109  * that were not completed by reconstructing this eor and checking 
110  * the log page.
111  *
112  * Previous versions of the operating system did not allow split 
113  * writes and detected partially written records in logredo by 
114  * ordering the updates to the header, trailer, and the move of data 
115  * into the logdata area.  The order: (1) data is moved (2) header 
116  * is updated (3) trailer is updated.  In logredo, when the header 
117  * differed from the trailer, the header and trailer were reconciled 
118  * as follows: if h.page != t.page they were set to the smaller of 
119  * the two and h.eor and t.eor set to 8 (i.e. empty page). if (only) 
120  * h.eor != t.eor they were set to the smaller of their two values.
121  */
122 struct logpage {
123         struct {                /* header */
124                 __le32 page;    /* 4: log sequence page number */
125                 __le16 rsrvd;   /* 2: */
126                 __le16 eor;     /* 2: end-of-log offset of lasrt record write */
127         } h;
128
129         __le32 data[LOGPSIZE / 4 - 4];  /* log record area */
130
131         struct {                /* trailer */
132                 __le32 page;    /* 4: normally the same as h.page */
133                 __le16 rsrvd;   /* 2: */
134                 __le16 eor;     /* 2: normally the same as h.eor */
135         } t;
136 };
137
138 #define LOGPHDRSIZE     8       /* log page header size */
139 #define LOGPTLRSIZE     8       /* log page trailer size */
140
141
142 /*
143  *      log record
144  *
145  * (this comment should be rewritten !)
146  * jfs uses only "after" log records (only a single writer is allowed
147  * in a  page, pages are written to temporary paging space if
148  * if they must be written to disk before commit, and i/o is
149  * scheduled for modified pages to their home location after
150  * the log records containing the after values and the commit 
151  * record is written to the log on disk, undo discards the copy
152  * in main-memory.)
153  *
154  * a log record consists of a data area of variable length followed by 
155  * a descriptor of fixed size LOGRDSIZE bytes.
156  * the  data area is rounded up to an integral number of 4-bytes and 
157  * must be no longer than LOGPSIZE.
158  * the descriptor is of size of multiple of 4-bytes and aligned on a 
159  * 4-byte boundary. 
160  * records are packed one after the other in the data area of log pages.
161  * (sometimes a DUMMY record is inserted so that at least one record ends 
162  * on every page or the longest record is placed on at most two pages).
163  * the field eor in page header/trailer points to the byte following 
164  * the last record on a page.
165  */
166
167 /* log record types */
168 #define LOG_COMMIT              0x8000
169 #define LOG_SYNCPT              0x4000
170 #define LOG_MOUNT               0x2000
171 #define LOG_REDOPAGE            0x0800
172 #define LOG_NOREDOPAGE          0x0080
173 #define LOG_NOREDOINOEXT        0x0040
174 #define LOG_UPDATEMAP           0x0008
175 #define LOG_NOREDOFILE          0x0001
176
177 /* REDOPAGE/NOREDOPAGE log record data type */
178 #define LOG_INODE               0x0001
179 #define LOG_XTREE               0x0002
180 #define LOG_DTREE               0x0004
181 #define LOG_BTROOT              0x0010
182 #define LOG_EA                  0x0020
183 #define LOG_ACL                 0x0040
184 #define LOG_DATA                0x0080
185 #define LOG_NEW                 0x0100
186 #define LOG_EXTEND              0x0200
187 #define LOG_RELOCATE            0x0400
188 #define LOG_DIR_XTREE           0x0800  /* Xtree is in directory inode */
189
190 /* UPDATEMAP log record descriptor type */
191 #define LOG_ALLOCXADLIST        0x0080
192 #define LOG_ALLOCPXDLIST        0x0040
193 #define LOG_ALLOCXAD            0x0020
194 #define LOG_ALLOCPXD            0x0010
195 #define LOG_FREEXADLIST         0x0008
196 #define LOG_FREEPXDLIST         0x0004
197 #define LOG_FREEXAD             0x0002
198 #define LOG_FREEPXD             0x0001
199
200
201 struct lrd {
202         /*
203          * type independent area
204          */
205         __le32 logtid;          /* 4: log transaction identifier */
206         __le32 backchain;       /* 4: ptr to prev record of same transaction */
207         __le16 type;            /* 2: record type */
208         __le16 length;          /* 2: length of data in record (in byte) */
209         __le32 aggregate;       /* 4: file system lv/aggregate */
210         /* (16) */
211
212         /*
213          * type dependent area (20)
214          */
215         union {
216
217                 /*
218                  *      COMMIT: commit
219                  *
220                  * transaction commit: no type-dependent information;
221                  */
222
223                 /*
224                  *      REDOPAGE: after-image
225                  *
226                  * apply after-image;
227                  *
228                  * N.B. REDOPAGE, NOREDOPAGE, and UPDATEMAP must be same format;
229                  */
230                 struct {
231                         __le32 fileset; /* 4: fileset number */
232                         __le32 inode;   /* 4: inode number */
233                         __le16 type;    /* 2: REDOPAGE record type */
234                         __le16 l2linesize;      /* 2: log2 of line size */
235                         pxd_t pxd;      /* 8: on-disk page pxd */
236                 } redopage;     /* (20) */
237
238                 /*
239                  *      NOREDOPAGE: the page is freed
240                  *
241                  * do not apply after-image records which precede this record
242                  * in the log with the same page block number to this page.
243                  *
244                  * N.B. REDOPAGE, NOREDOPAGE, and UPDATEMAP must be same format;
245                  */
246                 struct {
247                         __le32 fileset; /* 4: fileset number */
248                         __le32 inode;   /* 4: inode number */
249                         __le16 type;    /* 2: NOREDOPAGE record type */
250                         __le16 rsrvd;   /* 2: reserved */
251                         pxd_t pxd;      /* 8: on-disk page pxd */
252                 } noredopage;   /* (20) */
253
254                 /*
255                  *      UPDATEMAP: update block allocation map
256                  *
257                  * either in-line PXD,
258                  * or     out-of-line  XADLIST;
259                  *
260                  * N.B. REDOPAGE, NOREDOPAGE, and UPDATEMAP must be same format;
261                  */
262                 struct {
263                         __le32 fileset; /* 4: fileset number */
264                         __le32 inode;   /* 4: inode number */
265                         __le16 type;    /* 2: UPDATEMAP record type */
266                         __le16 nxd;     /* 2: number of extents */
267                         pxd_t pxd;      /* 8: pxd */
268                 } updatemap;    /* (20) */
269
270                 /*
271                  *      NOREDOINOEXT: the inode extent is freed
272                  *
273                  * do not apply after-image records which precede this 
274                  * record in the log with the any of the 4 page block 
275                  * numbers in this inode extent. 
276                  * 
277                  * NOTE: The fileset and pxd fields MUST remain in 
278                  *       the same fields in the REDOPAGE record format.
279                  *
280                  */
281                 struct {
282                         __le32 fileset; /* 4: fileset number */
283                         __le32 iagnum;  /* 4: IAG number     */
284                         __le32 inoext_idx;      /* 4: inode extent index */
285                         pxd_t pxd;      /* 8: on-disk page pxd */
286                 } noredoinoext; /* (20) */
287
288                 /*
289                  *      SYNCPT: log sync point
290                  *
291                  * replay log upto syncpt address specified;
292                  */
293                 struct {
294                         __le32 sync;    /* 4: syncpt address (0 = here) */
295                 } syncpt;
296
297                 /*
298                  *      MOUNT: file system mount
299                  *
300                  * file system mount: no type-dependent information;
301                  */
302
303                 /*
304                  *      ? FREEXTENT: free specified extent(s)
305                  *
306                  * free specified extent(s) from block allocation map
307                  * N.B.: nextents should be length of data/sizeof(xad_t)
308                  */
309                 struct {
310                         __le32 type;    /* 4: FREEXTENT record type */
311                         __le32 nextent; /* 4: number of extents */
312
313                         /* data: PXD or XAD list */
314                 } freextent;
315
316                 /*
317                  *      ? NOREDOFILE: this file is freed
318                  *
319                  * do not apply records which precede this record in the log
320                  * with the same inode number.
321                  *
322                  * NOREDILE must be the first to be written at commit
323                  * (last to be read in logredo()) - it prevents
324                  * replay of preceding updates of all preceding generations
325                  * of the inumber esp. the on-disk inode itself, 
326                  * but does NOT prevent
327                  * replay of the 
328                  */
329                 struct {
330                         __le32 fileset; /* 4: fileset number */
331                         __le32 inode;   /* 4: inode number */
332                 } noredofile;
333
334                 /*
335                  *      ? NEWPAGE: 
336                  *
337                  * metadata type dependent
338                  */
339                 struct {
340                         __le32 fileset; /* 4: fileset number */
341                         __le32 inode;   /* 4: inode number */
342                         __le32 type;    /* 4: NEWPAGE record type */
343                         pxd_t pxd;      /* 8: on-disk page pxd */
344                 } newpage;
345
346                 /*
347                  *      ? DUMMY: filler
348                  *
349                  * no type-dependent information
350                  */
351         } log;
352 };                                      /* (36) */
353
354 #define LOGRDSIZE       (sizeof(struct lrd))
355
356 /*
357  *      line vector descriptor
358  */
359 struct lvd {
360         __le16 offset;
361         __le16 length;
362 };
363
364
365 /*
366  *      log logical volume
367  */
368 struct jfs_log {
369
370         struct list_head sb_list;/*  This is used to sync metadata
371                                  *    before writing syncpt.
372                                  */
373         struct list_head journal_list; /* Global list */
374         struct block_device *bdev; /* 4: log lv pointer */
375         int serial;             /* 4: log mount serial number */
376
377         s64 base;               /* @8: log extent address (inline log ) */
378         int size;               /* 4: log size in log page (in page) */
379         int l2bsize;            /* 4: log2 of bsize */
380
381         long flag;              /* 4: flag */
382
383         struct lbuf *lbuf_free; /* 4: free lbufs */
384         wait_queue_head_t free_wait;    /* 4: */
385
386         /* log write */
387         int logtid;             /* 4: log tid */
388         int page;               /* 4: page number of eol page */
389         int eor;                /* 4: eor of last record in eol page */
390         struct lbuf *bp;        /* 4: current log page buffer */
391
392         struct semaphore loglock;       /* 4: log write serialization lock */
393
394         /* syncpt */
395         int nextsync;           /* 4: bytes to write before next syncpt */
396         int active;             /* 4: */
397         wait_queue_head_t syncwait;     /* 4: */
398
399         /* commit */
400         uint cflag;             /* 4: */
401         struct list_head cqueue; /* FIFO commit queue */
402         struct tblock *flush_tblk; /* tblk we're waiting on for flush */
403         int gcrtc;              /* 4: GC_READY transaction count */
404         struct tblock *gclrt;   /* 4: latest GC_READY transaction */
405         spinlock_t gclock;      /* 4: group commit lock */
406         int logsize;            /* 4: log data area size in byte */
407         int lsn;                /* 4: end-of-log */
408         int clsn;               /* 4: clsn */
409         int syncpt;             /* 4: addr of last syncpt record */
410         int sync;               /* 4: addr from last logsync() */
411         struct list_head synclist;      /* 8: logsynclist anchor */
412         spinlock_t synclock;    /* 4: synclist lock */
413         struct lbuf *wqueue;    /* 4: log pageout queue */
414         int count;              /* 4: count */
415         char uuid[16];          /* 16: 128-bit uuid of log device */
416
417         int no_integrity;       /* 3: flag to disable journaling to disk */
418 };
419
420 /*
421  * Log flag
422  */
423 #define log_INLINELOG   1
424 #define log_SYNCBARRIER 2
425 #define log_QUIESCE     3
426 #define log_FLUSH       4
427
428 /*
429  * group commit flag
430  */
431 /* jfs_log */
432 #define logGC_PAGEOUT   0x00000001
433
434 /* tblock/lbuf */
435 #define tblkGC_QUEUE            0x0001
436 #define tblkGC_READY            0x0002
437 #define tblkGC_COMMIT           0x0004
438 #define tblkGC_COMMITTED        0x0008
439 #define tblkGC_EOP              0x0010
440 #define tblkGC_FREE             0x0020
441 #define tblkGC_LEADER           0x0040
442 #define tblkGC_ERROR            0x0080
443 #define tblkGC_LAZY             0x0100  // D230860
444 #define tblkGC_UNLOCKED         0x0200  // D230860
445
446 /*
447  *              log cache buffer header
448  */
449 struct lbuf {
450         struct jfs_log *l_log;  /* 4: log associated with buffer */
451
452         /*
453          * data buffer base area
454          */
455         uint l_flag;            /* 4: pageout control flags */
456
457         struct lbuf *l_wqnext;  /* 4: write queue link */
458         struct lbuf *l_freelist;        /* 4: freelistlink */
459
460         int l_pn;               /* 4: log page number */
461         int l_eor;              /* 4: log record eor */
462         int l_ceor;             /* 4: committed log record eor */
463
464         s64 l_blkno;            /* 8: log page block number */
465         caddr_t l_ldata;        /* 4: data page */
466         struct page *l_page;    /* The page itself */
467         uint l_offset;          /* Offset of l_ldata within the page */ 
468
469         wait_queue_head_t l_ioevent;    /* 4: i/o done event */
470 };
471
472 /* Reuse l_freelist for redrive list */
473 #define l_redrive_next l_freelist
474
475 /*
476  *      logsynclist block
477  *
478  * common logsyncblk prefix for jbuf_t and tblock
479  */
480 struct logsyncblk {
481         u16 xflag;              /* flags */
482         u16 flag;               /* only meaninful in tblock */
483         lid_t lid;              /* lock id */
484         s32 lsn;                /* log sequence number */
485         struct list_head synclist;      /* log sync list link */
486 };
487
488 /*
489  *      logsynclist serialization (per log)
490  */
491
492 #define LOGSYNC_LOCK_INIT(log) spin_lock_init(&(log)->synclock)
493 #define LOGSYNC_LOCK(log, flags) spin_lock_irqsave(&(log)->synclock, flags)
494 #define LOGSYNC_UNLOCK(log, flags) \
495         spin_unlock_irqrestore(&(log)->synclock, flags)
496
497 /* compute the difference in bytes of lsn from sync point */
498 #define logdiff(diff, lsn, log)\
499 {\
500         diff = (lsn) - (log)->syncpt;\
501         if (diff < 0)\
502                 diff += (log)->logsize;\
503 }
504
505 extern int lmLogOpen(struct super_block *sb);
506 extern int lmLogClose(struct super_block *sb);
507 extern int lmLogShutdown(struct jfs_log * log);
508 extern int lmLogInit(struct jfs_log * log);
509 extern int lmLogFormat(struct jfs_log *log, s64 logAddress, int logSize);
510 extern void jfs_flush_journal(struct jfs_log * log, int wait);
511
512 #endif                          /* _H_JFS_LOGMGR */