qemu/roms/openbios/fs/grubfs/jfs.h

   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_ */