RASCSI/cpp/devices/cfilesystem.h

//---------------------------------------------------------------------------
//
//	SCSI Target Emulator PiSCSI
//	for Raspberry Pi
//
//	Powered by XM6 TypeG Technology.
//	Copyright (C) 2016-2020 GIMONS
//	[ Host File System for the X68000 ]
//
//  Note: This functionality is specific to the X68000 operating system.
//        It is highly unlikely that this will work for other platforms.
//---------------------------------------------------------------------------

#pragma once

#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdint>
#include <cstddef>
#include <cstdio>
#include <time.h>
#include <unistd.h>

using TCHAR = char;

static const int FILEPATH_MAX = 260;

//---------------------------------------------------------------------------
//
//	Status code definitions
//
//---------------------------------------------------------------------------
static const int FS_INVALIDFUNC	=	0xFFFFFFFF;	///< Executed an invalid function
static const int FS_FILENOTFND =	0xFFFFFFFE;	///< The selected file can not be found
static const int FS_DIRNOTFND =		0xFFFFFFFD;	///< The selected directory can not be found
static const int FS_OVEROPENED =	0xFFFFFFFC;	///< There are too many files open
static const int FS_CANTACCESS =	0xFFFFFFFB;	///< Can not access the direcory or volume
static const int FS_NOTOPENED =		0xFFFFFFFA;	///< The selected handle is not opened
static const int FS_INVALIDMEM =	0xFFFFFFF9;	///< Memory management has been destroyed
static const int FS_OUTOFMEM =		0xFFFFFFF8;	///< Insufficient memory for execution
static const int FS_INVALIDPTR =	0xFFFFFFF7;	///< Selected an invalid memory management pointer
static const int FS_INVALIDENV =	0xFFFFFFF6;	///< Selected an invalid environment
static const int FS_ILLEGALFMT =	0xFFFFFFF5;	///< The exeucted file is in an invalid format
static const int FS_ILLEGALMOD =	0xFFFFFFF4;	///< Invalid open access mode
static const int FS_INVALIDPATH =	0xFFFFFFF3;	///< Mistake in selected file name
static const int FS_INVALIDPRM =	0xFFFFFFF2;	///< Called with an invalid parameter
static const int FS_INVALIDDRV =	0xFFFFFFF1;	///< Mistake in selected drive
static const int FS_DELCURDIR =		0xFFFFFFF0;	///< Unable to delete the current directory
static const int FS_NOTIOCTRL =		0xFFFFFFEF;	///< Unable to use IOCTRL with the device
static const int FS_LASTFILE =		0xFFFFFFEE;	///< Can not find any more files
static const int FS_CANTWRITE =		0xFFFFFFED;	///< Selected file can not be written
static const int FS_DIRALREADY =	0xFFFFFFEC;	///< Selected directory is already registered
static const int FS_CANTDELETE =	0xFFFFFFEB;	///< Can not delete because of a file
static const int FS_CANTRENAME =	0xFFFFFFEA;	///< Can not rename because of a file
static const int FS_DISKFULL =		0xFFFFFFE9;	///< Can not create a file because the disk is full
static const int FS_DIRFULL =		0xFFFFFFE8;	///< Can not create a file because the directory is full
static const int FS_CANTSEEK =		0xFFFFFFE7;	///< Can not seek in the selected location
static const int FS_SUPERVISOR =	0xFFFFFFE6;	///< Selected supervisor in supervisor mode
static const int FS_THREADNAME =	0xFFFFFFE5;	///< A thread with this name already exists
static const int FS_BUFWRITE =		0xFFFFFFE4;	///< Writing to inter-process communication buffers is disallowed
static const int FS_BACKGROUND =	0xFFFFFFE3;	///< Unable to start a background process
static const int FS_OUTOFLOCK =		0xFFFFFFE0;	///< Insufficient lock space
static const int FS_LOCKED =		0xFFFFFFDF;	///< Can not access because it is locked
static const int FS_DRIVEOPENED =	0xFFFFFFDE;	///< Selected drive has an open handler
static const int FS_LINKOVER =		0xFFFFFFDD;	///< The symbolic link is nested over 16 times
static const int FS_FILEEXIST =		0xFFFFFFB0;	///< The file exists

static const int FS_FATAL_MEDIAOFFLINE =	0xFFFFFFA3;	///< No media inserted
static const int FS_FATAL_WRITEPROTECT =	0xFFFFFFA2;	///< Write protected
static const int FS_FATAL_INVALIDCOMMAND =	0xFFFFFFA1;	///< Invalid command number
static const int FS_FATAL_INVALIDUNIT =	0xFFFFFFA0;	///< Invalid unit number

static const int HUMAN68K_PATH_MAX = 96;		///< Longest path allowed in Human68k

//===========================================================================
//
/// Human68k name space
//
//===========================================================================
namespace Human68k {
	/// File attribute bit
	enum attribute_t {
		AT_READONLY = 0x01,		///< Read only attribute
		AT_HIDDEN = 0x02,		///< Hidden attribute
		AT_SYSTEM = 0x04,		///< System attribute
		AT_VOLUME = 0x08,		///< Volume label attribute
		AT_DIRECTORY = 0x10,		///< Directory attribute
		AT_ARCHIVE = 0x20,		///< Archive attribute
		AT_ALL = 0xFF,			///< All attribute bits are 1
	};

	/// File open modes
	enum open_t {
		OP_READ = 0,			///< Read
		OP_WRITE = 1,			///< Write
		OP_FULL = 2,			///< Read/Write
		OP_MASK = 0x0F,			///< Decision mask
		OP_SHARE_NONE = 0x10,		///< Sharing forbidden
		OP_SHARE_READ = 0x20,		///< Read sharing
		OP_SHARE_WRITE = 0x30,		///< Write sharing
		OP_SHARE_FULL = 0x40,		///< Read/Write sharing
		OP_SHARE_MASK = 0x70,		///< Sharing decision mask
		OP_SPECIAL = 0x100,		///< Dictionary access
	};

	/// Seek types
	enum class seek_t {
		SK_BEGIN = 0,			///< From the beginning of a file
		SK_CURRENT = 1,			///< From the current location
		SK_END = 2,			///< From the end of the file
	};

	// Media byte
	const static int MEDIA_REMOTE = 0xF3;		///< Remote drive

	struct namests_t {
		uint8_t wildcard;			///< Wildcard character length
		uint8_t drive;			///< Drive number
		uint8_t path[65];			///< Path (subdirectory +/)
		uint8_t name[8];			///< File name (PADDING 0x20)
		uint8_t ext[3];			///< Extension (PADDING 0x20)
		uint8_t add[10];			///< File name addition (PADDING 0x00)

		void GetCopyPath(uint8_t* szPath) const;
		void GetCopyFilename(uint8_t* szFilename) const;
	};

	struct files_t {
		uint8_t fatr;			///< + 0 search attribute; read-only
		//		uint8_t drive;	///< + 1 drive number; read-only
		uint32_t sector;			///< + 2 directory sector; DOS _FILES first address substitute
		//		uint16_t cluster;	///< + 6 directory cluster; details unknown (unused)
		uint16_t offset;			///< + 8 directory entry; write-only
		//		uint8_t name[8];	///< +10 working file name; write-only (unused)
		//		uint8_t ext[3];	///< +18 working extension; write-only (unused)
		uint8_t attr;			///< +21 file attribute; write-only
		uint16_t time;			///< +22 last change time of day; write-only
		uint16_t date;			///< +24 last change date; write-only
		uint32_t size;			///< +26 file size; write-only
		uint8_t full[23];			///< +30 full name; write-only
	};

	struct fcb_t {
		//		uint8_t pad00[6];	///< + 0~+ 5	(unused)
		uint32_t fileptr;			///< + 6~+ 9	file pointer
		//		uint8_t pad01[4];	///< +10~+13	(unused)
		uint16_t mode;			///< +14~+15	open mode
		//		uint8_t pad02[16];	///< +16~+31	(unused)
		//		uint32_t zero;	///< +32~+35	zeros are written when opened (unused)
		//		uint8_t name[8];	///< +36~+43	file name (PADDING 0x20) (unused)
		//		uint8_t ext[3];	///< +44~+46	extension (PADDING 0x20) (unused)
		uint8_t attr;			///< +47	file attribute
		//		uint8_t add[10];	///< +48~+57	file name addition (PADDING 0x00) (unused)
		uint16_t time;			///< +58~+59	last change time of day
		uint16_t date;			///< +60~+61	last change date
		//		uint16_t cluster;	///< +62~+63	cluster number (unused)
		uint32_t size;			///< +64~+67	file size
		//		uint8_t pad03[28];	///< +68~+95	FAT cache (unused)
	};

	struct capacity_t {
		uint16_t freearea;			///< + 0	Number of available clusters
		uint16_t clusters;			///< + 2	Total number of clusters
		uint16_t sectors;			///< + 4	Number of sectors per cluster
		uint16_t bytes;			///< + 6	Number of bytes per sector
	};

	struct ctrldrive_t {
		uint8_t status;			///< +13	status
		uint8_t pad[3];			///< Padding
	};

	struct dpb_t {
		uint16_t sector_size;		///< + 0	Number of bytes in one sector
		uint8_t cluster_size;		///< + 2	Number sectors in one cluster -1
		uint8_t shift;			///< + 3	Number of cluster→sector shifts
		uint16_t fat_sector;		///< + 4	FAT first sector number
		uint8_t fat_max;			///< + 6	FAT storage quantity
		uint8_t fat_size;			///< + 7	FAT controlled sector number (excluding duplicates)
		uint16_t file_max;			///< + 8	Number of files in the root directory
		uint16_t data_sector;		///< +10	First sector number of data storage
		uint16_t cluster_max;		///< +12	Total number of clusters +1
		uint16_t root_sector;		///< +14	First sector number of root directory
		//	uint32_t driverentry;	///< +16	Device driver pointer (unused)
		uint8_t media;			///< +20	Media identifier
		//	uint8_t flag;		///< +21	Flag used by DPB (unused)
	};

	/// Directory entry struct
	struct dirent_t {
		uint8_t name[8];			///< + 0	File name (PADDING 0x20)
		uint8_t ext[3];			///< + 8	Extension (PADDING 0x20)
		uint8_t attr;			///< +11	File attribute
		uint8_t add[10];			///< +12	File name addition (PADDING 0x00)
		uint16_t time;			///< +22	Last change time of day
		uint16_t date;			///< +24	Last change date
		uint16_t cluster;			///< +26	Cluster number
		uint32_t size;			///< +28	File size
	};

	/// IOCTRL parameter union
	union ioctrl_t {
		uint8_t buffer[8];			///< Access in byte units
		uint32_t param;			///< Parameter (First 4 bytes)
		uint16_t media;			///< Media byte (First 2 bytes)
	};

	/// Command line parameter struct
	/**
	The driver itself is included in the beginning of the argument,
	so setting to a length longer than HUMAN68K_PATH_MAX
	*/
	struct argument_t {
		uint8_t buf[256];			///< Command line argument
	};
}

/// Number of FILES buffers
/**
Under normal circumstances it's enough with just a few buffers,
but Human68k multitasking may lead to multiple threads working
deeply in the system, which is why this value is set this high.

Default is 20 buffers.
*/
static const int XM6_HOST_FILES_MAX = 20;

/// Number of FCB buffers
/**
This decides how many files can be opened at the same time.

Default is 100 files.
*/
static const int XM6_HOST_FCB_MAX = 100;

/// Max number of virtual clusters and sectors
/**
Number of virtual sectors used for accessing the first sector of a file entity.
Allocating a generous amount to exceed the number of threads lzdsys uses for access.

Default is 10 sectors.
*/
static const int XM6_HOST_PSEUDO_CLUSTER_MAX = 10;

/// Number of caches for directory entries
/**
Human68k carries out a large number of checks of directory entries when doing an operation
inside a subdirectory. This specifies the number of caches used to speed up this operation.
Cache is allocated per drive. The more you add the faster it gets, but use too many
and the host OS gets under a heavy load, so be careful.

Default is 16.
*/
static const int XM6_HOST_DIRENTRY_CACHE_MAX = 16;

/// Max number of entries that can be stored per directory
/**
When a large number of files are stored in a directory, a larger amount of data than
contemporanous applications can handle will be returned. This may lead to errors such as
partial data being recognized, performance dropping significantly, or OOM crashes.
To guard against this, an upper limit is defined here. In the case of a particular
file manager, the upper limit is 2560 files. This is one good example to use as reference.

Default is around 60000 entries. (Upper limit of the FAT root directory)
*/
static const int XM6_HOST_DIRENTRY_FILE_MAX	= 65535;

/// Max number of patterns for file name deduplication
/**
The file names on the Human68k side are automatically created based on the file system on
the host side. However, Human68k have stricter file name length restrictions than the host has.
Because of this, there is a risk that file name duplication will occur. When this happens,
WindrvXM will use a certain renaming heuristic to generate alternate file names to resolve
the duplication. Theoretically, there are over 60 million (36^5) unique file names that
can be generated by this method. However, in reality any more than a few hundred
deduplications will take excessive processing time. So here an upper limit to deduplication
is set in order to maintain system performance. If a system is operated with common sense,
you should only need a few dozen deduplication patterns, so this value can be kept low
to further improve performance. In the case deduplication is not carried out, multiple files
with the same name will be created. When trying to access such files,
only the first entry will ever be accessed.

Default is 36 patterns.
*/
static const int XM6_HOST_FILENAME_PATTERN_MAX = 36;

/// Duplicate file identification mark
/**
A symbol used to distinguish between host and Human68k files.
Do not use a command shell escape character, or similar protected symbol.

Default is '@'.
*/
static const char XM6_HOST_FILENAME_MARK = '@';

/// WINDRV operational flags
/**
Normally set to 0. When put in the OS trash can for deletion, it is set to 1.
Other values are reserved for future use.
Can be used for future extentions such as internal operational flags or mock media byte.
*/
enum {
	WINDRV_OPT_REMOVE =		0x00000001,	///< Bit 0: File delete process			0:Directly 1:Trash can
	WINDRV_OPT_ALPHABET =		0x00000020,	///< Bit 5: File name comparison; Alphabet distinction		0:No 1:Yes	0:-C 1:+C
	WINDRV_OPT_COMPARE_LENGTH =	0x00000040,	///< Bit 6: File name comparison; String length (unimplemented)	0:18+3 1:8+3	0:+T 1:-T
	WINDRV_OPT_CONVERT_LENGTH =	0x00000080,	///< Bit 7: File name conversion; String length		0:18+3 1:8+3	0:-A 1:+A
	WINDRV_OPT_CONVERT_SPACE =	0x00000100,	///< Bit 8: File name conversion; Space		0:No 1:'_'
	WINDRV_OPT_CONVERT_BADCHAR =	0x00000200,	///< Bit 9: File name conversion; Invalid char		0:No 1:'_'
	WINDRV_OPT_CONVERT_HYPHENS =	0x00000400,	///< Bit10: File name conversion; Middle hyphen	0:No 1:'_'
	WINDRV_OPT_CONVERT_HYPHEN =	0x00000800,	///< Bit11: File name conversion; Initial hyphen	0:No 1:'_'
	WINDRV_OPT_CONVERT_PERIODS =	0x00001000,	///< Bit12: File name conversion; Middle period	0:No 1:'_'
	WINDRV_OPT_CONVERT_PERIOD =	0x00002000,	///< Bit13: File name conversion; Initial period	0:No 1:'_'
	WINDRV_OPT_REDUCED_SPACE =	0x00010000,	///< Bit16: File name reduction; Space		0:No 1:Reduced
	WINDRV_OPT_REDUCED_BADCHAR =	0x00020000,	///< Bit17: File name reduction; Invalid char		0:No 1:Reduced
	WINDRV_OPT_REDUCED_HYPHENS =	0x00040000,	///< Bit18: File name reduction Middle hyphen	0:No 1:Reduced
	WINDRV_OPT_REDUCED_HYPHEN =	0x00080000,	///< Bit19: File name reduction Initial hyphen	0:No 1:Reduced
	WINDRV_OPT_REDUCED_PERIODS =	0x00100000,	///< Bit20: File name reduction Middle period	0:No 1:Reduced
	WINDRV_OPT_REDUCED_PERIOD =	0x00200000,	///< Bit21: File name reduction Initial period	0:No 1:Reduced
	// Bit24～30 Duplicate file identification mark			0:Automatic 1～127:Chars
};

/// File system operational flag
/**
Normal is 0. Becomes 1 if attempting to mount in read-only mode.
Reserving the other values for future use.
Insurance against hard-to-detect devices such as homemade USB storage.
*/
static const uint32_t FSFLAG_WRITE_PROTECT = 0x00000001;	///< Bit0: Force write protect

//===========================================================================
//
/// Full ring list
///
/// First (root.next) is the most recent object.
/// Last (root.prev) is the oldest / unused object.
/// For code optimization purposes, always upcast the pointer when deleting.
//
//===========================================================================
class CRing {
public:
	CRing() { Init(); }
	~CRing() { Remove(); }
	CRing(CRing&) = default;
	CRing& operator=(const CRing&) = default;

	void  Init() { next = prev = this; }

	CRing*  Next() const { return next; }			///< Get the next element
	CRing*  Prev() const { return prev; }			///< Get the previous element

	void  Insert(CRing* pRoot)
	{
			// Separate the relevant objects
		assert(next);
		assert(prev);
		next->prev = prev;
		prev->next = next;
		// Insert into the beginning of the ring
		assert(pRoot);
		assert(pRoot->next);
		next = pRoot->next;
		prev = pRoot;
		pRoot->next->prev = this;
		pRoot->next = this;
	}
										///< Separate objects & insert into the beginning of the ring

	void  InsertTail(CRing* pRoot)
	{
			// Separate the relevant objects
		assert(next);
		assert(prev);
		next->prev = prev;
		prev->next = next;
		// Insert into the end of the ring
		assert(pRoot);
		assert(pRoot->prev);
		next = pRoot;
		prev = pRoot->prev;
		pRoot->prev->next = this;
		pRoot->prev = this;
	}
										///< Separate objects & insert into the end of the ring

	void  InsertRing(CRing* pRoot)
	{
			if (next == prev) return;

		// Insert into the beginning of the ring
		assert(pRoot);
		assert(pRoot->next);
		pRoot->next->prev = prev;
		prev->next = pRoot->next;
		pRoot->next = next;
		next->prev = pRoot;

		// Empty self
		next = prev = this;
	}
										///< Separate objects except self & insert into the beginning of the ring

	void  Remove()
	{
			// Separate the relevant objects
		assert(next);
		assert(prev);
		next->prev = prev;
		prev->next = next;
		// To be safe, assign self (nothing stops you from separating any number of times)
		next = prev = this;
	}
										///< Separate objects

private:
	CRing* next;						///< Next element
	CRing* prev;						///< Previous element
};

//===========================================================================
//
/// Directory Entry: File Name
//
//===========================================================================
class CHostFilename {
public:
	CHostFilename() = default;
	~CHostFilename() = default;

	static size_t Offset() { return offsetof(CHostFilename, m_szHost); }	///< Get offset location

	void SetHost(const TCHAR* szHost);					///< Set the name of the host
	const TCHAR* GetHost() const { return m_szHost; }	///< Get the name of the host
	void ConvertHuman(int nCount = -1);					///< Convert the Human68k name
	void CopyHuman(const uint8_t* szHuman);					///< Copy the Human68k name
	bool isReduce() const;							///< Inspect if the Human68k name is generated
	bool isCorrect() const { return m_bCorrect; }		///< Inspect if the Human68k file name adhers to naming rules
	const uint8_t* GetHuman() const { return m_szHuman; }	///< Get Human68k file name
	const uint8_t* GetHumanLast() const
	{ return m_pszHumanLast; }				///< Get Human68k file name
	const uint8_t* GetHumanExt() const { return m_pszHumanExt; }///< Get Human68k file name
	void SetEntryName();							///< Set Human68k directory entry
	void SetEntryAttribute(uint8_t nHumanAttribute)
	{ m_dirHuman.attr = nHumanAttribute; }			///< Set Human68k directory entry
	void  SetEntrySize(uint32_t nHumanSize)
	{ m_dirHuman.size = nHumanSize; }				///< Set Human68k directory entry
	void SetEntryDate(uint16_t nHumanDate)
	{ m_dirHuman.date = nHumanDate; }				///< Set Human68k directory entry
	void SetEntryTime(uint16_t nHumanTime)
	{ m_dirHuman.time = nHumanTime; }				///< Set Human68k directory entry
	void SetEntryCluster(uint16_t nHumanCluster)
	{ m_dirHuman.cluster = nHumanCluster; }			///< Set Human68k directory entry
	const Human68k::dirent_t*  GetEntry() const
	{ return &m_dirHuman; }					///< Get Human68k directory entry
	int CheckAttribute(uint32_t nHumanAttribute) const;			///< Determine Human68k directory entry attributes
	bool isSameEntry(const Human68k::dirent_t* pdirHuman) const
	{ assert(pdirHuman); return memcmp(&m_dirHuman, pdirHuman, sizeof(m_dirHuman)) == 0; }
										///< Determine Human68k directory entry match

	// Path name operations
	static const uint8_t* SeparateExt(const uint8_t* szHuman);			///< Extract extension from Human68k file name

private:
	static uint8_t* CopyName(uint8_t* pWrite, const uint8_t* pFirst, const uint8_t* pLast);
										///< Copy Human68k file name elements

	const uint8_t* m_pszHumanLast = nullptr;		///< Last position of the Human68k internal name of the relevant entry
	const uint8_t* m_pszHumanExt = nullptr;		///< Position of the extension of the Human68k internal name of the relevant entry
	bool m_bCorrect = false;			///< TRUE if the relevant entry of the Human68k internal name is correct
	uint8_t m_szHuman[24];			///< Human68k internal name of the relevant entry
	Human68k::dirent_t m_dirHuman;		///< All information for the Human68k relevant entry
	TCHAR m_szHost[FILEPATH_MAX];		///< The host name of the relevant entry (variable length)
};

//===========================================================================
//
/// Directory entry: path name
///
/// A file path in Human68k always begings with / and ends with /
/// They don't hold unit numbers.
/// Include the base path part of the name on the host side for a performance boost.
//
//===========================================================================
/** @note
Most Human68k applications are written in a way that expects time stamps not to
get updated for new directories created as a result of file operations, which
triggers updates to directory entires.
However, on the host file system, new directories do typically get an updated time stamp.

The unfortunate outcome is that when copying a directory for instance, the time stamp
will get overwritten even if the application did not intend for the time stamp to get updated.

Here follows an implementation of a directory cache FAT time stamp  emulation feature.
At the time of a file system update on the host side, time stamp information will be restored
in order to achieve expected behavior on the Human68k side.
*/
class CHostPath: public CRing {
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFilename f;
	};

public:
	/// Search buffer
	struct find_t {
		uint32_t count;			///< Search execution count + 1 (When 0 the below value is invalid)
		uint32_t id;			///< Entry unique ID for the path of the next search
		const ring_t* pos;		///< Position of the next search (When identical to unique ID)
		Human68k::dirent_t entry;	///< Contents of the next seach entry

		void  Clear() { count = 0; }	///< Initialize
	};

	CHostPath() = default;
	~CHostPath();
	CHostPath(CHostPath&) = default;
	CHostPath& operator=(const CHostPath&) = default;

	void Clean();								///< Initialialize for reuse

	void SetHuman(const uint8_t* szHuman);					///< Directly specify the name on the Human68k side
	void SetHost(const TCHAR* szHost);					///< Directly specify the name on the host side
	bool isSameHuman(const uint8_t* szHuman) const;				///< Compare the name on the Human68k side
	bool isSameChild(const uint8_t* szHuman) const;				///< Compare the name on the Human68k side
	const TCHAR* GetHost() const { return m_szHost; }	///< Obtain the name on the host side
	const CHostFilename* FindFilename(const uint8_t* szHuman, uint32_t nHumanAttribute = Human68k::AT_ALL) const;
										///< Find file name
	const CHostFilename* FindFilenameWildcard(const uint8_t* szHuman, uint32_t nHumanAttribute, find_t* pFind) const;
										///< Find file name (with support for wildcards)
	bool isRefresh() const;							///< Check that the file change has been done
	void Refresh();							///< Refresh file
	void Backup();								/// Backup the time stamp on the host side
	void Restore() const;							/// Restore the time stamp on the host side
	void Release();							///< Update

	// CHostEntry is an external API that we use
	static void InitId() { g_nId = 0; }					///< Initialize the counter for the unique ID generation

private:
	static ring_t* Alloc(size_t nLength);					///< Allocate memory for the file name
	static void Free(ring_t* pRing);					///< Release memory for the file name
	static int Compare(const uint8_t* pFirst, const uint8_t* pLast, const uint8_t* pBufFirst, const uint8_t* pBufLast);
										///< Compare string (with support for wildcards)

	CRing m_cRing;								///< For CHostFilename linking
	time_t m_tBackup = 0;					///< For time stamp restoration
	bool m_bRefresh = true;						///< Refresh flag
	uint32_t m_nId = 0;								///< Unique ID (When the value has changed, it means an update has been made)
	uint8_t m_szHuman[HUMAN68K_PATH_MAX];					///< The internal Human68k name for the relevant entry
	TCHAR m_szHost[FILEPATH_MAX];						///< The host side name for the relevant entry

	static uint32_t g_nId;							///< Counter for the unique ID generation
};

//===========================================================================
//
/// File search processing
///
/// It's pretty much impossible to process Human68k file names as Unicode internally.
/// So, we carry out binary conversion for processing. We leave it up to the
/// directory entry cache to handle the conversion, which allows WINDRV to read
/// everything as Shift-JIS. Additionally, it allows Human68k names to be
/// fully independent of base path assignments.
///
/// We create directory entry cache just before file handling.
/// Since creating directory entires is very costly, we try to reuse created entries
/// as much as humanly possible.
///
/// There are three kinds of file search. They are all processed in CHostFiles::Find()
/// 1. Search by path name only; the only attribute is 'directory'; _CHKDIR _CREATE
/// 2. Path + file name + attribute search; _OPEN
/// 3. Path + wildcard + attribute search; _FILES _NFILES
/// The search results are kept as directory entry data.
//
//===========================================================================
class CHostFiles {
public:
	CHostFiles() = default;
	~CHostFiles() = default;

	void Init();

	void SetKey(uint32_t nKey) { m_nKey = nKey; }			///< Set search key
	bool isSameKey(uint32_t nKey) const { return m_nKey == nKey; }	///< Compare search key
	void SetPath(const Human68k::namests_t* pNamests);				///< Create path and file name internally
	bool isRootPath() const { return m_szHumanPath[1] == '\0'; }			///< Check if root directory
	void SetPathWildcard() { m_nHumanWildcard = 1; }				///< Enable file search using wildcards
	void SetPathOnly() { m_nHumanWildcard = 0xFF; }				///< Enable only path names
	bool isPathOnly() const { return m_nHumanWildcard == 0xFF; }			///< Check if set to only path names
	void SetAttribute(uint32_t nHumanAttribute) { m_nHumanAttribute = nHumanAttribute; }	///< Set search attribute
	bool Find(uint32_t nUnit, const class CHostEntry* pEntry);				///< Find files on the Human68k side, generating data on the host side
	const CHostFilename* Find(const CHostPath* pPath);					///< Find file name
	void SetEntry(const CHostFilename* pFilename);					///< Store search results on the Human68k side
	void SetResult(const TCHAR* szPath);						///< Set names on the host side
	void AddResult(const TCHAR* szPath);						///< Add file name to the name on the host side
	void AddFilename();								///< Add the new Human68k file name to the name on the host side

	const TCHAR* GetPath() const { return m_szHostResult; }		///< Get the name on the host side

	const Human68k::dirent_t* GetEntry() const { return &m_dirHuman; }///< Get Human68k directory entry

	uint32_t GetAttribute() const { return m_dirHuman.attr; }		///< Get Human68k attribute
	uint16_t GetDate() const { return m_dirHuman.date; }			///< Get Human68k date
	uint16_t GetTime() const { return m_dirHuman.time; }			///< Get Human68k time
	uint32_t GetSize() const { return m_dirHuman.size; }		///< Get Human68k file size
	const uint8_t* GetHumanFilename() const { return m_szHumanFilename; }///< Get Human68k file name
	const uint8_t* GetHumanResult() const { return m_szHumanResult; }	///< Get Human68k file name search results
	const uint8_t* GetHumanPath() const { return m_szHumanPath; }	///< Get Human68k path name

private:
	uint32_t m_nKey = 0;						///< FILES buffer address for Human68k; 0 is unused
	uint32_t m_nHumanWildcard = 0;				///< Human68k wildcard data
	uint32_t m_nHumanAttribute = 0;			///< Human68k search attribute
	CHostPath::find_t m_findNext = {};		///< Next search location data
	Human68k::dirent_t m_dirHuman = {};		///< Search results: Human68k file data
	uint8_t m_szHumanFilename[24] = {};		///< Human68k file name
	uint8_t m_szHumanResult[24] = {};			///< Search results: Human68k file name
	uint8_t m_szHumanPath[HUMAN68K_PATH_MAX] = {};	///< Human68k path name
	TCHAR m_szHostResult[FILEPATH_MAX] = {};	///< Search results: host's full path name
};

//===========================================================================
//
/// File search memory manager
//
//===========================================================================
class CHostFilesManager {
public:
#ifdef _DEBUG
	~CHostFilesManager();
#endif	// _DEBUG
	void  Init();						///< Initialization (when the driver is installed)
	void  Clean();						///< Release (when starting up or resetting)

	CHostFiles*  Alloc(uint32_t nKey);
	CHostFiles*  Search(uint32_t nKey);
	void  Free(CHostFiles* pFiles);
private:
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFiles f;
	};

	CRing m_cRing;						///< For attaching to CHostFiles
};

//===========================================================================
//
/// FCB processing
//
//===========================================================================
class CHostFcb {
public:
	CHostFcb() = default;
	~CHostFcb() { Close(); }
	CHostFcb(CHostFcb&) = default;
	CHostFcb& operator=(const CHostFcb&) = default;

	void Init();

	void SetKey(uint32_t nKey) { m_nKey = nKey; }			///< Set search key
	bool isSameKey(uint32_t nKey) const { return m_nKey == nKey; }	///< Compare search key
	void SetUpdate() { m_bUpdate = true; }				///< Update
	bool isUpdate() const { return m_bUpdate; }			///< Get update state
	bool SetMode(uint32_t nHumanMode);						///< Set file open mode
	void SetFilename(const TCHAR* szFilename);					///< Set file name
	void SetHumanPath(const uint8_t* szHumanPath);					///< Set Human68k path name
	const uint8_t* GetHumanPath() const { return m_szHumanPath; }	///< Get Human68k path name

	bool Create(uint32_t nHumanAttribute, bool bForce);	///< Create file
	bool Open();									///< Open file
	uint32_t Read(uint8_t* pBuffer, uint32_t nSize);					///< Read file
	uint32_t Write(const uint8_t* pBuffer, uint32_t nSize);					///< Write file
	bool Truncate() const;								///< Truncate file
	uint32_t Seek(uint32_t nOffset, Human68k::seek_t nHumanSeek);		///< Seek file
	bool TimeStamp(uint32_t nHumanTime) const;						///< Set file time stamp
	void Close();									///< Close file

private:
	uint32_t m_nKey = 0;								///< Human68k FCB buffer address (0 if unused)
	bool m_bUpdate = false;							///< Update flag
	FILE* m_pFile = nullptr;						///< Host side file object
	const char* m_pszMode = nullptr;				///< Host side file open mode
	bool m_bFlag = false;							///< Host side file open flag
	uint8_t m_szHumanPath[HUMAN68K_PATH_MAX] = {};		///< Human68k path name
	TCHAR m_szFilename[FILEPATH_MAX] = {};			///< Host side file name
};

//===========================================================================
//
/// FCB processing manager
//
//===========================================================================
class CHostFcbManager {
public:
	#ifdef _DEBUG
	~CHostFcbManager();
	#endif	// _DEBUG
	void  Init();								///< Initialization (when the driver is installed)
	void  Clean() const;						///< Release (when starting up or resetting)

	CHostFcb*  Alloc(uint32_t nKey);
	CHostFcb*  Search(uint32_t nKey);
	void  Free(CHostFcb* p);

private:
	/// For memory management
	struct ring_t {
		CRing r;
		CHostFcb f;
	};

	CRing m_cRing;								///< For attaching to CHostFcb
};

//===========================================================================
//
/// Host side drive
///
/// Keeps the required data for each drive, managed in CHostEntry.
//
//===========================================================================
class CHostDrv
{
public:
	CHostDrv() = default;
	~CHostDrv();
	CHostDrv(CHostDrv&) = default;
	CHostDrv& operator=(const CHostDrv&) = default;

	void Init(const TCHAR* szBase, uint32_t nFlag);				///< Initialization (device startup and load)

	bool isWriteProtect() const { return m_bWriteProtect; }
	bool isEnable() const { return m_bEnable; }		///< Is it accessible?
	bool isMediaOffline() const;
	uint8_t GetMediaByte() const;
	uint32_t GetStatus() const;
	void SetEnable(bool);						///< Set media status
	bool CheckMedia();							///< Check if media was changed
	void Update();								///< Update media status
	void Eject();
	void GetVolume(TCHAR* szLabel);					///< Get volume label
	bool GetVolumeCache(TCHAR* szLabel) const;				///< Get volume label from cache
	uint32_t GetCapacity(Human68k::capacity_t* pCapacity);
	bool GetCapacityCache(Human68k::capacity_t* pCapacity) const;		///< Get capacity from cache

	// Cache operations
	void CleanCache() const;							///< Update all cache
	void CleanCache(const uint8_t* szHumanPath);				///< Update cache for the specified path
	void CleanCacheChild(const uint8_t* szHumanPath) const;	///< Update all cache below the specified path
	void DeleteCache(const uint8_t* szHumanPath);				///< Delete the cache for the specified path
	CHostPath* FindCache(const uint8_t* szHuman);				///< Inspect if the specified path is cached
	CHostPath* CopyCache(CHostFiles* pFiles);				///< Acquire the host side name on the basis of cache information
	CHostPath* MakeCache(CHostFiles* pFiles);				///< Get all required data to construct a host side name
	bool Find(CHostFiles* pFiles);						///< Find host side name (path + file name (can be abbreviated) + attribute)

private:
	// Path name operations
	static const uint8_t*  SeparateCopyFilename(const uint8_t* szHuman, uint8_t* szBuffer);
										///< Split and copy the first element of the Human68k full path name

	/// For memory management
	struct ring_t {
		CRing r;
		CHostPath f;
	};

	bool m_bWriteProtect = false;						///< TRUE if write-protected
	bool m_bEnable = false;							///< TRUE if media is usable
	uint32_t m_nRing = 0;							///< Number of stored path names
	CRing m_cRing;							///< For attaching to CHostPath
	Human68k::capacity_t m_capCache;				///< Sector data cache: if "sectors == 0" then not cached
	bool m_bVolumeCache = false;						///< TRUE if the volume label has been read
	TCHAR m_szVolumeCache[24] = {};					///< Volume label cache
	TCHAR m_szBase[FILEPATH_MAX] = {};					///< Base path
};

//===========================================================================
//
/// Directory entry management
//
//===========================================================================
class CHostEntry {

public:

	/// Max number of drive candidates
	static const int DRIVE_MAX = 10;

	CHostEntry() = default;
	~CHostEntry();
	CHostEntry(CHostEntry&) = default;
	CHostEntry& operator=(const CHostEntry&) = default;

	void Init() const;							///< Initialization (when the driver is installed)
	void Clean();								///< Release (when starting up or resetting)

	// Cache operations
	void CleanCache() const;							///< Update all cache
	void CleanCache(uint32_t nUnit) const;						///< Update cache for the specified unit
	void CleanCache(uint32_t nUnit, const uint8_t* szHumanPath) const;	///< Update cache for the specified path
	void CleanCacheChild(uint32_t nUnit, const uint8_t* szHumanPath) const;	///< Update cache below the specified path
	void DeleteCache(uint32_t nUnit, const uint8_t* szHumanPath) const;	///< Delete cache for the specified path
	bool Find(uint32_t nUnit, CHostFiles* pFiles) const;				///< Find host side name (path + file name (can be abbreviated) + attribute)
	void ShellNotify(uint32_t nEvent, const TCHAR* szPath);			///< Notify status change in the host side file system

	// Drive object operations
	void SetDrv(uint32_t nUnit, CHostDrv* pDrv);
	bool isWriteProtect(uint32_t nUnit) const;
	bool isEnable(uint32_t nUnit) const;					///< Is it accessible?
	bool isMediaOffline(uint32_t nUnit) const;
	uint8_t GetMediaByte(uint32_t nUnit) const;
	uint32_t GetStatus(uint32_t nUnit) const;					///< Get drive status
	bool CheckMedia(uint32_t nUnit) const;						///< Media change check
	void Eject(uint32_t nUnit) const;
	void GetVolume(uint32_t nUnit, TCHAR* szLabel) const;				///< Get volume label
	bool GetVolumeCache(uint32_t nUnit, TCHAR* szLabel) const;		///< Get volume label from cache
	uint32_t GetCapacity(uint32_t nUnit, Human68k::capacity_t* pCapacity) const;
	bool GetCapacityCache(uint32_t nUnit, Human68k::capacity_t* pCapacity) const;		///< Get cluster size from cache

private:

	CHostDrv* m_pDrv[DRIVE_MAX] = {};				///< Host side drive object
	uint32_t m_nTimeout = 0;							///< Last time a timeout check was carried out
};

//===========================================================================
//
/// Host side file system
//
//===========================================================================
/** @note
Current state of affairs:

While it violates the design philosophy of XM6, we should find a way for
'class Windrv' and 'class CWindrv' to have a direct pointer to 'class CFileSys'.
This way, we get the following benefits.

Benefit no. 1
Makes it possible to manage a large number of command handler methods in one place.
There is a high chance the command handlers will change drastically because of
host system architectural changes, so we will save a huge amount of maintenance work
in the long run.

Benefit no. 2
We would get rid of virtual funcion code for processing table creation and lookup.
It is not feasible to implement code in XM6 for simultaneous use of file system objects.
Therefore file system object polymorphism is a waste of CPU cycles.

I made the change as an experiment. Performance did improve.
The improvement was obvious from looking at the source the compiler spit out
after changing the FILESYS_FAST_STRUCTURE value in windrv.h.
You may understand now why I decided to rant here.

The easy solution is to put the content of 'class CFileSys' into 'class CWindrv'.
(To be honest, I really want to deprecate 'class CHost'... I wonder if there's a good way...)
*/
class CFileSys
{
public:
	CFileSys() = default;
	virtual ~CFileSys() = default;

	void Reset();								///< Reset (close all)
	void Init();								///< Initialization (device startup and load)

	// Command handlers
	uint32_t InitDevice(const Human68k::argument_t* pArgument);		///< $40 - Device startup
	int CheckDir(uint32_t nUnit, const Human68k::namests_t* pNamests) const;		///< $41 - Directory check
	int MakeDir(uint32_t nUnit, const Human68k::namests_t* pNamests) const;		///< $42 - Create directory
	int RemoveDir(uint32_t nUnit, const Human68k::namests_t* pNamests) const;	///< $43 - Delete directory
	int Rename(uint32_t nUnit, const Human68k::namests_t* pNamests, const Human68k::namests_t* pNamestsNew) const;
										///< $44 - Change file name
	int Delete(uint32_t nUnit, const Human68k::namests_t* pNamests) const;		///< $45 - Delete file
	int Attribute(uint32_t nUnit, const Human68k::namests_t* pNamests, uint32_t nHumanAttribute) const;
										///< $46 - Get / set file attribute
	int Files(uint32_t nUnit, uint32_t nKey, const Human68k::namests_t* pNamests, Human68k::files_t* pFiles);
										///< $47 - Find file
	int NFiles(uint32_t nUnit, uint32_t nKey, Human68k::files_t* pFiles);		///< $48 - Find next file
	int Create(uint32_t nUnit, uint32_t nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb, uint32_t nHumanAttribute, bool bForce);
										///< $49 - Create file
	int Open(uint32_t nUnit, uint32_t nKey, const Human68k::namests_t* pNamests, Human68k::fcb_t* pFcb);
										///< $4A - Open file
	int Close(uint32_t nUnit, uint32_t nKey, const Human68k::fcb_t* pFcb);		///< $4B - Close file
	int Read(uint32_t nKey, Human68k::fcb_t* pFcb, uint8_t* pAddress, uint32_t nSize);
										///< $4C - Read file
	int Write(uint32_t nKey, Human68k::fcb_t* pFcb, const uint8_t* pAddress, uint32_t nSize);
										///< $4D - Write file
	int Seek(uint32_t nKey, Human68k::fcb_t* pFcb, uint32_t nSeek, int nOffset);	///< $4E - Seek file
	uint32_t TimeStamp(uint32_t nUnit, uint32_t nKey, Human68k::fcb_t* pFcb, uint32_t nHumanTime);
										///< $4F - Get / set file timestamp
	int GetCapacity(uint32_t nUnit, Human68k::capacity_t* pCapacity) const;		///< $50 - Get capacity
	int CtrlDrive(uint32_t nUnit, Human68k::ctrldrive_t* pCtrlDrive) const;		///< $51 - Inspect / control drive status
	int GetDPB(uint32_t nUnit, Human68k::dpb_t* pDpb) const;				///< $52 - Get DPB
	int DiskRead(uint32_t nUnit, uint8_t* pBuffer, uint32_t nSector, uint32_t nSize);	///< $53 - Read sectors
	int DiskWrite(uint32_t nUnit) const;						///< $54 - Write sectors
	int Ioctrl(uint32_t nUnit, uint32_t nFunction, Human68k::ioctrl_t* pIoctrl);	///< $55 - IOCTRL
	int Flush(uint32_t nUnit) const;							///< $56 - Flush
	int CheckMedia(uint32_t nUnit) const;						///< $57 - Media change check
	int Lock(uint32_t nUnit) const;							///< $58 - Lock

	void SetOption(uint32_t nOption);						///< Set option
	uint32_t GetOption() const { return m_nOption; }		///< Get option
	uint32_t GetDefault() const { return m_nOptionDefault; }	///< Get default options
	static uint32_t GetFileOption() { return g_nOption; }			///< Get file name change option

	static const int DriveMax = CHostEntry::DRIVE_MAX;			///< Max number of drive candidates

private:
	void InitOption(const Human68k::argument_t* pArgument);
	bool FilesVolume(uint32_t nUnit, Human68k::files_t* pFiles) const;		///< Get volume label

	uint32_t m_nUnits = 0;								///< Number of current drive objects (Changes for every resume)

	uint32_t m_nOption = 0;							///< Current runtime flag
	uint32_t m_nOptionDefault = 0;						///< Runtime flag at reset

	uint32_t m_nDrives = 0;							///< Number of candidates for base path status restoration (scan every time if 0)

	uint32_t m_nKernel = 0;							///< Counter for kernel check
	uint32_t m_nKernelSearch = 0;						///< Initial address for NUL device

	uint32_t m_nHostSectorCount = 0;					///< Virtual sector identifier

	CHostFilesManager m_cFiles;						///< File search memory
	CHostFcbManager m_cFcb;							///< FCB operation memory
	CHostEntry m_cEntry;							///< Drive object and directory entry

	uint32_t m_nHostSectorBuffer[XM6_HOST_PSEUDO_CLUSTER_MAX];
										///< Entity that the virtual sector points to

	uint32_t m_nFlag[DriveMax] = {};					///< Candidate runtime flag for base path restoration
	TCHAR m_szBase[DriveMax][FILEPATH_MAX] = {};	///< Candidate for base path restoration
	static uint32_t g_nOption;							///< File name change flag
};