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