1 /* jfs.h - an extractions from linux/include/linux/jfs/jfs* into one file */ 2 /* 3 * GRUB -- GRand Unified Bootloader 4 * Copyright (C) 2000 International Business Machines Corp. 5 * Copyright (C) 2001 Free Software Foundation, Inc. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15 * the GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 20 * MA 02110-1301, USA. 21 */ 22 23 #ifndef _JFS_H_ 24 #define _JFS_H_ 25 26 /* those are from jfs_filsys.h */ 27 28 /* 29 * file system option (superblock flag) 30 */ 31 /* platform option (conditional compilation) */ 32 #define JFS_AIX 0x80000000 /* AIX support */ 33 /* POSIX name/directory support */ 34 35 #define JFS_OS2 0x40000000 /* OS/2 support */ 36 /* case-insensitive name/directory support */ 37 38 #define JFS_LINUX 0x10000000 /* Linux support */ 39 /* case-sensitive name/directory support */ 40 41 /* directory option */ 42 #define JFS_UNICODE 0x00000001 /* unicode name */ 43 44 /* bba */ 45 #define JFS_SWAP_BYTES 0x00100000 /* running on big endian computer */ 46 47 48 /* 49 * buffer cache configuration 50 */ 51 /* page size */ 52 #ifdef PSIZE 53 #undef PSIZE 54 #endif 55 #define PSIZE 4096 /* page size (in byte) */ 56 57 /* 58 * fs fundamental size 59 * 60 * PSIZE >= file system block size >= PBSIZE >= DISIZE 61 */ 62 #define PBSIZE 512 /* physical block size (in byte) */ 63 #define DISIZE 512 /* on-disk inode size (in byte) */ 64 #define L2DISIZE 9 65 #define INOSPERIAG 4096 /* number of disk inodes per iag */ 66 #define L2INOSPERIAG 12 67 #define INOSPEREXT 32 /* number of disk inode per extent */ 68 #define L2INOSPEREXT 5 69 70 /* Minimum number of bytes supported for a JFS partition */ 71 #define MINJFS (0x1000000) 72 73 /* 74 * fixed byte offset address 75 */ 76 #define SUPER1_OFF 0x8000 /* primary superblock */ 77 78 #define AITBL_OFF (SUPER1_OFF + PSIZE + (PSIZE << 1)) 79 80 /* 81 * fixed reserved inode number 82 */ 83 /* aggregate inode */ 84 #define AGGREGATE_I 1 /* aggregate inode map inode */ 85 #define FILESYSTEM_I 16 /* 1st/only fileset inode in ait: 86 * fileset inode map inode 87 */ 88 89 /* per fileset inode */ 90 #define ROOT_I 2 /* fileset root inode */ 91 92 /* 93 * directory configuration 94 */ 95 #define JFS_NAME_MAX 255 96 #define JFS_PATH_MAX PSIZE 97 98 #if 0 99 typedef unsigned char u8; 100 typedef char s8; 101 typedef unsigned short u16; 102 typedef short s16; 103 typedef unsigned int u32; 104 typedef int s32; 105 typedef unsigned long long u64; 106 typedef long long s64; 107 #endif 108 109 typedef u16 UniChar; 110 111 /* these from jfs_btree.h */ 112 113 /* btpaget_t flag */ 114 #define BT_TYPE 0x07 /* B+-tree index */ 115 #define BT_ROOT 0x01 /* root page */ 116 #define BT_LEAF 0x02 /* leaf page */ 117 #define BT_INTERNAL 0x04 /* internal page */ 118 #define BT_RIGHTMOST 0x10 /* rightmost page */ 119 #define BT_LEFTMOST 0x20 /* leftmost page */ 120 121 /* those are from jfs_types.h */ 122 123 struct timestruc_t { 124 u32 tv_sec; 125 u32 tv_nsec; 126 }; 127 128 /* 129 * physical xd (pxd) 130 */ 131 typedef struct { 132 unsigned len:24; 133 unsigned addr1:8; 134 u32 addr2; 135 } pxd_t; 136 137 /* xd_t field extraction */ 138 #define lengthPXD(pxd) ((pxd)->len) 139 #define addressPXD(pxd) (((s64)((pxd)->addr1)) << 32 | ((pxd)->addr2)) 140 141 /* 142 * data extent descriptor (dxd) 143 */ 144 typedef struct { 145 unsigned flag:8; /* 1: flags */ 146 unsigned rsrvd:24; /* 3: */ 147 u32 size; /* 4: size in byte */ 148 unsigned len:24; /* 3: length in unit of fsblksize */ 149 unsigned addr1:8; /* 1: address in unit of fsblksize */ 150 u32 addr2; /* 4: address in unit of fsblksize */ 151 } dxd_t; /* - 16 - */ 152 153 /* 154 * DASD limit information - stored in directory inode 155 */ 156 typedef struct dasd { 157 u8 thresh; /* Alert Threshold (in percent) */ 158 u8 delta; /* Alert Threshold delta (in percent) */ 159 u8 rsrvd1; 160 u8 limit_hi; /* DASD limit (in logical blocks) */ 161 u32 limit_lo; /* DASD limit (in logical blocks) */ 162 u8 rsrvd2[3]; 163 u8 used_hi; /* DASD usage (in logical blocks) */ 164 u32 used_lo; /* DASD usage (in logical blocks) */ 165 } dasd_t; 166 167 168 /* from jfs_superblock.h */ 169 170 #define JFS_MAGIC 0x3153464A /* "JFS1" */ 171 172 struct jfs_superblock 173 { 174 u32 s_magic; /* 4: magic number */ 175 u32 s_version; /* 4: version number */ 176 177 s64 s_size; /* 8: aggregate size in hardware/LVM blocks; 178 * VFS: number of blocks 179 */ 180 s32 s_bsize; /* 4: aggregate block size in bytes; 181 * VFS: fragment size 182 */ 183 s16 s_l2bsize; /* 2: log2 of s_bsize */ 184 s16 s_l2bfactor; /* 2: log2(s_bsize/hardware block size) */ 185 s32 s_pbsize; /* 4: hardware/LVM block size in bytes */ 186 s16 s_l2pbsize; /* 2: log2 of s_pbsize */ 187 s16 pad; /* 2: padding necessary for alignment */ 188 189 u32 s_agsize; /* 4: allocation group size in aggr. blocks */ 190 191 u32 s_flag; /* 4: aggregate attributes: 192 * see jfs_filsys.h 193 */ 194 u32 s_state; /* 4: mount/unmount/recovery state: 195 * see jfs_filsys.h 196 */ 197 s32 s_compress; /* 4: > 0 if data compression */ 198 199 pxd_t s_ait2; /* 8: first extent of secondary 200 * aggregate inode table 201 */ 202 203 pxd_t s_aim2; /* 8: first extent of secondary 204 * aggregate inode map 205 */ 206 u32 s_logdev; /* 4: device address of log */ 207 s32 s_logserial; /* 4: log serial number at aggregate mount */ 208 pxd_t s_logpxd; /* 8: inline log extent */ 209 210 pxd_t s_fsckpxd; /* 8: inline fsck work space extent */ 211 212 struct timestruc_t s_time; /* 8: time last updated */ 213 214 s32 s_fsckloglen; /* 4: Number of filesystem blocks reserved for 215 * the fsck service log. 216 * N.B. These blocks are divided among the 217 * versions kept. This is not a per 218 * version size. 219 * N.B. These blocks are included in the 220 * length field of s_fsckpxd. 221 */ 222 s8 s_fscklog; /* 1: which fsck service log is most recent 223 * 0 => no service log data yet 224 * 1 => the first one 225 * 2 => the 2nd one 226 */ 227 char s_fpack[11]; /* 11: file system volume name 228 * N.B. This must be 11 bytes to 229 * conform with the OS/2 BootSector 230 * requirements 231 */ 232 233 /* extendfs() parameter under s_state & FM_EXTENDFS */ 234 s64 s_xsize; /* 8: extendfs s_size */ 235 pxd_t s_xfsckpxd; /* 8: extendfs fsckpxd */ 236 pxd_t s_xlogpxd; /* 8: extendfs logpxd */ 237 /* - 128 byte boundary - */ 238 239 /* 240 * DFS VFS support (preliminary) 241 */ 242 char s_attach; /* 1: VFS: flag: set when aggregate is attached 243 */ 244 u8 rsrvd4[7]; /* 7: reserved - set to 0 */ 245 246 u64 totalUsable; /* 8: VFS: total of 1K blocks which are 247 * available to "normal" (non-root) users. 248 */ 249 u64 minFree; /* 8: VFS: # of 1K blocks held in reserve for 250 * exclusive use of root. This value can be 0, 251 * and if it is then totalUsable will be equal 252 * to # of blocks in aggregate. I believe this 253 * means that minFree + totalUsable = # blocks. 254 * In that case, we don't need to store both 255 * totalUsable and minFree since we can compute 256 * one from the other. I would guess minFree 257 * would be the one we should store, and 258 * totalUsable would be the one we should 259 * compute. (Just a guess...) 260 */ 261 262 u64 realFree; /* 8: VFS: # of free 1K blocks can be used by 263 * "normal" users. It may be this is something 264 * we should compute when asked for instead of 265 * storing in the superblock. I don't know how 266 * often this information is needed. 267 */ 268 /* 269 * graffiti area 270 */ 271 }; 272 273 /* from jfs_dtree.h */ 274 275 /* 276 * entry segment/slot 277 * 278 * an entry consists of type dependent head/only segment/slot and 279 * additional segments/slots linked vi next field; 280 * N.B. last/only segment of entry is terminated by next = -1; 281 */ 282 /* 283 * directory page slot 284 */ 285 typedef struct { 286 s8 next; /* 1: */ 287 s8 cnt; /* 1: */ 288 UniChar name[15]; /* 30: */ 289 } dtslot_t; /* (32) */ 290 291 #define DTSLOTDATALEN 15 292 293 /* 294 * internal node entry head/only segment 295 */ 296 typedef struct { 297 pxd_t xd; /* 8: child extent descriptor */ 298 299 s8 next; /* 1: */ 300 u8 namlen; /* 1: */ 301 UniChar name[11]; /* 22: 2-byte aligned */ 302 } idtentry_t; /* (32) */ 303 304 /* 305 * leaf node entry head/only segment 306 * 307 * For legacy filesystems, name contains 13 unichars -- no index field 308 */ 309 typedef struct { 310 u32 inumber; /* 4: 4-byte aligned */ 311 s8 next; /* 1: */ 312 u8 namlen; /* 1: */ 313 UniChar name[11]; /* 22: 2-byte aligned */ 314 u32 index; /* 4: index into dir_table */ 315 } ldtentry_t; /* (32) */ 316 317 #define DTLHDRDATALEN 11 318 319 /* 320 * dir_table used for directory traversal during readdir 321 */ 322 323 /* 324 * Maximum entry in inline directory table 325 */ 326 327 typedef struct dir_table_slot { 328 u8 rsrvd; /* 1: */ 329 u8 flag; /* 1: 0 if free */ 330 u8 slot; /* 1: slot within leaf page of entry */ 331 u8 addr1; /* 1: upper 8 bits of leaf page address */ 332 u32 addr2; /* 4: lower 32 bits of leaf page address -OR- 333 index of next entry when this entry was deleted */ 334 } dir_table_slot_t; /* (8) */ 335 336 /* 337 * directory root page (in-line in on-disk inode): 338 * 339 * cf. dtpage_t below. 340 */ 341 typedef union { 342 struct { 343 dasd_t DASD; /* 16: DASD limit/usage info F226941 */ 344 345 u8 flag; /* 1: */ 346 s8 nextindex; /* 1: next free entry in stbl */ 347 s8 freecnt; /* 1: free count */ 348 s8 freelist; /* 1: freelist header */ 349 350 u32 idotdot; /* 4: parent inode number */ 351 352 s8 stbl[8]; /* 8: sorted entry index table */ 353 } header; /* (32) */ 354 355 dtslot_t slot[9]; 356 } dtroot_t; 357 358 /* 359 * directory regular page: 360 * 361 * entry slot array of 32 byte slot 362 * 363 * sorted entry slot index table (stbl): 364 * contiguous slots at slot specified by stblindex, 365 * 1-byte per entry 366 * 512 byte block: 16 entry tbl (1 slot) 367 * 1024 byte block: 32 entry tbl (1 slot) 368 * 2048 byte block: 64 entry tbl (2 slot) 369 * 4096 byte block: 128 entry tbl (4 slot) 370 * 371 * data area: 372 * 512 byte block: 16 - 2 = 14 slot 373 * 1024 byte block: 32 - 2 = 30 slot 374 * 2048 byte block: 64 - 3 = 61 slot 375 * 4096 byte block: 128 - 5 = 123 slot 376 * 377 * N.B. index is 0-based; index fields refer to slot index 378 * except nextindex which refers to entry index in stbl; 379 * end of entry stot list or freelist is marked with -1. 380 */ 381 typedef union { 382 struct { 383 s64 next; /* 8: next sibling */ 384 s64 prev; /* 8: previous sibling */ 385 386 u8 flag; /* 1: */ 387 s8 nextindex; /* 1: next entry index in stbl */ 388 s8 freecnt; /* 1: */ 389 s8 freelist; /* 1: slot index of head of freelist */ 390 391 u8 maxslot; /* 1: number of slots in page slot[] */ 392 s8 stblindex; /* 1: slot index of start of stbl */ 393 u8 rsrvd[2]; /* 2: */ 394 395 pxd_t self; /* 8: self pxd */ 396 } header; /* (32) */ 397 398 dtslot_t slot[128]; 399 } dtpage_t; 400 401 /* from jfs_xtree.h */ 402 403 /* 404 * extent allocation descriptor (xad) 405 */ 406 typedef struct xad { 407 unsigned flag:8; /* 1: flag */ 408 unsigned rsvrd:16; /* 2: reserved */ 409 unsigned off1:8; /* 1: offset in unit of fsblksize */ 410 u32 off2; /* 4: offset in unit of fsblksize */ 411 unsigned len:24; /* 3: length in unit of fsblksize */ 412 unsigned addr1:8; /* 1: address in unit of fsblksize */ 413 u32 addr2; /* 4: address in unit of fsblksize */ 414 } xad_t; /* (16) */ 415 416 /* xad_t field extraction */ 417 #define offsetXAD(xad) (((s64)((xad)->off1)) << 32 | ((xad)->off2)) 418 #define addressXAD(xad) (((s64)((xad)->addr1)) << 32 | ((xad)->addr2)) 419 #define lengthXAD(xad) ((xad)->len) 420 421 /* possible values for maxentry */ 422 #define XTPAGEMAXSLOT 256 423 #define XTENTRYSTART 2 424 425 /* 426 * xtree page: 427 */ 428 typedef union { 429 struct xtheader { 430 s64 next; /* 8: */ 431 s64 prev; /* 8: */ 432 433 u8 flag; /* 1: */ 434 u8 rsrvd1; /* 1: */ 435 s16 nextindex; /* 2: next index = number of entries */ 436 s16 maxentry; /* 2: max number of entries */ 437 s16 rsrvd2; /* 2: */ 438 439 pxd_t self; /* 8: self */ 440 } header; /* (32) */ 441 442 xad_t xad[XTPAGEMAXSLOT]; /* 16 * maxentry: xad array */ 443 } xtpage_t; 444 445 /* from jfs_dinode.h */ 446 447 struct dinode { 448 /* 449 * I. base area (128 bytes) 450 * ------------------------ 451 * 452 * define generic/POSIX attributes 453 */ 454 u32 di_inostamp; /* 4: stamp to show inode belongs to fileset */ 455 s32 di_fileset; /* 4: fileset number */ 456 u32 di_number; /* 4: inode number, aka file serial number */ 457 u32 di_gen; /* 4: inode generation number */ 458 459 pxd_t di_ixpxd; /* 8: inode extent descriptor */ 460 461 s64 di_size; /* 8: size */ 462 s64 di_nblocks; /* 8: number of blocks allocated */ 463 464 u32 di_nlink; /* 4: number of links to the object */ 465 466 u32 di_uid; /* 4: user id of owner */ 467 u32 di_gid; /* 4: group id of owner */ 468 469 u32 di_mode; /* 4: attribute, format and permission */ 470 471 struct timestruc_t di_atime; /* 8: time last data accessed */ 472 struct timestruc_t di_ctime; /* 8: time last status changed */ 473 struct timestruc_t di_mtime; /* 8: time last data modified */ 474 struct timestruc_t di_otime; /* 8: time created */ 475 476 dxd_t di_acl; /* 16: acl descriptor */ 477 478 dxd_t di_ea; /* 16: ea descriptor */ 479 480 s32 di_next_index; /* 4: Next available dir_table index */ 481 482 s32 di_acltype; /* 4: Type of ACL */ 483 484 /* 485 * Extension Areas. 486 * 487 * Historically, the inode was partitioned into 4 128-byte areas, 488 * the last 3 being defined as unions which could have multiple 489 * uses. The first 96 bytes had been completely unused until 490 * an index table was added to the directory. It is now more 491 * useful to describe the last 3/4 of the inode as a single 492 * union. We would probably be better off redesigning the 493 * entire structure from scratch, but we don't want to break 494 * commonality with OS/2's JFS at this time. 495 */ 496 union { 497 struct { 498 /* 499 * This table contains the information needed to 500 * find a directory entry from a 32-bit index. 501 * If the index is small enough, the table is inline, 502 * otherwise, an x-tree root overlays this table 503 */ 504 dir_table_slot_t _table[12]; /* 96: inline */ 505 506 dtroot_t _dtroot; /* 288: dtree root */ 507 } _dir; /* (384) */ 508 #define di_dirtable u._dir._table 509 #define di_dtroot u._dir._dtroot 510 #define di_parent di_dtroot.header.idotdot 511 #define di_DASD di_dtroot.header.DASD 512 513 struct { 514 union { 515 u8 _data[96]; /* 96: unused */ 516 struct { 517 void *_imap; /* 4: unused */ 518 u32 _gengen; /* 4: generator */ 519 } _imap; 520 } _u1; /* 96: */ 521 #define di_gengen u._file._u1._imap._gengen 522 523 union { 524 xtpage_t _xtroot; 525 struct { 526 u8 unused[16]; /* 16: */ 527 dxd_t _dxd; /* 16: */ 528 union { 529 u32 _rdev; /* 4: */ 530 u8 _fastsymlink[128]; 531 } _u; 532 u8 _inlineea[128]; 533 } _special; 534 } _u2; 535 } _file; 536 #define di_xtroot u._file._u2._xtroot 537 #define di_dxd u._file._u2._special._dxd 538 #define di_btroot di_xtroot 539 #define di_inlinedata u._file._u2._special._u 540 #define di_rdev u._file._u2._special._u._rdev 541 #define di_fastsymlink u._file._u2._special._u._fastsymlink 542 #define di_inlineea u._file._u2._special._inlineea 543 } u; 544 }; 545 546 typedef struct dinode dinode_t; 547 548 /* di_mode */ 549 #define IFMT 0xF000 /* S_IFMT - mask of file type */ 550 #define IFDIR 0x4000 /* S_IFDIR - directory */ 551 #define IFREG 0x8000 /* S_IFREG - regular file */ 552 #define IFLNK 0xA000 /* S_IFLNK - symbolic link */ 553 554 /* extended mode bits (on-disk inode di_mode) */ 555 #define INLINEEA 0x00040000 /* inline EA area free */ 556 557 /* from jfs_imap.h */ 558 559 #define EXTSPERIAG 128 /* number of disk inode extent per iag */ 560 #define SMAPSZ 4 /* number of words per summary map */ 561 #define MAXAG 128 /* maximum number of allocation groups */ 562 563 /* 564 * inode allocation map: 565 * 566 * inode allocation map consists of 567 * . the inode map control page and 568 * . inode allocation group pages (per 4096 inodes) 569 * which are addressed by standard JFS xtree. 570 */ 571 /* 572 * inode allocation group page (per 4096 inodes of an AG) 573 */ 574 typedef struct { 575 s64 agstart; /* 8: starting block of ag */ 576 s32 iagnum; /* 4: inode allocation group number */ 577 s32 inofreefwd; /* 4: ag inode free list forward */ 578 s32 inofreeback; /* 4: ag inode free list back */ 579 s32 extfreefwd; /* 4: ag inode extent free list forward */ 580 s32 extfreeback; /* 4: ag inode extent free list back */ 581 s32 iagfree; /* 4: iag free list */ 582 583 /* summary map: 1 bit per inode extent */ 584 s32 inosmap[SMAPSZ]; /* 16: sum map of mapwords w/ free inodes; 585 * note: this indicates free and backed 586 * inodes, if the extent is not backed the 587 * value will be 1. if the extent is 588 * backed but all inodes are being used the 589 * value will be 1. if the extent is 590 * backed but at least one of the inodes is 591 * free the value will be 0. 592 */ 593 s32 extsmap[SMAPSZ]; /* 16: sum map of mapwords w/ free extents */ 594 s32 nfreeinos; /* 4: number of free inodes */ 595 s32 nfreeexts; /* 4: number of free extents */ 596 /* (72) */ 597 u8 pad[1976]; /* 1976: pad to 2048 bytes */ 598 /* allocation bit map: 1 bit per inode (0 - free, 1 - allocated) */ 599 u32 wmap[EXTSPERIAG]; /* 512: working allocation map */ 600 u32 pmap[EXTSPERIAG]; /* 512: persistent allocation map */ 601 pxd_t inoext[EXTSPERIAG]; /* 1024: inode extent addresses */ 602 } iag_t; /* (4096) */ 603 604 #endif /* _JFS_H_ */ 605