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