| 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 |
* 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 file *bdev_file; /* 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 */ |