Logo Search packages:      
Sourcecode: xbox-cromwell version File versions  Download package

jfs.h

/* jfs.h - an extractions from linux/include/linux/jfs/jfs* into one file */
/*   
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2000  International Business Machines  Corp.
 *  Copyright (C) 2001  Free Software Foundation, Inc.
 *
 *  This program is free software;  you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or 
 *  (at your option) any later version.
 * 
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY;  without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *  the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program;  if not, write to the Free Software 
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifndef _JFS_H_
#define _JFS_H_

/* those are from jfs_filsys.h */

/*
 *     file system option (superblock flag)
 */
/* platform option (conditional compilation) */
#define JFS_AIX         0x80000000  /* AIX support */
/*    POSIX name/directory  support */

#define JFS_OS2         0x40000000  /* OS/2 support */
/*    case-insensitive name/directory support */

#define JFS_LINUX       0x10000000  /* Linux support */
/*    case-sensitive name/directory support */

/* directory option */
#define JFS_UNICODE     0x00000001  /* unicode name */

/* bba */
#define     JFS_SWAP_BYTES          0x00100000  /* running on big endian computer */


/*
 *    buffer cache configuration
 */
/* page size */
#ifdef PSIZE
#undef PSIZE
#endif
#define     PSIZE       4096  /* page size (in byte) */

/*
 *    fs fundamental size
 *
 * PSIZE >= file system block size >= PBSIZE >= DISIZE
 */
#define     PBSIZE            512   /* physical block size (in byte) */
#define DISIZE          512   /* on-disk inode size (in byte) */
#define L2DISIZE  9
#define     INOSPERIAG  4096  /* number of disk inodes per iag */
#define     L2INOSPERIAG      12
#define INOSPEREXT      32    /* number of disk inode per extent */
#define L2INOSPEREXT    5

/* Minimum number of bytes supported for a JFS partition */
#define MINJFS                (0x1000000)

/*
 * fixed byte offset address
 */
#define SUPER1_OFF      0x8000      /* primary superblock */

#define AITBL_OFF (SUPER1_OFF + PSIZE + (PSIZE << 1))

/*
 *    fixed reserved inode number
 */
/* aggregate inode */
#define     AGGREGATE_I 1     /* aggregate inode map inode */
#define     FILESYSTEM_I      16    /* 1st/only fileset inode in ait:
                         * fileset inode map inode
                         */

/* per fileset inode */
#define     ROOT_I            2     /* fileset root inode */

/*
 *    directory configuration
 */
#define JFS_NAME_MAX    255
#define JFS_PATH_MAX    PSIZE

typedef unsigned char u8;
typedef char s8;
typedef unsigned short u16;
typedef short s16;
typedef unsigned int u32;
typedef int s32;
typedef unsigned long long u64;
typedef long long s64;

typedef u16 UniChar;

/* these from jfs_btree.h */

/* btpaget_t flag */
#define BT_TYPE         0x07  /* B+-tree index */
#define     BT_ROOT           0x01  /* root page */
#define     BT_LEAF           0x02  /* leaf page */
#define     BT_INTERNAL 0x04  /* internal page */
#define     BT_RIGHTMOST      0x10  /* rightmost page */
#define     BT_LEFTMOST 0x20  /* leftmost page */

/* those are from jfs_types.h */

struct timestruc_t {
      u32 tv_sec;
      u32 tv_nsec;
};

/*
 *    physical xd (pxd)
 */
typedef struct {
      unsigned len:24;
      unsigned addr1:8;
      u32 addr2;
} pxd_t;

/* xd_t field extraction */
#define     lengthPXD(pxd)    ((pxd)->len)
#define     addressPXD(pxd)   (((s64)((pxd)->addr1)) << 32 | ((pxd)->addr2))

/*
 *    data extent descriptor (dxd)
 */
typedef struct {
      unsigned flag:8;  /* 1: flags */
      unsigned rsrvd:24;      /* 3: */
      u32 size;         /* 4: size in byte */
      unsigned len:24;  /* 3: length in unit of fsblksize */
      unsigned addr1:8; /* 1: address in unit of fsblksize */
      u32 addr2;        /* 4: address in unit of fsblksize */
} dxd_t;                /* - 16 - */

/*
 *    DASD limit information - stored in directory inode
 */
typedef struct dasd {
      u8 thresh;        /* Alert Threshold (in percent) */
      u8 delta;         /* Alert Threshold delta (in percent)   */
      u8 rsrvd1;
      u8 limit_hi;            /* DASD limit (in logical blocks)       */
      u32 limit_lo;           /* DASD limit (in logical blocks)       */
      u8 rsrvd2[3];
      u8 used_hi;       /* DASD usage (in logical blocks)       */
      u32 used_lo;            /* DASD usage (in logical blocks)       */
} dasd_t;


/* from jfs_superblock.h */

#define JFS_MAGIC       0x3153464A  /* "JFS1" */

struct jfs_superblock
{
      u32 s_magic;            /* 4: magic number */
      u32 s_version;          /* 4: version number */

      s64 s_size;       /* 8: aggregate size in hardware/LVM blocks;
                         * VFS: number of blocks
                         */
      s32 s_bsize;            /* 4: aggregate block size in bytes; 
                         * VFS: fragment size
                         */
      s16 s_l2bsize;          /* 2: log2 of s_bsize */
      s16 s_l2bfactor;  /* 2: log2(s_bsize/hardware block size) */
      s32 s_pbsize;           /* 4: hardware/LVM block size in bytes */
      s16 s_l2pbsize;         /* 2: log2 of s_pbsize */
      s16 pad;          /* 2: padding necessary for alignment */

      u32 s_agsize;           /* 4: allocation group size in aggr. blocks */

      u32 s_flag;       /* 4: aggregate attributes:
                         *    see jfs_filsys.h
                         */
      u32 s_state;            /* 4: mount/unmount/recovery state: 
                         *    see jfs_filsys.h
                         */
      s32 s_compress;         /* 4: > 0 if data compression */

      pxd_t s_ait2;           /* 8: first extent of secondary
                         *    aggregate inode table
                         */

      pxd_t s_aim2;           /* 8: first extent of secondary
                         *    aggregate inode map
                         */
      u32 s_logdev;           /* 4: device address of log */
      s32 s_logserial;  /* 4: log serial number at aggregate mount */
      pxd_t s_logpxd;         /* 8: inline log extent */

      pxd_t s_fsckpxd;  /* 8: inline fsck work space extent */

      struct timestruc_t s_time;    /* 8: time last updated */

      s32 s_fsckloglen; /* 4: Number of filesystem blocks reserved for
                         *    the fsck service log.  
                         *    N.B. These blocks are divided among the
                         *         versions kept.  This is not a per
                         *         version size.
                         *    N.B. These blocks are included in the 
                         *         length field of s_fsckpxd.
                         */
      s8 s_fscklog;           /* 1: which fsck service log is most recent
                         *    0 => no service log data yet
                         *    1 => the first one
                         *    2 => the 2nd one
                         */
      char s_fpack[11]; /* 11: file system volume name 
                         *     N.B. This must be 11 bytes to
                         *          conform with the OS/2 BootSector
                         *          requirements
                         */

      /* extendfs() parameter under s_state & FM_EXTENDFS */
      s64 s_xsize;            /* 8: extendfs s_size */
      pxd_t s_xfsckpxd; /* 8: extendfs fsckpxd */
      pxd_t s_xlogpxd;  /* 8: extendfs logpxd */
      /* - 128 byte boundary - */

      /*
       *      DFS VFS support (preliminary) 
       */
      char s_attach;          /* 1: VFS: flag: set when aggregate is attached
                         */
      u8 rsrvd4[7];           /* 7: reserved - set to 0 */

      u64 totalUsable;  /* 8: VFS: total of 1K blocks which are
                         * available to "normal" (non-root) users.
                         */
      u64 minFree;            /* 8: VFS: # of 1K blocks held in reserve for 
                         * exclusive use of root.  This value can be 0,
                         * and if it is then totalUsable will be equal 
                         * to # of blocks in aggregate.  I believe this
                         * means that minFree + totalUsable = # blocks.
                         * In that case, we don't need to store both 
                         * totalUsable and minFree since we can compute
                         * one from the other.  I would guess minFree 
                         * would be the one we should store, and 
                         * totalUsable would be the one we should 
                         * compute.  (Just a guess...)
                         */

      u64 realFree;           /* 8: VFS: # of free 1K blocks can be used by 
                         * "normal" users.  It may be this is something
                         * we should compute when asked for instead of 
                         * storing in the superblock.  I don't know how
                         * often this information is needed.
                         */
      /*
       *      graffiti area
       */
};

/* from jfs_dtree.h */

/*
 *      entry segment/slot
 *
 * an entry consists of type dependent head/only segment/slot and
 * additional segments/slots linked vi next field;
 * N.B. last/only segment of entry is terminated by next = -1;
 */
/*
 *    directory page slot
 */
typedef struct {
      s8 next;          /* 1: */
      s8 cnt;                 /* 1: */
      UniChar name[15]; /* 30: */
} dtslot_t;             /* (32) */

#define DTSLOTDATALEN   15

/*
 *     internal node entry head/only segment
 */
typedef struct {
      pxd_t xd;         /* 8: child extent descriptor */

      s8 next;          /* 1: */
      u8 namlen;        /* 1: */
      UniChar name[11]; /* 22: 2-byte aligned */
} idtentry_t;                 /* (32) */

/*
 *    leaf node entry head/only segment
 *
 *    For legacy filesystems, name contains 13 unichars -- no index field
 */
typedef struct {
      u32 inumber;            /* 4: 4-byte aligned */
      s8 next;          /* 1: */
      u8 namlen;        /* 1: */
      UniChar name[11]; /* 22: 2-byte aligned */
      u32 index;        /* 4: index into dir_table */
} ldtentry_t;                 /* (32) */

#define DTLHDRDATALEN   11

/*
 * dir_table used for directory traversal during readdir
*/ 

/*
 * Maximum entry in inline directory table
 */

typedef struct dir_table_slot {
      u8 rsrvd;   /* 1: */
      u8 flag;    /* 1: 0 if free */
      u8 slot;    /* 1: slot within leaf page of entry */
      u8 addr1;   /* 1: upper 8 bits of leaf page address */
      u32 addr2;  /* 4: lower 32 bits of leaf page address -OR-
                        index of next entry when this entry was deleted */
} dir_table_slot_t;     /* (8) */

/*
 *    directory root page (in-line in on-disk inode):
 *
 * cf. dtpage_t below.
 */
typedef union {
      struct {
            dasd_t DASD;      /* 16: DASD limit/usage info  F226941 */

            u8 flag;    /* 1: */
            s8 nextindex;     /* 1: next free entry in stbl */
            s8 freecnt; /* 1: free count */
            s8 freelist;      /* 1: freelist header */

            u32 idotdot;      /* 4: parent inode number */

            s8 stbl[8]; /* 8: sorted entry index table */
      } header;         /* (32) */

      dtslot_t slot[9];
} dtroot_t;

/*
 *    directory regular page:
 *
 *    entry slot array of 32 byte slot
 *
 * sorted entry slot index table (stbl):
 * contiguous slots at slot specified by stblindex,
 * 1-byte per entry
 *   512 byte block:  16 entry tbl (1 slot)
 *  1024 byte block:  32 entry tbl (1 slot)
 *  2048 byte block:  64 entry tbl (2 slot)
 *  4096 byte block: 128 entry tbl (4 slot)
 *
 * data area:
 *   512 byte block:  16 - 2 =  14 slot
 *  1024 byte block:  32 - 2 =  30 slot
 *  2048 byte block:  64 - 3 =  61 slot
 *  4096 byte block: 128 - 5 = 123 slot
 *
 * N.B. index is 0-based; index fields refer to slot index
 * except nextindex which refers to entry index in stbl;
 * end of entry stot list or freelist is marked with -1.
 */
typedef union {
      struct {
            s64 next;   /* 8: next sibling */
            s64 prev;   /* 8: previous sibling */

            u8 flag;    /* 1: */
            s8 nextindex;     /* 1: next entry index in stbl */
            s8 freecnt; /* 1: */
            s8 freelist;      /* 1: slot index of head of freelist */

            u8 maxslot; /* 1: number of slots in page slot[] */
            s8 stblindex;     /* 1: slot index of start of stbl */
            u8 rsrvd[2];      /* 2: */

            pxd_t self; /* 8: self pxd */
      } header;         /* (32) */

      dtslot_t slot[128];
} dtpage_t;

/* from jfs_xtree.h */

/*
 *      extent allocation descriptor (xad)
 */
typedef struct xad {
      unsigned flag:8;  /* 1: flag */
      unsigned rsvrd:16;      /* 2: reserved */
      unsigned off1:8;  /* 1: offset in unit of fsblksize */
      u32 off2;         /* 4: offset in unit of fsblksize */
      unsigned len:24;  /* 3: length in unit of fsblksize */
      unsigned addr1:8; /* 1: address in unit of fsblksize */
      u32 addr2;        /* 4: address in unit of fsblksize */
} xad_t;                /* (16) */

/* xad_t field extraction */
#define offsetXAD(xad)  (((s64)((xad)->off1)) << 32 | ((xad)->off2))
#define addressXAD(xad) (((s64)((xad)->addr1)) << 32 | ((xad)->addr2))
#define lengthXAD(xad)  ((xad)->len)

/* possible values for maxentry */
#define XTPAGEMAXSLOT   256
#define XTENTRYSTART    2

/*
 *      xtree page:
 */
typedef union {
      struct xtheader {
            s64 next;   /* 8: */
            s64 prev;   /* 8: */

            u8 flag;    /* 1: */
            u8 rsrvd1;  /* 1: */
            s16 nextindex;    /* 2: next index = number of entries */
            s16 maxentry;     /* 2: max number of entries */
            s16 rsrvd2; /* 2: */

            pxd_t self; /* 8: self */
      } header;         /* (32) */

      xad_t xad[XTPAGEMAXSLOT];     /* 16 * maxentry: xad array */
} xtpage_t;

/* from jfs_dinode.h */

struct dinode {
      /*
       *      I. base area (128 bytes)
       *      ------------------------
       *
       * define generic/POSIX attributes
       */
      u32 di_inostamp;  /* 4: stamp to show inode belongs to fileset */
      s32 di_fileset;         /* 4: fileset number */
      u32 di_number;          /* 4: inode number, aka file serial number */
      u32 di_gen;       /* 4: inode generation number */

      pxd_t di_ixpxd;         /* 8: inode extent descriptor */

      s64 di_size;            /* 8: size */
      s64 di_nblocks;         /* 8: number of blocks allocated */

      u32 di_nlink;           /* 4: number of links to the object */

      u32 di_uid;       /* 4: user id of owner */
      u32 di_gid;       /* 4: group id of owner */

      u32 di_mode;            /* 4: attribute, format and permission */

      struct timestruc_t di_atime;  /* 8: time last data accessed */
      struct timestruc_t di_ctime;  /* 8: time last status changed */
      struct timestruc_t di_mtime;  /* 8: time last data modified */
      struct timestruc_t di_otime;  /* 8: time created */

      dxd_t di_acl;           /* 16: acl descriptor */

      dxd_t di_ea;            /* 16: ea descriptor */

      s32 di_next_index;  /* 4: Next available dir_table index */

      s32 di_acltype;         /* 4: Type of ACL */

      /*
       *    Extension Areas.
       *
       *    Historically, the inode was partitioned into 4 128-byte areas,
       *    the last 3 being defined as unions which could have multiple
       *    uses.  The first 96 bytes had been completely unused until
       *    an index table was added to the directory.  It is now more
       *    useful to describe the last 3/4 of the inode as a single
       *    union.  We would probably be better off redesigning the
       *    entire structure from scratch, but we don't want to break
       *    commonality with OS/2's JFS at this time.
       */
      union {
            struct {
                  /*
                   * This table contains the information needed to
                   * find a directory entry from a 32-bit index.
                   * If the index is small enough, the table is inline,
                   * otherwise, an x-tree root overlays this table
                   */
                  dir_table_slot_t _table[12];  /* 96: inline */

                  dtroot_t _dtroot;       /* 288: dtree root */
            } _dir;                             /* (384) */
#define di_dirtable     u._dir._table
#define di_dtroot u._dir._dtroot
#define di_parent       di_dtroot.header.idotdot
#define di_DASD         di_dtroot.header.DASD

            struct {
                  union {
                        u8 _data[96];           /* 96: unused */
                        struct {
                              void *_imap;      /* 4: unused */
                              u32 _gengen;      /* 4: generator */
                        } _imap;
                  } _u1;                        /* 96: */
#define di_gengen u._file._u1._imap._gengen

                  union {
                        xtpage_t _xtroot;
                        struct {
                              u8 unused[16];    /* 16: */
                              dxd_t _dxd; /* 16: */
                              union {
                                    u32 _rdev;  /* 4: */
                                    u8 _fastsymlink[128];
                              } _u;
                              u8 _inlineea[128];
                        } _special;
                  } _u2;
            } _file;
#define di_xtroot u._file._u2._xtroot
#define di_dxd          u._file._u2._special._dxd
#define di_btroot di_xtroot
#define di_inlinedata   u._file._u2._special._u
#define di_rdev         u._file._u2._special._u._rdev
#define di_fastsymlink  u._file._u2._special._u._fastsymlink
#define di_inlineea     u._file._u2._special._inlineea
      } u;
};

typedef struct dinode dinode_t;

/* di_mode */
#define IFMT      0xF000            /* S_IFMT - mask of file type */
#define IFDIR     0x4000            /* S_IFDIR - directory */
#define IFREG     0x8000            /* S_IFREG - regular file */
#define IFLNK     0xA000            /* S_IFLNK - symbolic link */

/* extended mode bits (on-disk inode di_mode) */
#define INLINEEA        0x00040000  /* inline EA area free */

/* from jfs_imap.h */

#define     EXTSPERIAG  128   /* number of disk inode extent per iag  */
#define SMAPSZ          4     /* number of words per summary map      */
#define     MAXAG       128   /* maximum number of allocation groups  */

/*
 *    inode allocation map:
 * 
 * inode allocation map consists of 
 * . the inode map control page and
 * . inode allocation group pages (per 4096 inodes)
 * which are addressed by standard JFS xtree.
 */
/*
 *    inode allocation group page (per 4096 inodes of an AG)
 */
typedef struct {
      s64 agstart;            /* 8: starting block of ag              */
      s32 iagnum;       /* 4: inode allocation group number     */
      s32 inofreefwd;         /* 4: ag inode free list forward        */
      s32 inofreeback;  /* 4: ag inode free list back           */
      s32 extfreefwd;         /* 4: ag inode extent free list forward */
      s32 extfreeback;  /* 4: ag inode extent free list back    */
      s32 iagfree;            /* 4: iag free list                     */

      /* summary map: 1 bit per inode extent */
      s32 inosmap[SMAPSZ];    /* 16: sum map of mapwords w/ free inodes;
                         *      note: this indicates free and backed
                         *      inodes, if the extent is not backed the
                         *      value will be 1.  if the extent is
                         *      backed but all inodes are being used the
                         *      value will be 1.  if the extent is
                         *      backed but at least one of the inodes is
                         *      free the value will be 0.
                         */
      s32 extsmap[SMAPSZ];    /* 16: sum map of mapwords w/ free extents */
      s32 nfreeinos;          /* 4: number of free inodes             */
      s32 nfreeexts;          /* 4: number of free extents            */
      /* (72) */
      u8 pad[1976];           /* 1976: pad to 2048 bytes */
      /* allocation bit map: 1 bit per inode (0 - free, 1 - allocated) */
      u32 wmap[EXTSPERIAG];   /* 512: working allocation map  */
      u32 pmap[EXTSPERIAG];   /* 512: persistent allocation map */
      pxd_t inoext[EXTSPERIAG];     /* 1024: inode extent addresses */
} iag_t;                /* (4096) */

#endif /* _JFS_H_ */

Generated by  Doxygen 1.6.0   Back to index