ffs.h

Go to the documentation of this file.

/*
 * COPYRIGHT:        See COPYING in the top level directory
 * PROJECT:          ReactOS File System Recognizer
 * FILE:             drivers/filesystems/fs_rec/ffs.h
 * PURPOSE:          FFS Header File
 * PROGRAMMER:       Peter Hater
 *                   Pierre Schweitzer (pierre@reactos.org)
 */

#include <pshpack1.h>

/*
 * The path name on which the file system is mounted is maintained
 * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
 * the super block for this name.
 */
#define MAXMNTLEN   468

/*
 * The volume name for this filesystem is maintained in fs_volname.
 * MAXVOLLEN defines the length of the buffer allocated.
 * This space used to be part of of fs_fsmnt.
 */
#define MAXVOLLEN   32

/*
 * Unused value currently, FreeBSD compat.
 */
#define FSMAXSNAP 20

/*
 * There is a 128-byte region in the superblock reserved for in-core
 * pointers to summary information. Originally this included an array
 * of pointers to blocks of struct csum; now there are just four
 * pointers and the remaining space is padded with fs_ocsp[].
 * NOCSPTRS determines the size of this padding. One pointer (fs_csp)
 * is taken away to point to a contiguous array of struct csum for
 * all cylinder groups; a second (fs_maxcluster) points to an array
 * of cluster sizes that is computed as cylinder groups are inspected;
 * the third (fs_contigdirs) points to an array that tracks the
 * creation of new directories; and the fourth (fs_active) is used
 * by snapshots.
 */
#define NOCSPTRS    ((128 / sizeof(void *)) - 4)

/*
 * Per cylinder group information; summarized in blocks allocated
 * from first cylinder group data blocks.  These blocks have to be
 * read in from fs_csaddr (size fs_cssize) in addition to the
 * super block.
 */
struct csum {
    INT32   cs_ndir;        /* number of directories */
    INT32   cs_nbfree;      /* number of free blocks */
    INT32   cs_nifree;      /* number of free inodes */
    INT32   cs_nffree;      /* number of free frags */
};

struct csum_total {
    INT64   cs_ndir;        /* number of directories */
    INT64   cs_nbfree;      /* number of free blocks */
    INT64   cs_nifree;      /* number of free inodes */
    INT64   cs_nffree;      /* number of free frags */
    INT64   cs_spare[4];    /* future expansion */
};

/*
 * Super block for an FFS file system in memory.
 */
typedef struct fs {
    INT32    fs_firstfield;     /* historic file system linked list, */
    INT32    fs_unused_1;       /*     used for incore super blocks */
    INT32    fs_sblkno;     /* addr of super-block in filesys */
    INT32    fs_cblkno;     /* offset of cyl-block in filesys */
    INT32    fs_iblkno;     /* offset of inode-blocks in filesys */
    INT32    fs_dblkno;     /* offset of first data after cg */
    INT32    fs_old_cgoffset;   /* cylinder group offset in cylinder */
    INT32    fs_old_cgmask;     /* used to calc mod fs_ntrak */
    INT32    fs_old_time;       /* last time written */
    INT32    fs_old_size;       /* number of blocks in fs */
    INT32    fs_old_dsize;      /* number of data blocks in fs */
    INT32    fs_ncg;        /* number of cylinder groups */
    INT32    fs_bsize;      /* size of basic blocks in fs */
    INT32    fs_fsize;      /* size of frag blocks in fs */
    INT32    fs_frag;       /* number of frags in a block in fs */
/* these are configuration parameters */
    INT32    fs_minfree;        /* minimum percentage of free blocks */
    INT32    fs_old_rotdelay;   /* num of ms for optimal next block */
    INT32    fs_old_rps;        /* disk revolutions per second */
/* these fields can be computed from the others */
    INT32    fs_bmask;      /* ``blkoff'' calc of blk offsets */
    INT32    fs_fmask;      /* ``fragoff'' calc of frag offsets */
    INT32    fs_bshift;     /* ``lblkno'' calc of logical blkno */
    INT32    fs_fshift;     /* ``numfrags'' calc number of frags */
/* these are configuration parameters */
    INT32    fs_maxcontig;      /* max number of contiguous blks */
    INT32    fs_maxbpg;     /* max number of blks per cyl group */
/* these fields can be computed from the others */
    INT32    fs_fragshift;      /* block to frag shift */
    INT32    fs_fsbtodb;        /* fsbtodb and dbtofsb shift constant */
    INT32    fs_sbsize;     /* actual size of super block */
    INT32    fs_spare1[2];      /* old fs_csmask */
                    /* old fs_csshift */
    INT32    fs_nindir;     /* value of NINDIR */
    INT32    fs_inopb;      /* value of INOPB */
    INT32    fs_old_nspf;       /* value of NSPF */
/* yet another configuration parameter */
    INT32    fs_optim;      /* optimization preference, see below */
/* these fields are derived from the hardware */
    INT32    fs_old_npsect;     /* # sectors/track including spares */
    INT32    fs_old_interleave; /* hardware sector interleave */
    INT32    fs_old_trackskew;  /* sector 0 skew, per track */
/* fs_id takes the space of the unused fs_headswitch and fs_trkseek fields */
    INT32    fs_id[2];      /* unique file system id */
/* sizes determined by number of cylinder groups and their sizes */
    INT32    fs_old_csaddr;     /* blk addr of cyl grp summary area */
    INT32    fs_cssize;     /* size of cyl grp summary area */
    INT32    fs_cgsize;     /* cylinder group size */
/* these fields are derived from the hardware */
    INT32    fs_spare2;     /* old fs_ntrak */
    INT32    fs_old_nsect;      /* sectors per track */
    INT32    fs_old_spc;        /* sectors per cylinder */
    INT32    fs_old_ncyl;       /* cylinders in file system */
    INT32    fs_old_cpg;        /* cylinders per group */
    INT32    fs_ipg;        /* inodes per group */
    INT32    fs_fpg;        /* blocks per group * fs_frag */
/* this data must be re-computed after crashes */
    struct  csum fs_old_cstotal;    /* cylinder summary information */
/* these fields are cleared at mount time */
    INT8     fs_fmod;       /* super block modified flag */
    INT8     fs_clean;      /* file system is clean flag */
    INT8     fs_ronly;      /* mounted read-only flag */
    UINT8    fs_old_flags;      /* see FS_ flags below */
    UCHAR    fs_fsmnt[MAXMNTLEN];   /* name mounted on */
    UCHAR    fs_volname[MAXVOLLEN]; /* volume name */
    UINT64   fs_swuid;      /* system-wide uid */
    INT32    fs_pad;
/* these fields retain the current block allocation info */
    INT32    fs_cgrotor;        /* last cg searched (UNUSED) */
    void    *fs_ocsp[NOCSPTRS]; /* padding; was list of fs_cs buffers */
    UINT8   *fs_contigdirs; /* # of contiguously allocated dirs */
    struct csum *fs_csp;        /* cg summary info buffer for fs_cs */
    INT32   *fs_maxcluster;     /* max cluster in each cyl group */
    INT32   *fs_active;     /* used by snapshots to track fs */
    INT32    fs_old_cpc;        /* cyl per cycle in postbl */
/* this area is otherwise allocated unless fs_old_flags & FS_FLAGS_UPDATED */
    INT32    fs_maxbsize;       /* maximum blocking factor permitted */
    INT64    fs_sparecon64[17]; /* old rotation block list head */
    INT64    fs_sblockloc;      /* byte offset of standard superblock */
    struct  csum_total fs_cstotal;  /* cylinder summary information */
    INT64    fs_time;       /* last time written */
    INT64    fs_size;       /* number of blocks in fs */
    INT64    fs_dsize;      /* number of data blocks in fs */
    INT64    fs_csaddr;     /* blk addr of cyl grp summary area */
    INT64    fs_pendingblocks;  /* blocks in process of being freed */
    INT32    fs_pendinginodes;  /* inodes in process of being freed */
    INT32    fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
/* back to stuff that has been around a while */
    INT32    fs_avgfilesize;    /* expected average file size */
    INT32    fs_avgfpdir;       /* expected # of files per directory */
    INT32    fs_save_cgsize;    /* save real cg size to use fs_bsize */
    INT32    fs_sparecon32[26]; /* reserved for future constants */
    INT32    fs_flags;      /* see FS_ flags below */
/* back to stuff that has been around a while (again) */
    INT32    fs_contigsumsize;  /* size of cluster summary array */ 
    INT32    fs_maxsymlinklen;  /* max length of an internal symlink */
    INT32    fs_old_inodefmt;   /* format of on-disk inodes */
    UINT64   fs_maxfilesize;    /* maximum representable file size */
    INT64    fs_qbmask;     /* ~fs_bmask for use with 64-bit size */
    INT64    fs_qfmask;     /* ~fs_fmask for use with 64-bit size */
    INT32    fs_state;      /* validate fs_clean field (UNUSED) */
    INT32    fs_old_postblformat;   /* format of positional layout tables */
    INT32    fs_old_nrpos;      /* number of rotational positions */
    INT32    fs_spare5[2];      /* old fs_postbloff */
                    /* old fs_rotbloff */
    INT32    fs_magic;      /* magic number */
} FFSD_SUPER_BLOCK, *PFFSD_SUPER_BLOCK;

#define MAXPARTITIONS       16  /* number of partitions */
#define NDDATA 5
#define NSPARE 5

typedef struct disklabel {
    UINT32 d_magic;     /* the magic number */
    UINT16 d_type;      /* drive type */
    UINT16 d_subtype;       /* controller/d_type specific */
    char      d_typename[16];   /* type name, e.g. "eagle" */

    /*
     * d_packname contains the pack identifier and is returned when
     * the disklabel is read off the disk or in-core copy.
     * d_boot0 and d_boot1 are the (optional) names of the
     * primary (block 0) and secondary (block 1-15) bootstraps
     * as found in /usr/mdec.  These are returned when using
     * getdiskbyname(3) to retrieve the values from /etc/disktab.
     */
    union {
        char    un_d_packname[16];  /* pack identifier */
        struct {
            char *un_d_boot0;   /* primary bootstrap name */
            char *un_d_boot1;   /* secondary bootstrap name */
        } un_b;
    } d_un;

            /* disk geometry: */
    UINT32 d_secsize;       /* # of bytes per sector */
    UINT32 d_nsectors;      /* # of data sectors per track */
    UINT32 d_ntracks;       /* # of tracks per cylinder */
    UINT32 d_ncylinders;        /* # of data cylinders per unit */
    UINT32 d_secpercyl;     /* # of data sectors per cylinder */
    UINT32 d_secperunit;        /* # of data sectors per unit */

    /*
     * Spares (bad sector replacements) below are not counted in
     * d_nsectors or d_secpercyl.  Spare sectors are assumed to
     * be physical sectors which occupy space at the end of each
     * track and/or cylinder.
     */
    UINT16 d_sparespertrack;    /* # of spare sectors per track */
    UINT16 d_sparespercyl;  /* # of spare sectors per cylinder */
    /*
     * Alternative cylinders include maintenance, replacement,
     * configuration description areas, etc.
     */
    UINT32 d_acylinders;        /* # of alt. cylinders per unit */

            /* hardware characteristics: */
    /*
     * d_interleave, d_trackskew and d_cylskew describe perturbations
     * in the media format used to compensate for a slow controller.
     * Interleave is physical sector interleave, set up by the
     * formatter or controller when formatting.  When interleaving is
     * in use, logically adjacent sectors are not physically
     * contiguous, but instead are separated by some number of
     * sectors.  It is specified as the ratio of physical sectors
     * traversed per logical sector.  Thus an interleave of 1:1
     * implies contiguous layout, while 2:1 implies that logical
     * sector 0 is separated by one sector from logical sector 1.
     * d_trackskew is the offset of sector 0 on track N relative to
     * sector 0 on track N-1 on the same cylinder.  Finally, d_cylskew
     * is the offset of sector 0 on cylinder N relative to sector 0
     * on cylinder N-1.
     */
    UINT16 d_rpm;       /* rotational speed */
    UINT16 d_interleave;        /* hardware sector interleave */
    UINT16 d_trackskew;     /* sector 0 skew, per track */
    UINT16 d_cylskew;       /* sector 0 skew, per cylinder */
    UINT32 d_headswitch;        /* head switch time, usec */
    UINT32 d_trkseek;       /* track-to-track seek, usec */
    UINT32 d_flags;     /* generic flags */
    UINT32 d_drivedata[NDDATA]; /* drive-type specific information */
    UINT32 d_spare[NSPARE]; /* reserved for future use */
    UINT32 d_magic2;        /* the magic number (again) */
    UINT16 d_checksum;      /* xor of data incl. partitions */

            /* filesystem and partition information: */
    UINT16 d_npartitions;   /* number of partitions in following */
    UINT32 d_bbsize;        /* size of boot area at sn0, bytes */
    UINT32 d_sbsize;        /* max size of fs superblock, bytes */
    struct  partition {     /* the partition table */
        UINT32 p_size;  /* number of sectors in partition */
        UINT32 p_offset;    /* starting sector */
        union {
            UINT32 fsize; /* FFS, ADOS:
                        filesystem basic fragment size */
            UINT32 cdsession; /* ISO9660: session offset */
        } __partition_u2;
        UINT8 p_fstype; /* filesystem type, see below */
        UINT8 p_frag;   /* filesystem fragments per block */
        union {
            UINT16 cpg; /* UFS: FS cylinders per group */
            UINT16 sgs; /* LFS: FS segment shift */
        } __partition_u1;
    } d_partitions[MAXPARTITIONS];  /* actually may be more */
} FFSD_DISKLABEL, *PFFSD_DISKLABEL;
#include <poppack.h>

C_ASSERT(FIELD_OFFSET(FFSD_SUPER_BLOCK, fs_cgsize) == 160);
C_ASSERT(FIELD_OFFSET(FFSD_SUPER_BLOCK, fs_fmod) == 208);
C_ASSERT(FIELD_OFFSET(FFSD_SUPER_BLOCK, fs_ocsp) == 728);

#define SBLOCK_UFS1     8192
#define SBLOCK_UFS2    65536

#define SBLOCKSIZE      8192

/*
 * File system identification
 */
#define FS_UFS1_MAGIC   0x011954    /* UFS1 fast file system magic number */
#define FS_UFS2_MAGIC   0x19540119  /* UFS2 fast file system magic number */

#define DISKMAGIC   ((UINT32)0x82564557)    /* The disk magic number */

#define LABELSECTOR     1   /* sector containing label */

#define FS_BSDFFS   7       /* 4.2BSD fast file system */