/*++

joejoe most of this will just disappear....VBO will remain......



Copyright (c) 1989  Microsoft Corporation

Module Name:

    Rx.h

Abstract:

    This module defines the on-disk structure of the Rx file system.

Author:

    Gary Kimura     [GaryKi]    28-Dec-1989

Revision History:

--*/

#ifndef _RDBSS_
#define _RDBSS_

//
//  The following nomenclature is used to describe the Rx on-disk
//  structure:
//
//      LBN - is the number of a sector relative to the start of the disk.
//
//      VBN - is the number of a sector relative to the start of a file,
//          directory, or allocation.
//
//      LBO - is a byte offset relative to the start of the disk.
//
//      VBO - is a byte offset relative to the start of a file, directory
//          or allocation.
//

//typedef ULONG LBO;
//typedef LBO *PLBO;

//typedef ULONG VBO;
//typedef LONGLONG RXVBO;
//typedef VBO *PVBO;

#if 0

//
//  The boot sector is the first physical sector (LBN == 0) on the volume.
//  Part of the sector contains a BIOS Parameter Block.  The BIOS in the
//  sector is packed (i.e., unaligned) so we'll supply a unpacking macro
//  to translate a packed BIOS into its unpacked equivalent.  The unpacked
//  BIOS structure is already defined in ntioapi.h so we only need to define
//  the packed BIOS.
//

//
//  Define the Packed and Unpacked BIOS Parameter Block
//

typedef struct _PACKED_BIOS_PARAMETER_BLOCK {
    UCHAR  BytesPerSector[2];                       // offset = 0x000  0
    UCHAR  SectorsPerCluster[1];                    // offset = 0x002  2
    UCHAR  ReservedSectors[2];                      // offset = 0x003  3
    UCHAR  Rxs[1];                                 // offset = 0x005  5
    UCHAR  RootEntries[2];                          // offset = 0x006  6
    UCHAR  Sectors[2];                              // offset = 0x008  8
    UCHAR  Media[1];                                // offset = 0x00A 10
    UCHAR  SectorsPerRx[2];                        // offset = 0x00B 11
    UCHAR  SectorsPerTrack[2];                      // offset = 0x00D 13
    UCHAR  Heads[2];                                // offset = 0x00F 15
    UCHAR  HiddenSectors[4];                        // offset = 0x011 17
    UCHAR  LargeSectors[4];                         // offset = 0x015 21
} PACKED_BIOS_PARAMETER_BLOCK;                      // sizeof = 0x019 25
typedef PACKED_BIOS_PARAMETER_BLOCK *PPACKED_BIOS_PARAMETER_BLOCK;

typedef struct BIOS_PARAMETER_BLOCK {
    USHORT BytesPerSector;
    UCHAR  SectorsPerCluster;
    USHORT ReservedSectors;
    UCHAR  Rxs;
    USHORT RootEntries;
    USHORT Sectors;
    UCHAR  Media;
    USHORT SectorsPerRx;
    USHORT SectorsPerTrack;
    USHORT Heads;
    ULONG  HiddenSectors;
    ULONG  LargeSectors;
} BIOS_PARAMETER_BLOCK, *PBIOS_PARAMETER_BLOCK;

//
//  This macro takes a Packed BIOS and fills in its Unpacked equivalent
//

#define RxUnpackBios(Bios,Pbios) {                                    \
    CopyUchar2(&(Bios)->BytesPerSector,    &(Pbios)->BytesPerSector[0]   ); \
    CopyUchar1(&(Bios)->SectorsPerCluster, &(Pbios)->SectorsPerCluster[0]); \
    CopyUchar2(&(Bios)->ReservedSectors,   &(Pbios)->ReservedSectors[0]  ); \
    CopyUchar1(&(Bios)->Rxs,              &(Pbios)->Rxs[0]             ); \
    CopyUchar2(&(Bios)->RootEntries,       &(Pbios)->RootEntries[0]      ); \
    CopyUchar2(&(Bios)->Sectors,           &(Pbios)->Sectors[0]          ); \
    CopyUchar1(&(Bios)->Media,             &(Pbios)->Media[0]            ); \
    CopyUchar2(&(Bios)->SectorsPerRx,     &(Pbios)->SectorsPerRx[0]    ); \
    CopyUchar2(&(Bios)->SectorsPerTrack,   &(Pbios)->SectorsPerTrack[0]  ); \
    CopyUchar2(&(Bios)->Heads,             &(Pbios)->Heads[0]            ); \
    CopyUchar4(&(Bios)->HiddenSectors,     &(Pbios)->HiddenSectors[0]    ); \
    CopyUchar4(&(Bios)->LargeSectors,      &(Pbios)->LargeSectors[0]     ); \
}

//
//  Define the boot sector
//

typedef struct _PACKED_BOOT_SECTOR {
    UCHAR Jump[3];                                  // offset = 0x000   0
    UCHAR Oem[8];                                   // offset = 0x003   3
    PACKED_BIOS_PARAMETER_BLOCK PackedBpb;          // offset = 0x00B  11
    UCHAR PhysicalDriveNumber;                      // offset = 0x024  36
    UCHAR Reserved;                                 // offset = 0x025  37
    UCHAR Signature;                                // offset = 0x026  38
    UCHAR Id[4];                                    // offset = 0x027  39
    UCHAR VolumeLabel[11];                          // offset = 0x02B  43
    UCHAR SystemId[8];                              // offset = 0x036  54
} PACKED_BOOT_SECTOR;                               // sizeof = 0x03E  62

typedef PACKED_BOOT_SECTOR *PPACKED_BOOT_SECTOR;

//
//  Define a Rx Entry type.
//
//  This type is used when representing a rx table entry.  It also used
//  to be used when dealing with a rx table index and a count of entries,
//  but the ensuing type casting nightmare sealed this rxe.  These other
//  two types are represented as ULONGs.
//

typedef USHORT RDBSS_ENTRY;
typedef RDBSS_ENTRY *PRDBSS_ENTRY;

#define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(RDBSS_ENTRY))

//
//  The following constants the are the valid Rx index values.
//

#define RDBSS_CLUSTER_AVAILABLE            (RDBSS_ENTRY)0x0000
#define RDBSS_CLUSTER_RESERVED             (RDBSS_ENTRY)0xfff0
#define RDBSS_CLUSTER_BAD                  (RDBSS_ENTRY)0xfff7
#define RDBSS_CLUSTER_LAST                 (RDBSS_ENTRY)0xffff

//
//  Rx files have the following time/date structures.  Note that the
//  following structure is a 32 bits long but USHORT aligned.
//

typedef struct _RDBSS_TIME {

    USHORT DoubleSeconds : 5;
    USHORT Minute        : 6;
    USHORT Hour          : 5;

} RDBSS_TIME;
typedef RDBSS_TIME *PRDBSS_TIME;

typedef struct _RDBSS_DATE {

    USHORT Day           : 5;
    USHORT Month         : 4;
    USHORT Year          : 7; // Relative to 1980

} RDBSS_DATE;
typedef RDBSS_DATE *PRDBSS_DATE;

typedef struct _RDBSS_TIME_STAMP {

    RDBSS_TIME Time;
    RDBSS_DATE Date;

} RDBSS_TIME_STAMP;
typedef RDBSS_TIME_STAMP *PRDBSS_TIME_STAMP;

//
//  Rx files have 8 character file names and 3 character extensions
//

typedef UCHAR RDBSS8DOT3[11];
typedef RDBSS8DOT3 *PRDBSS8DOT3;


//
//  The directory entry record exists for every file/directory on the
//  disk except for the root directory.
//

typedef struct _PACKED_DIRENT {
    RDBSS8DOT3       FileName;                         //  offset =  0
    UCHAR          Attributes;                       //  offset = 11
    UCHAR          NtByte;                           //  offset = 12
    UCHAR          CreationMSec;                     //  offset = 13
    RDBSS_TIME_STAMP CreationTime;                     //  offset = 14
    RDBSS_DATE       LastAccessDate;                   //  offset = 18
    USHORT         ExtendedAttributes;               //  offset = 20
    RDBSS_TIME_STAMP LastWriteTime;                    //  offset = 22
    RDBSS_ENTRY      FirstClusterOfFile;               //  offset = 26
    ULONG          FileSize;                         //  offset = 28
} PACKED_DIRENT;                                     //  sizeof = 32
typedef PACKED_DIRENT *PPACKED_DIRENT;

//
//  A packed dirent is already quadword aligned so simply declare a dirent as a
//  packed dirent
//

typedef PACKED_DIRENT DIRENT;
typedef DIRENT *PDIRENT;

//
//  The first byte of a dirent describes the dirent.  There is also a routine
//  to help in deciding how to interpret the dirent.
//

#define RDBSS_DIRENT_NEVER_USED            0x00
#define RDBSS_DIRENT_REALLY_0E5            0x05
#define RDBSS_DIRENT_DIRECTORY_ALIAS       0x2e
#define RDBSS_DIRENT_DELETED               0xe5

//
//  Define the NtByte bits.
//

#define RDBSS_DIRENT_NT_BYTE_DIRTY         0x01
#define RDBSS_DIRENT_NT_BYTE_TEST_SURFACE  0x02
#define RDBSS_DIRENT_NT_BYTE_8_LOWER_CASE  0x08
#define RDBSS_DIRENT_NT_BYTE_3_LOWER_CASE  0x10

//
//  Define the various dirent attributes
//

#define RDBSS_DIRENT_ATTR_READ_ONLY        0x01
#define RDBSS_DIRENT_ATTR_HIDDEN           0x02
#define RDBSS_DIRENT_ATTR_SYSTEM           0x04
#define RDBSS_DIRENT_ATTR_VOLUME_ID        0x08
#define RDBSS_DIRENT_ATTR_DIRECTORY        0x10
#define RDBSS_DIRENT_ATTR_ARCHIVE          0x20
#define RDBSS_DIRENT_ATTR_DEVICE           0x40
#define RDBSS_DIRENT_ATTR_LFN              (RDBSS_DIRENT_ATTR_READ_ONLY | \
                                          RDBSS_DIRENT_ATTR_HIDDEN |    \
                                          RDBSS_DIRENT_ATTR_SYSTEM |    \
                                          RDBSS_DIRENT_ATTR_VOLUME_ID)


//
//  These macros convert a number of fields in the Bpb to bytes from sectors
//
//      ULONG
//      RxBytesPerCluster (
//          IN PBIOS_PARAMETER_BLOCK Bios
//      );
//
//      ULONG
//      RxBytesPerRx (
//          IN PBIOS_PARAMETER_BLOCK Bios
//      );
//
//      ULONG
//      RxReservedBytes (
//          IN PBIOS_PARAMETER_BLOCK Bios
//      );
//

#define RxBytesPerCluster(B) ((ULONG)((B)->BytesPerSector * (B)->SectorsPerCluster))

#define RxBytesPerRx(B) ((ULONG)((B)->BytesPerSector * (B)->SectorsPerRx))

#define RxReservedBytes(B) ((ULONG)((B)->BytesPerSector * (B)->ReservedSectors))

//
//  This macro returns the size of the root directory dirent area in bytes
//
//      ULONG
//      RxRootDirectorySize (
//          IN PBIOS_PARAMETER_BLOCK Bios
//          );
//

#define RxRootDirectorySize(B) ((ULONG)((B)->RootEntries * sizeof(DIRENT)))

//
//  This macro returns the first Lbo (zero based) of the root directory on
//  the device.  This area is after the reserved and rxs.
//
//      LBO
//      RxRootDirectoryLbo (
//          IN PBIOS_PARAMETER_BLOCK Bios
//          );
//

#define RxRootDirectoryLbo(B) (RxReservedBytes(B) + ((B)->Rxs * RxBytesPerRx(B)))

//
//  This macro returns the first Lbo (zero based) of the file area on the
//  the device.  This area is after the reserved, rxs, and root directory.
//
//      LBO
//      RxFirstFileAreaLbo (
//          IN PBIOS_PARAMTER_BLOCK Bios
//          );
//

#define RxFileAreaLbo(B) (RxRootDirectoryLbo(B) + RxRootDirectorySize(B))

//
//  This macro returns the number of clusters on the disk.  This value is
//  computed by taking the total sectors on the disk subtracting up to the
//  first file area sector and then dividing by the sectors per cluster count.
//  Note that I don't use any of the above macros since far too much
//  superfluous sector/byte conversion would take place.
//
//      ULONG
//      RxNumberOfClusters (
//          IN PBIOS_PARAMETER_BLOCK Bios
//          );
//

#define RxNumberOfClusters(B) (                                         \
                                                                         \
    (((B)->Sectors + (B)->LargeSectors                                   \
                                                                         \
        -   ((B)->ReservedSectors +                                      \
             (B)->Rxs * (B)->SectorsPerRx +                            \
             (B)->RootEntries * sizeof(DIRENT) / (B)->BytesPerSector ) ) \
                                                                         \
                                    /                                    \
                                                                         \
                        (B)->SectorsPerCluster)                          \
)


//
//  This macro returns the rx table bit size (i.e., 12 or 16 bits)
//
//      ULONG
//      RxIndexBitSize (
//          IN PBIOS_PARAMETER_BLOCK Bios
//          );
//

#define RxIndexBitSize(B) ((UCHAR)(RxNumberOfClusters(B) < 4087 ? 12 : 16))

//
//  This macro raises RxStatus(FILE_CORRUPT) and marks the Fcb bad if an
//  index value is not within the proper range.
//  Note that the first two index values are invalid (0, 1), so we must
//  add two from the top end to make sure the everything is within range
//
//      VOID
//      RxVerifyIndexIsValid (
//          IN PRX_CONTEXT RxContext,
//          IN PVCB Vcb,
//          IN ULONG Index
//          );
//

#define RxVerifyIndexIsValid(IC,V,I) {                                       \
    if (((I) < 2) || ((I) > ((V)->AllocationSupport.NumberOfClusters + 1))) { \
        RxRaiseStatus(IC,RxStatus(FILE_CORRUPT_ERROR));                         \
    }                                                                         \
}

//
//  These two macros are used to translate between Logical Byte Offsets,
//  and rx entry indexes.  Note the use of variables stored in the Vcb.
//  These two macros are used at a higher level than the other macros
//  above.
//
//  LBO
//  GetLboFromRxIndex (
//      IN RDBSS_ENTRY Rx_Index,
//      IN PVCB Vcb
//      );
//
//  RDBSS_ENTRY
//  GetRxIndexFromLbo (
//      IN LBO Lbo,
//      IN PVCB Vcb
//      );
//

#define RxGetLboFromIndex(VCB,RDBSS_INDEX) (                                       \
        (VCB)->AllocationSupport.FileAreaLbo +                                    \
        ((LBO)((RDBSS_INDEX) - 2) << (VCB)->AllocationSupport.LogOfBytesPerCluster) \
)


#define RxGetIndexFromLbo(VCB,LBO) (                      \
        (((LBO) - (VCB)->AllocationSupport.FileAreaLbo) >> \
        (VCB)->AllocationSupport.LogOfBytesPerCluster) + 2 \
)

//
//  The following macro does the tmp shifting and such to lookup an entry
//
//  VOID
//  RxLookup12BitEntry(
//      IN PVOID Rx,
//      IN RDBSS_ENTRY Index,
//      OUT PRDBSS_ENTRY Entry
//      );
//

#define RxLookup12BitEntry(RDBSS,INDEX,ENTRY) {                               \
                                                                             \
    CopyUchar2((PUCHAR)(ENTRY), (PUCHAR)(RDBSS) + (INDEX) * 3 / 2);            \
                                                                             \
    *ENTRY = ((INDEX) & 1) ? *(ENTRY) >> 4 : (RDBSS_ENTRY)(*(ENTRY) & 0xfff);  \
}

//
//  The following macro does the tmp shifting and such to store an entry
//
//  VOID
//  RxSet12BitEntry(
//      IN PVOID Rx,
//      IN RDBSS_ENTRY Index,
//      IN RDBSS_ENTRY Entry
//      );
//

#define RxSet12BitEntry(RDBSS,INDEX,ENTRY) {                            \
                                                                       \
    RDBSS_ENTRY TmpRxEntry;                                             \
                                                                       \
    CopyUchar2((PUCHAR)&TmpRxEntry, (PUCHAR)(RDBSS) + (INDEX) * 3 / 2); \
                                                                       \
    TmpRxEntry = (RDBSS_ENTRY)                                          \
                (((INDEX) & 1) ? ((ENTRY) << 4) | (TmpRxEntry & 0xf)  \
                               : (ENTRY) | (TmpRxEntry & 0xf000));    \
                                                                       \
    *((UNALIGNED UCHAR2 *)((PUCHAR)(RDBSS) + (INDEX) * 3 / 2)) = *((UNALIGNED UCHAR2 *)(&TmpRxEntry)); \
}

//
//  The following macro compares two RDBSS_TIME_STAMPs
//

#define RxAreTimesEqual(TIME1,TIME2) ((BOOLEAN)                  \
    (RtlCompareMemory((TIME1),(TIME2), sizeof(RDBSS_TIME_STAMP)) == \
     sizeof(RDBSS_TIME_STAMP))                                      \
)


#define EA_FILE_SIGNATURE                (0x4445) // "ED"
#define EA_SET_SIGNATURE                 (0x4145) // "EA"

//
//  If the volume contains any ea data then there is one EA file called
//  "EA DATA. SF" located in the root directory as Hidden, System and
//  ReadOnly.
//

typedef struct _EA_FILE_HEADER {
    USHORT Signature;           // offset = 0
    USHORT FormatType;          // offset = 2
    USHORT LogType;             // offset = 4
    USHORT Cluster1;            // offset = 6
    USHORT NewCValue1;          // offset = 8
    USHORT Cluster2;            // offset = 10
    USHORT NewCValue2;          // offset = 12
    USHORT Cluster3;            // offset = 14
    USHORT NewCValue3;          // offset = 16
    USHORT Handle;              // offset = 18
    USHORT NewHOffset;          // offset = 20
    UCHAR  Reserved[10];        // offset = 22
    USHORT EaBaseTable[240];    // offset = 32
} EA_FILE_HEADER;               // sizeof = 512

typedef EA_FILE_HEADER *PEA_FILE_HEADER;

typedef USHORT EA_OFF_TABLE[128];

typedef EA_OFF_TABLE *PEA_OFF_TABLE;

//
//  Every file with an extended attribute contains in its dirent an index
//  into the EaMapTable.  The map table contains an offset within the ea
//  file (cluster aligned) of the ea data for the file.  The individual
//  ea data for each file is prefaced with an Ea Data Header.
//

typedef struct _EA_SET_HEADER {
    USHORT Signature;           // offset = 0
    USHORT OwnEaHandle;         // offset = 2
    ULONG  NeedEaCount;         // offset = 4
    UCHAR  OwnerFileName[14];   // offset = 8
    UCHAR  Reserved[4];         // offset = 22
    UCHAR  cbList[4];           // offset = 26
    UCHAR  PackedEas[1];        // offset = 30
} EA_SET_HEADER;                // sizeof = 30
typedef EA_SET_HEADER *PEA_SET_HEADER;

#define SIZE_OF_EA_SET_HEADER       30

#define MAXIMUM_EA_SIZE             0x0000ffff

#define GetcbList(EASET) (((EASET)->cbList[0] <<  0) + \
                          ((EASET)->cbList[1] <<  8) + \
                          ((EASET)->cbList[2] << 16) + \
                          ((EASET)->cbList[3] << 24))

#define SetcbList(EASET,CB) {                \
    (EASET)->cbList[0] = (CB >>  0) & 0x0ff; \
    (EASET)->cbList[1] = (CB >>  8) & 0x0ff; \
    (EASET)->cbList[2] = (CB >> 16) & 0x0ff; \
    (EASET)->cbList[3] = (CB >> 24) & 0x0ff; \
}

//
//  Every individual ea in an ea set is declared the following packed ea
//

typedef struct _PACKED_EA {
    UCHAR Flags;
    UCHAR EaNameLength;
    UCHAR EaValueLength[2];
    CHAR  EaName[1];
} PACKED_EA;
typedef PACKED_EA *PPACKED_EA;

//
//  The following two macros are used to get and set the ea value length
//  field of a packed ea
//
//      VOID
//      GetEaValueLength (
//          IN PPACKED_EA Ea,
//          OUT PUSHORT ValueLength
//          );
//
//      VOID
//      SetEaValueLength (
//          IN PPACKED_EA Ea,
//          IN USHORT ValueLength
//          );
//

#define GetEaValueLength(EA,LEN) {               \
    *(LEN) = 0;                                  \
    CopyUchar2( (LEN), (EA)->EaValueLength );    \
}

#define SetEaValueLength(EA,LEN) {               \
    CopyUchar2( &((EA)->EaValueLength), (LEN) ); \
}

//
//  The following macro is used to get the size of a packed ea
//
//      VOID
//      SizeOfPackedEa (
//          IN PPACKED_EA Ea,
//          OUT PUSHORT EaSize
//          );
//

#define SizeOfPackedEa(EA,SIZE) {          \
    ULONG _NL,_DL; _NL = 0; _DL = 0;       \
    CopyUchar1(&_NL, &(EA)->EaNameLength); \
    GetEaValueLength(EA, &_DL);            \
    *(SIZE) = 1 + 1 + 2 + _NL + 1 + _DL;   \
}

#define EA_NEED_EA_FLAG                 0x80
#define MIN_EA_HANDLE                   1
#define MAX_EA_HANDLE                   30719
#define UNUSED_EA_HANDLE                0xffff
#define EA_CBLIST_OFFSET                0x1a
#define MAX_EA_BASE_INDEX               240
#define MAX_EA_OFFSET_INDEX             128

#endif
#endif // _RDBSS_