helos1/driver/filesystem/fat/fat.hpp

#pragma once

#include "../../../cppruntime/runtime.hpp"
#include "../filesystem.hpp"
#include "../../../main.h"

namespace helos {

namespace filesystem {


// FAT is a FAT12/16/32 driver.
class FAT: public Filesystem {
private:
	// Type of the FAT filesystem (FAT12, FAT16 or FAT32)
	enum FATType {
		FAT12,
		FAT16,
		FAT32,
		exFAT,
	};


	// The 1st sector of the FAT filesystem, BIOS Parameter Block and Extended Boot Record
	// Same for FAT12/16 and FAT32.
	struct BIOSParamBlock {
		char     jumpcode[3];            // EB XX 90, a jmp:short XX; nop command
		char     oemid[8];               // OEM identifier, can be any string
		uint16_t numBytesPerSector;      // number of bytes per sector (512)
		uint8_t  numSectorsPerCluster;   // number of sectors per cluster (8, 512*8=4096)
		uint16_t numReservedSector;      // number of reserved sectors, including the BPB
		uint8_t  numFATs;                // number of FATs, often 2
		uint16_t numDirEntry;            // number of directory entries
		uint16_t numSectors_short;       // total sectors in the volume, 0 if the value is too large to fit and in sectorCount_large;
		uint8_t  mediaDescriptorType;    // Media Descriptor Type
		uint16_t numSectorsPerFAT_12_16; // number of sectors per FAT, set only for FAT12/16
		uint16_t numSectorsPerTrack;     // number of sectors per track
		uint16_t numSides;               // number of heads or sides of the media
		uint32_t offsetLBA;              // number of hidden sectors (i.e., the LBA of the beginning of the partition.)
		uint32_t numSectors_large;       // large sector count, set if sectorCount_short is 0
	} PACKED;
	static_assert(sizeof(BIOSParamBlock) == 36, "BIOS Parameter Block struct not packed");


	// Extended Boot Record for FAT12/16, comes right after BPB
	struct ExtBootRecord_12_16 {
		uint8_t  driveNumber; // drive number, i.e., 0x00 for floppy and 0x80 for harddisk. Useless.
		uint8_t  ntFlags;     // flags in Windows NT, reserved and zero.
		uint8_t  signature;   // signature, must be 0x28 or 0x29.
		uint32_t volumeID;    // volume ID (partition UUID)
		char     label[11];   // label, padded with spaces
		char     type[8];     // system identifier string, containing the FAT filesystem type. Not to be trusted.
	} PACKED;
	static_assert(sizeof(ExtBootRecord_12_16) == 62 - 36, "ExtBootRecord_12_16 not packed");


	// Extended Boot Record for FAT32, comes right after BPB
	struct ExtBootRecord_32 {
		uint32_t sectorsPerFAT;        // number of sectors in per FAT
		uint16_t flags;                // flags
		uint16_t version;              // FAT version number. High byte is the major version and low byte is the minor. Can be zero.
		uint32_t clusterRoot;          // the cluster number (offset) of the root directory. Often 2.
		uint16_t sectorFSinfo;         // the sector number of the FSInfo structure
		uint16_t sectorBackupBootsect; // the sector number of the backup boot sector
		char     reserved[12];         // reserved. Should be set to zero on format.

		uint8_t  driveNumber; // drive number, i.e., 0x00 for floppy and 0x80 for harddisk. Useless.
		uint8_t  ntFlags;     // flags in Windows NT, reserved and zero.
		uint8_t  signature;   // signature, must be 0x28 or 0x29.
		uint32_t volumeID;    // volume ID (partition UUID)
		char     label[11];   // label, padded with spaces
		char     type[8];     // system identifier string, always "FAT32   " with 3 spaces. Not to be trusted.
	} PACKED;
	static_assert(sizeof(ExtBootRecord_32) == 90 - 36, "ExtBootRecord_36 not packed");


	static constexpr int FSInfo_Offset = 484;
	// FSInfo structure for FAT32, starting at byte offset 484
	struct FSInfo {
		uint32_t signatureMid;      // = 0x61417272
		uint32_t freeClusterCount;  // last known free cluster count, might be incorrect. 0xFFFFFFFF means the value is unknown and must be computed.
		uint32_t freeClusterOffset; // the cluster number at which the driver should start looking for free clusters. 0xFFFFFFFF means there is no hint and the driver should start at 2. Also might be incorrect.
		char     reserved[12];      // reserved
		uint32_t signatureTrail;    // = 0xAA550000
	} PACKED;
	static_assert(sizeof(FSInfo) == 512 - 484, "FSInfo_off484 not packed");

	static constexpr uint32_t
		FSInfo_SignatureLead  = 0x41615252, // Lead signature at the beginning of the FSInfo sector
		FSInto_SignatureMid   = 0x61417272, // Signature at offset 0x1e4
		FSInfo_SignatureTrail = 0xaa550000; // Trail signature at the end of the sector


	// Time in a Directory Entry
	struct DirEntry_Time {
		uint16_t hours : 5;        // Hours in wall time.
		uint16_t minutes : 6;      // Minutes in wall time.
		uint16_t seconds_div2 : 5; // Seconds in wall time divided by 2 (sec = div2*2 + 10th/100)
	};

	// Date in a Directory Entry
	struct DirEntry_Date {
		uint16_t year_1980 : 7; // Calendar year, offset since 1980
		uint16_t month : 4;     // Calendar month, 1-12
		uint16_t day : 5;       // Calendar day, 1-31
	};

	// Directory Entry
	struct DirEntry {
		char          name[8], ext[3];         // File name and extension (standard 8.3 format)
		uint8_t       flags;                   // Flags of the file.
		char          reserved;                // Reserved by Windows NT.
		uint8_t       createTime_Seconds_10th; // Tenths of a second, range 0-199 inclusive.
		DirEntry_Time createTime;              // Create time
		DirEntry_Date createDate;              // Create time
		DirEntry_Date lastAccessDate;          // Last access date. there are no last-access time.
		uint16_t      firstCluster_high;       // High 16 bits of the first cluster number.
		DirEntry_Time modifyTime;              // Last modify time
		DirEntry_Date modifyDate;              // Last modify date
		uint16_t      firstCluster_low;        // Low 16 bits of the first cluster number.
		uint32_t      size;                    // Size of the file in bytes
	} PACKED;
	static_assert(sizeof(DirEntry) == 32, "DirEntry not packed");

	static constexpr uint8_t
		DirEntry_Flags_ReadOnly              = 0x01, // Read-Only
		DirEntry_Flags_ReadOnly_Hidden       = 0x02, // Hidden
		DirEntry_Flags_ReadOnly_System       = 0x04, // System
		DirEntry_Flags_ReadOnly_VolumeID     = 0x08, // A Volume-ID entry, only in the root folder
		DirEntry_Flags_ReadOnly_Directory    = 0x10, // Directory
		DirEntry_Flags_ReadOnly_Archive      = 0x20, // Archive
		DirEntry_Flags_ReadOnly_LongFileName = 0x0f; // Part of a Long File Name entry

public:
	~FAT();

	// AllocateBlock allocates a new FAT driver from a block device.
	//
	// It only supports 512-byte-block devices.
	virtual Filesystem *AllocateBlock(BlockDevice *block, Config *config) override;

public:
	// Opendir opens a new directory.
	//
	// It places the cluster number of the directory into file->handle.
	virtual int Opendir(const char *path, OpenFile *file) override;

	// Readdir reads a whole directory in one go, calling the callback on each element.
	virtual int Readdir(const char *path, void *user, Readdir_Callback callback, OpenFile *file) override;

	// Closedir closes a open directory.
	//
	// Currently it does nothing.
	virtual int Closedir(const char *path, OpenFile *file) override;

private:
	// returns the next cluster number from this one, or 0 if end-of-chain
	int __NextCluster(int cluster);

	// reads a directory from a cluster number
	virtual int __Readdir(int cluster, void *user, Readdir_Callback callback);

private:
	FATType type;

	// A copy of the BPB and EBR
	BIOSParamBlock *bpb;
	union {
		ExtBootRecord_12_16 *ebr;
		ExtBootRecord_32 *   ebr32;
	};

	// A copy of the entire FAT
	// TODO change this! this takes about 1/128 of the disk size in memory (in FAT32)
	void *fat_table;
	void *sector; // A buffer at the size of a sector. Allocated on creation

	int numSectors; // Number of sectors in the entire partition.
};


} // namespace filesystem
} // namespace helos