Return to Unit Reference
Description
Ultibo FileSystem interface unit
Numbering of Devices, Partitions, Volumes, Drives etc
Example:
Machine with 2 Floppy drives, 2 Fixed drives
Fixed Drive 1 has 2 Partitions (1 Primary and 1 Extended)
Fixed Drive 2 has 1 Partition (1 Primary)
\Floppy0 = Device 00h/Partition 0
\Floppy1 = Device 01h/Partition 0
\Harddisk0\Partition1 = Device 80h/Partition 1
\Harddisk0\Extended1 = Device 80h/Extended 1
\Harddisk0\Partition2 = Device 80h/Partition 2
\Harddisk1\Partition1 = Device 81h/Partition 1
\Volume1 = \Floppy0
\Volume2 = \Floppy1
\Volume3 = \Harddisk0\Partition1
\Volume4 = \Harddisk1\Partition1
\Volume5 = \Harddisk0\Partition2
A: = \Volume1
B: = \Volume2
C: = \Volume3 (Alternate Name = \HarddiskVolume1)
D: = \Volume4 (Alternate Name = \HarddiskVolume2)
E: = \Volume5 (Alternate Name = \HarddiskVolume3)
Constants
[Expand]
FileSystem specific constants FILESYS_*
FILESYS_LOGGING_DESCRIPTION = 'Filesystem Logging';
|
|
|
|
FILESYS_STORAGE_TIMER_INTERVAL = 500;
|
|
[Expand]
FileSystem lock state FILESYS_LOCK_*
FILESYS_LOCK_NONE = 0;
|
|
FILESYS_LOCK_READ = 1;
|
|
FILESYS_LOCK_WRITE = 2;
|
|
FILESYS_LOCK_AUTO = 3;
|
Not intended for use in all situations, use with extreme caution.
|
[Expand]
FileSystem cache FILESYS_CACHE_*
FILESYS_CACHE_THREAD_NAME = 'Filesystem Cache';
|
Thread name for Filesystem cache threads
|
FILESYS_CACHE_THREAD_PRIORITY = THREAD_PRIORITY_HIGHER;
|
Thread priority for Filesystem cache threads
|
|
|
FILESYS_CACHE_TIMER_INTERVAL = 50;
|
50ms timer interval for Filesystem cache
|
FILESYS_CACHE_FLUSH_TIMEOUT = 3000;
|
Filesystem cache flush timeout 3 seconds
|
FILESYS_CACHE_DISCARD_TIMEOUT = 180000;
|
Filesystem cache discard timeout 3 minutes
|
[Expand]
FileSystem entry timer FILESYS_ENTRY_*
FILESYS_ENTRY_TIMER_INTERVAL = 1000;
|
1000ms timer interval for Filesystem entries
|
FILESYS_ENTRY_DELETE_TIMEOUT = 30000;
|
Filesystem entry delete timeout 30 seconds
|
[Expand]
FileSystem cache timer CACHE_TIMER_*
CACHE_TIMER_KEY_NONE = TIMER_KEY_NONE;
|
|
CACHE_TIMER_KEY_MAX = TIMER_KEY_MAX;
|
|
CACHE_TIMER_KEY_MIN = TIMER_KEY_MIN;
|
|
[Expand]
FileSystem entry timer key ENTRY_TIMER_KEY_*
ENTRY_TIMER_KEY_NONE = TIMER_KEY_NONE;
|
|
ENTRY_TIMER_KEY_MAX = TIMER_KEY_MAX;
|
|
ENTRY_TIMER_KEY_MIN = TIMER_KEY_MIN;
|
|
[Expand]
FileSystem partition, device and volume *_PARTITION, *_DEVICE, *_VOLUME
MIN_FLOPPY_DEVICE = $00;
|
|
MAX_FLOPPY_DEVICE = $7F;
|
|
|
|
MIN_FIXED_DEVICE = $80;
|
|
MAX_FIXED_DEVICE = $FF;
|
Extends over CDROM/Other
|
|
|
MIN_CDROM_DEVICE = $E0;
|
|
MAX_CDROM_DEVICE = $EF;
|
|
|
|
MIN_OTHER_DEVICE = $F0;
|
|
MAX_OTHER_DEVICE = $FF;
|
|
|
|
INVALID_PARTITION = -1;
|
|
INVALID_DEVICE = -1;
|
|
INVALID_VOLUME = 0;
|
|
|
|
MIN_PARTITION = 0;
|
|
MAX_PARTITION = 3;
|
|
MAX_EXTENDED = 1;
|
Only 2 partitions in second level
|
|
|
MIN_FLOPPY_DRIVE = MIN_DRIVE;
|
|
MAX_FLOPPY_DRIVE = MIN_DRIVE + 1;
|
|
|
|
MIN_FIXED_DRIVE = MIN_DRIVE + 2;
|
|
MAX_FIXED_DRIVE = MAX_DRIVE;
|
|
|
|
MIN_SECTOR_SIZE = 512;
|
|
MAX_SECTOR_SIZE = 4096;
|
|
ISO_SECTOR_SIZE = 2048;
|
|
|
|
VOLUME_PREFIX = '\Volume';
|
eg \Volume1
|
EXTENDED_PREFIX = '\Extended';
|
eg \Extended1
|
PARTITION_PREFIX = '\Partition';
|
eg \Partition1
|
CONTROLLER_PREFIX = '\Controller';
|
eg \Controller0
|
CDROM_DEVICE_PREFIX = '\Cdrom';
|
eg \Cdrom0
|
OTHER_DEVICE_PREFIX = '\Other';
|
eg \Other0
|
FIXED_DEVICE_PREFIX = '\Harddisk';
|
eg \Harddisk0
|
FLOPPY_DEVICE_PREFIX = '\Floppy';
|
eg \Floppy0
|
UNKNOWN_DEVICE_PREFIX = '\Unknown';
|
eg \Unknown0
|
|
|
VOLUME_PATH_PREFIX = '\\?';
|
eg \\?\Volume1\Home
|
DEVICE_PATH_PREFIX = '\\.';
|
eg \\.\Harddisk0\Partition1\Home
|
REPARSE_PATH_PREFIX = '\??\';
|
|
|
|
BOOT_RECORD_SIGNATURE = $AA55;
|
|
PARTITION_RECORD_SIGNATURE = $AA55;
|
|
BOOT_SECTOR_SIGNATURE = $AA55;
|
|
[Expand]
FileSystem find flag FIND_FLAG_*
FIND_FLAG_NONE = $00000000;
|
|
FIND_FLAG_FILE_NAMES = $00000001;
|
|
[Expand]
FileSystem find wildcard FIND_WILDCARD_*
FIND_WILDCARD_NAME = '*.*';
|
|
FIND_WILDCARD_STREAM = '*';
|
|
[Expand]
File mode fm*Mask
fmOpenMask = $000F;
|
|
fmShareMask = $00F0;
|
|
[Expand]
File attribute fa*
faDot = $01000000;
|
|
faDotDot = $02000000;
|
|
faFile = $04000000;
|
|
faStream = $08000000;
|
|
faFlagName = $00100000;
|
Used for FAT case flags
|
faFlagExt = $00200000;
|
Used for FAT case flags
|
faFlagBoth = (faFlagName or faFlagExt);
|
|
faFlagLong = $00400000;
|
Not currently used
|
faFlagMetafile = $00800000;
|
Used for NTFS Metafiles
|
|
|
faFlagMask = $0FFF0000;
|
Used to preserve internal attributes
|
faFindMask = $0000FFFF;
|
Used to mask internal attributes
|
faMatchMask = (faFile or faStream or faVolumeID or faDirectory);
|
|
|
|
| Additional File Attribute Flags for NTFS/EXTFS/NSS
|
faDevice = $00000040;
|
Note: Conflicts with faSymLink in FPC SysUtils (filutilh.inc)
|
faNormal = $00000080;
|
|
faTemporary = $00000100;
|
|
faSparse = $00000200;
|
|
faReparse = $00000400;
|
|
faCompressed = $00000800;
|
|
faOffline = $00001000;
|
|
faNotIndexed = $00002000;
|
|
faEncrypted = $00004000;
|
|
|
|
faMftDirectory = $10000000;
|
Used only by FileName Attribute
|
faMftIndexView = $20000000;
|
Used by both the StandardInformation and FileName attributes
|
|
|
| Note: NTFS does not store the faVolumeID or faDirectory attributes
|
|
|
| Additional File Attribute constants
|
faNone = $00000000;
|
|
faStandard = (faReadOnly or faHidden or faSysFile or faArchive);
|
|
faLongName = (faReadOnly or faHidden or faSysFile or faVolumeID);
|
|
faLongMask = (faReadOnly or faHidden or faSysFile or faVolumeID or faDirectory or faArchive);
|
|
[Expand]
FileSystem volume attribute va*
vaNone = $00000000;
|
|
vaCaseSensitive = $00000001;
|
|
vaCasePreserved = $00000002;
|
|
vaUnicode = $00000004;
|
|
vaPersistentAcls = $00000008;
|
|
vaFileCompression = $00000010;
|
|
vaVolumeQuotas = $00000020;
|
|
vaSparseFiles = $00000040;
|
|
vaReparsePoints = $00000080;
|
|
vaRemoteStorage = $00000100;
|
|
vaLongNamesApi = $00004000;
|
|
vaVolumeCompressed = $00008000;
|
|
vaObjectIds = $00010000;
|
|
vaEncryption = $00020000;
|
|
vaNamedStreams = $00040000;
|
|
vaReadOnly = $00080000;
|
|
|
|
| Additional Volume Attribute constants
|
vaBootCatalog = $01000000;
|
Used to indicate support for ISO Boot Catalogs
|
vaVirtualVolume = $02000000;
|
Used to indicate Volume is Virtual or on a Virtual Device
|
vaFolderEncryption = $04000000;
|
Used to indicate support for Folder Encryption (New files in folder are automatically encrypted)
|
vaFolderCompression = $08000000;
|
Used to indicate support for Folder Compression (New files in folder are automatically compressed)
|
[Expand]
FileSystem device attribute da*
daNone = $00000000;
|
|
daWriteable = $00000001;
|
|
daVirtual = $00000002;
|
|
[Expand]
FileSystem image attribute ia*
iaNone = $00000000;
|
|
iaDisk = $00000001;
|
Memory/File/Device (All others always Disk)
|
iaPartition = $00000002;
|
Memory/File/Device
|
iaVolume = $00000004;
|
Memory/File/Device
|
iaDrive = $00000008;
|
Memory/File/Device
|
iaCDROM = $00000010;
|
Memory/File/Device/Iso
|
iaDVD = $00000020;
|
Memory/File/Device/Iso
|
iaFlat = $00000040;
|
Bochs
|
iaSparse = $00000080;
|
Bochs
|
iaGrowing = $00000100;
|
Bochs
|
iaFixed = $00000200;
|
Vpc/Vbox/Vmware
|
iaDynamic = $00000400;
|
Vpc/Vbox/Vmware
|
iaSplit = $00000800;
|
Vpc/Vmware/WIM/Ghost/Portlock/Powerquest
|
iaUndoable = $00001000;
|
Vpc/Vbox/Vmware
|
|
|
iaReadable = $00010000;
|
All
|
iaWriteable = $00020000;
|
All
|
iaEraseable = $00040000;
|
All
|
[Expand]
FileSystem catalog attribute ca*
caNone = $00000000;
|
|
caDefault = $00000001;
|
Initial/Default Entry
|
caBootable = $00000002;
|
Boot Indicator
|
caNoEmulation = $00000004;
|
No Emulation
|
caFloppy12M = $00000008;
|
1.2M
|
caFloppy144M = $00000010;
|
1.44M
|
caFloppy288M = $00000020;
|
2.88M
|
caHardDisk = $00000040;
|
Hard Disk
|
[Expand]
FileSystem miscellaneous NAME_HASH_SIZE*
NAME_HASH_SIZE = 8;
|
Used for Internal Name Hash Generation only
|
[Expand]
FileSystem partition Id pid*
| See http://www.win.tue.nl/~aeb/partitions/partition_types-1.html
|
|
|
MAX_PARTITION_ID = 255;
|
|
pidUnused = 0;
|
Empty
|
pidFAT12 = 1;
|
|
pidXENIXROOT = 2;
|
|
pidXENIXUSR = 3;
|
|
pidFAT16 = 4;
|
under 32M
|
pidExtended = 5;
|
|
pidFAT16HUGE = 6;
|
over 32M
|
pidHPFSNTFS = 7;
|
|
pidAIXOS2 = 8;
|
|
pidAIX = 9;
|
|
pidOS2BOOT = 10;
|
|
pidFAT32 = 11;
|
|
pidFAT32LBA = 12;
|
|
pidUnknown013 = 13;
|
|
pidFAT16LBA = 14;
|
|
pidExtLBA = 15;
|
|
pidOPUS = 16;
|
|
pidHIDDEN12 = 17;
|
|
pidCompaqDiag = 18;
|
|
pidUnknown019 = 19;
|
|
pidHIDDEN16 = 20;
|
|
pidUnknown021 = 21;
|
|
pidHIDDEN16HUGE = 22;
|
|
pidHIDDENHPFS = 23;
|
|
pidASTSWAP = 24;
|
|
pidWillowtech = 25;
|
|
pidUnknown026 = 26;
|
|
pidHIDDEN32 = 27;
|
|
pidHIDDEN32LBA = 28;
|
|
pidUnknown029 = 29;
|
|
pidHIDDEN16LBA = 30;
|
|
pidUnknown031 = 31;
|
|
pidWillowsoft = 32;
|
|
pidOxygen = 33;
|
|
pidOxygenExtended = 34;
|
|
pidReserved035 = 35;
|
|
pidNECMSDOS = 36;
|
|
pidUnknown037 = 37;
|
|
pidUnknown038 = 38;
|
|
pidUnknown039 = 39;
|
|
pidUnknown040 = 40;
|
|
pidUnknown041 = 41;
|
|
pidUnknown042 = 42;
|
|
pidUnknown043 = 43;
|
|
pidUnknown044 = 44;
|
|
pidUnknown045 = 45;
|
|
pidUnknown046 = 46;
|
|
pidUnknown047 = 47;
|
|
pidUnknown048 = 48;
|
|
pidReserved049 = 49;
|
|
pidAlienNOS = 50;
|
|
pidReserved051 = 51;
|
|
pidReserved052 = 52;
|
|
pidOS2JFS = 53;
|
|
pidReserved054 = 54;
|
|
pidUnknown055 = 55;
|
|
pidTheos057 = 56;
|
|
pidPlan9 = 57;
|
|
pidTheos058 = 58;
|
|
pidTheos059 = 59;
|
|
pidPowerQuest = 60;
|
|
pidHiddenNetware = 61;
|
|
pidUnknown062 = 62;
|
|
pidUnknown063 = 63;
|
|
pidVENIX286 = 64;
|
|
pidPersonalRISC = 65;
|
|
pidSFS = 66;
|
|
pidPTSDOS = 67;
|
|
pidGoBack = 68;
|
|
pidEUMEL069 = 69;
|
|
pidEUMEL070 = 70;
|
|
pidEUMEL071 = 71;
|
|
pidEUMEL072 = 72;
|
|
pidUnknown073 = 73;
|
|
pidAdaOS = 74;
|
|
pidUnknown075 = 75;
|
|
pidOberon = 76;
|
|
pidQNX4077 = 77;
|
|
pidQNX4078 = 78;
|
|
pidQNX4079 = 79;
|
|
pidOnTrack080 = 80;
|
|
pidNOVELL081 = 81;
|
|
pidCPM = 82;
|
|
pidOnTrack083 = 83;
|
|
pidOnTrack084 = 84;
|
|
pidEZDrive = 85;
|
|
pidGoldenBow = 86;
|
|
pidUnknown087 = 87;
|
|
pidUnknown088 = 88;
|
|
pidUnknown089 = 89;
|
|
pidUnknown090 = 90;
|
|
pidUnknown091 = 91;
|
|
pidPriamEdisk = 92;
|
|
pidUnknown093 = 93;
|
|
pidUnknown094 = 94;
|
|
pidUnknown095 = 95;
|
|
pidUnknown096 = 96;
|
|
pidSpeedStor097 = 97;
|
|
pidUnknown098 = 98;
|
|
pidSysV = 99;
|
|
pidNetware286 = 100;
|
|
pidNWFS = 101;
|
Traditional/Netware 6 Master
|
pidUnknown102 = 102;
|
|
pidNovell103 = 103;
|
|
pidNovell104 = 104;
|
|
pidNSS = 105;
|
NSS/Netware 6
|
pidUnknown106 = 106;
|
|
pidUnknown107 = 107;
|
|
pidUnknown108 = 108;
|
|
pidUnknown109 = 109;
|
|
pidUnknown110 = 110;
|
|
pidUnknown111 = 111;
|
|
pidDiskSecure = 112;
|
|
pidUnknown113 = 113;
|
|
pidUnknown114 = 114;
|
|
pidReserved115 = 115;
|
|
pidReserved116 = 116;
|
|
pidPCIX = 117;
|
|
pidReserved118 = 118;
|
|
pidUnknown119 = 119;
|
|
pidUnknown120 = 120;
|
|
pidUnknown121 = 121;
|
|
pidUnknown122 = 122;
|
|
pidUnknown123 = 123;
|
|
pidUnknown124 = 124;
|
|
pidUnknown125 = 125;
|
|
pidUnknown126 = 126;
|
|
pidUnknown127 = 127;
|
|
pidMinix = 128;
|
|
pidLinuxMinix = 129;
|
|
pidLinuxSwap = 130;
|
|
pidLinuxNative = 131;
|
|
pidHIDDENC = 132;
|
|
pidLinuxExtended = 133;
|
|
pidFAT16Stripe = 134;
|
|
pidNTFSStripe = 135;
|
|
pidUnknown136 = 136;
|
|
pidUnknown137 = 137;
|
|
pidUnknown138 = 138;
|
|
pidUnknown139 = 139;
|
|
pidUnknown140 = 140;
|
|
pidUnknown141 = 141;
|
|
pidUnknown142 = 142;
|
|
pidUnknown143 = 143;
|
|
pidUnknown144 = 144;
|
|
pidUnknown145 = 145;
|
|
pidUnknown146 = 146;
|
|
pidAmoeba = 147;
|
|
pidAmoebaBBT = 148;
|
|
pidUnknown149 = 149;
|
|
pidUnknown150 = 150;
|
|
pidUnknown151 = 151;
|
|
pidUnknown152 = 152;
|
|
pidUnknown153 = 153;
|
|
pidUnknown154 = 154;
|
|
pidUnknown155 = 155;
|
|
pidUnknown156 = 156;
|
|
pidUnknown157 = 157;
|
|
pidUnknown158 = 158;
|
|
pidUnknown159 = 159;
|
|
pidPhoenixPM = 160;
|
|
pidReserved161 = 161;
|
|
pidUnknown162 = 162;
|
|
pidReserved163 = 163;
|
|
pidReserved164 = 164;
|
|
pidFreeBSD = 165;
|
|
pidOpenBSD = 166;
|
|
pidNeXTStep = 167;
|
|
pidUnknown168 = 168;
|
|
pidUnknown169 = 169;
|
|
pidUnknown170 = 170;
|
|
pidDarwinBoot = 171;
|
|
pidUnknown172 = 172;
|
|
pidUnknown173= 173;
|
|
pidUnknown174 = 174;
|
|
pidUnknown175 = 175;
|
|
pidUnknown176 = 176;
|
|
pidUnknown177 = 177;
|
|
pidUnknown178 = 178;
|
|
pidUnknown179 = 179;
|
|
pidReserved180 = 180;
|
|
pidUnknown181 = 181;
|
|
pidFAT16MirrorA = 182;
|
|
pidNTFSMirrorA = 183;
|
|
pidBSDIswap = 184;
|
|
pidUnknown185 = 185;
|
|
pidUnknown186 = 186;
|
|
pidUnknown187 = 187;
|
|
pidUnknown188 = 188;
|
|
pidUnknown189 = 189;
|
|
pidUnknown190= 190;
|
|
pidUnknown191 = 191;
|
|
pidUnknown192 = 192;
|
|
pidDRDOSFAT12 = 193;
|
|
pidUnknown194 = 194;
|
|
pidUnknown195 = 195;
|
|
pidDRDOSFAT16 = 196;
|
|
pidUnknown197 = 197;
|
|
pidFAT16MirrorB = 198;
|
|
pidNTFSMirrorB = 199;
|
|
pidUnknown200 = 200;
|
|
pidUnknown201 = 201;
|
|
pidUnknown202 = 202;
|
|
pidUnknown203 = 203;
|
|
pidUnknown204 = 204;
|
|
pidUnknown205 = 205;
|
|
pidUnknown206 = 206;
|
|
pidUnknown207 = 207;
|
|
pidUnknown208 = 208;
|
|
pidUnknown209 = 209;
|
|
pidTinyEFAT = 210;
|
|
pidEFAT = 211;
|
|
pidSecuredEFAT = 212;
|
|
pidOpticalEFAT = 213;
|
|
pidUnknown214 = 214;
|
|
pidUnknown215 = 215;
|
|
pidCPM86 = 216;
|
|
pidUnknown217 = 217;
|
|
pidUnknown218 = 218;
|
|
pidConcurrentCPM = 219;
|
|
pidUnknown220 = 220;
|
|
pidUnknown221 = 221;
|
|
pidUnknown222 = 222;
|
|
pidUnknown223 = 223;
|
|
pidUnknown224 = 224;
|
|
pidSpeedStorFAT12 = 225;
|
|
pidUnknown226 = 226;
|
|
pidUnknown227 = 227;
|
|
pidSpeedStorFAT16 = 228;
|
|
pidReserved229 = 229;
|
|
pidReserved230 = 230;
|
|
pidUnknown231 = 231;
|
|
pidUnknown232 = 232;
|
|
pidUnknown233 = 233;
|
|
pidUnknown234 = 234;
|
|
pidBeOSBFS1 = 235;
|
|
pidUnknown236 = 236;
|
|
pidUnknown237 = 237;
|
|
pidUnknown238 = 238;
|
|
pidUnknown239 = 239;
|
|
pidLinuxRISC = 240;
|
|
pidStorageDimension = 241;
|
|
pidDOS33Secondary = 242;
|
|
pidSpeedStor243 = 243;
|
|
pidSpeedStor244 = 244;
|
|
pidPrologue = 245;
|
|
pidSpeedStor246 = 246;
|
|
pidOSGEFAT = 247;
|
|
pidUnknown248 = 248;
|
|
pidUnknown249 = 249;
|
|
pidBochsX86 = 250;
|
|
pidVMware = 251;
|
|
pidVMwareSwap = 252;
|
|
pidLinuxRAID = 253;
|
|
pidLANstep = 254;
|
|
pidXenixBBT = 255;
|
|
|
|
PARTITION_NAMES:array[0..MAX_PARTITION_ID] of String = (
|
'Unused',
|
|
'FAT12',
|
|
'XENIX ROOT',
|
|
'XENIX USR',
|
|
'FAT16 (up to 32M)',
|
|
'Extended',
|
|
'FAT16 (over 32M)',
|
|
'HPFS or NTFS',
|
|
'AIX or OS/2',
|
|
'AIX',
|
|
'OS/2 Boot Manager',
|
|
'FAT32',
|
|
'FAT32 (LBA)',
|
|
'Unknown',
|
|
'FAT16 (LBA)',
|
|
'Extended (LBA)',
|
|
'OPUS',
|
|
'Hidden FAT12',
|
|
'Compaq Diagnostic',
|
|
'Unknown',
|
|
'Hidden FAT16 (<32M)',
|
|
'Unknown',
|
|
'Hidden FAT16 (>32M)',
|
|
'Hidden HPFS',
|
|
'AST SWAP',
|
|
'Willowtech',
|
|
'Unknown',
|
|
'Hidden FAT32',
|
|
'Hidden FAT32 (LBA)',
|
|
'Unknown',
|
|
'Hidden FAT16 (LBA)',
|
|
'Unknown',
|
|
'Willowsoft',
|
|
'Oxygen',
|
|
'Oxygen Extended',
|
|
'Reserved',
|
|
'NEC MS-DOS 3.X',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Reserved',
|
|
'Alien NOS',
|
|
'Reserved',
|
|
'Reserved',
|
|
'OS/2 JFS',
|
|
'Reserved',
|
|
'Unknown',
|
|
'Theos',
|
|
'Plan 9',
|
|
'Theos',
|
|
'Theos',
|
|
'PowerQuest Recovery',
|
|
'Hidden Netware',
|
|
'Unknown',
|
|
'Unknown',
|
|
'VENIX 80286',
|
|
'Personal RISC',
|
|
'SFS',
|
|
'PTS-DOS',
|
|
'GoBack',
|
|
'EUMEL/Elan',
|
|
'EUMEL/Elan',
|
|
'EUMEL/Elan',
|
|
'EUMEL/Elan',
|
|
'Unknown',
|
|
'AdaOS Aquila',
|
|
'Unknown',
|
|
'Oberon',
|
|
'First QNX 4.0',
|
|
'Second QNX 4.0',
|
|
'Third QNX 4.0',
|
|
'OnTrack DM',
|
|
'NOVELL',
|
|
'CP/M',
|
|
'OnTrack DM',
|
|
'OnTrack DM',
|
|
'EZ Drive',
|
|
'GoldenBow',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Priam Edisk',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'SpeedStor',
|
|
'Unknown',
|
|
'Sys V / Mach / HURD',
|
|
'Netware 286',
|
|
'Netware 386',
|
|
'Unknown',
|
|
'Novell',
|
|
'Novell',
|
|
'Netware NSS',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'DiskSecure',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Reserved',
|
|
'Reserved',
|
|
'PC/IX',
|
|
'Reserved',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Minix v1.1-1.4a',
|
|
'Linux / Minix',
|
|
'Linux Swap',
|
|
'Linux Native',
|
|
'Hidden C:',
|
|
'Linux Extended',
|
|
'FAT16 Stripe Set',
|
|
'NTFS Stripe Set',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Amoeba',
|
|
'Amoeba BBT',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Phoenix Power Management',
|
|
'Reserved',
|
|
'Unknown',
|
|
'Reserved',
|
|
'Reserved',
|
|
'FreeBSD',
|
|
'OpenBSD',
|
|
'NeXTStep',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Apple Darwin Boot',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Reserved',
|
|
'Unknown',
|
|
'FAT16 Mirror (Master)',
|
|
'NTFS Mirror (Master)',
|
|
'BSDI Swap',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'DR-DOS FAT12',
|
|
'Unknown',
|
|
'Unknown',
|
|
'DR-DOS FAT16',
|
|
'Unknown',
|
|
'FAT16 Mirror (Slave)',
|
|
'NTFS Mirror (Slave)',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Tiny EFAT',
|
|
'EFAT',
|
|
'Secured EFAT',
|
|
'Optical EFAT',
|
|
'Unknown',
|
|
'Unknown',
|
|
'CP/M-86',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Concurrent CP/M',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'SpeedStor FAT12',
|
|
'Unknown',
|
|
'Unknown',
|
|
'SpeedStor FAT16',
|
|
'Reserved',
|
|
'Reserved',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'BeOS BFS-1',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Unknown',
|
|
'Linux/PA-RISC',
|
|
'Storage Dimension',
|
|
'DOS 3.3+ Secondary',
|
|
'SpeedStor',
|
|
'SpeedStor',
|
|
'Prologue',
|
|
'SpeedStor',
|
|
'OSG EFAT',
|
|
'Unknown',
|
|
'Unknown',
|
|
'BochsX86',
|
|
'VMware',
|
|
'VMware Swap',
|
|
'Linux RAID',
|
|
'LANstep',
|
|
'Xenix BBT');
|
|
[Expand]
FileSystem device description FILESYS_*_DEVICE_DESCRIPTION
FILESYS_ATA_DEVICE_DESCRIPTION = 'ATA Storage Device';
|
|
FILESYS_ATAPI_DEVICE_DESCRIPTION = 'ATAPI Storage Device';
|
|
FILESYS_SCSI_DEVICE_DESCRIPTION = 'SCSI Storage Device';
|
|
FILESYS_USB_DEVICE_DESCRIPTION = 'USB Storage Device';
|
|
FILESYS_MMC_DEVICE_DESCRIPTION = 'MMC/SD Storage Device';
|
|
[Expand]
FileSystem controller description FILESYS_*_CONTROLLER_DESCRIPTION
FILESYS_ATA_CONTROLLER_DESCRIPTION = 'ATA Storage Controller';
|
|
FILESYS_ATAPI_CONTROLLER_DESCRIPTION = 'ATAPI Storage Controller';
|
|
FILESYS_SCSI_CONTROLLER_DESCRIPTION = 'SCSI Storage Controller';
|
|
FILESYS_USB_CONTROLLER_DESCRIPTION = 'USB Storage Controller';
|
|
FILESYS_MMC_CONTROLLER_DESCRIPTION = 'MMC/SD Storage Controller';
|
|
[Expand]
FileSystem logging FILESYS_LOG_*
FILESYS_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
FileSystem debugging messages
|
FILESYS_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
FileSystem informational messages, such as a filesystem being mounted or dismounted.
|
FILESYS_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
FileSystem error messages
|
FILESYS_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No FileSystem messages
|
Type definitions
Storage device event
[Expand]
PStorageDeviceEvent = ^TStorageDeviceEvent;
TStorageDeviceEvent = record
Timer:TTimerHandle;
|
|
Device:PStorageDevice;
|
|
Cache timer
[Expand]
PCacheTimerItem = ^TCacheTimerItem;
TCacheTimerItem = record
Key:Integer;
|
Ordering key for timer list
|
Page:TObject;
|
The cache page referenced by this timer list item
|
Prev:PCacheTimerItem;
|
Previous item in timer list
|
Next:PCacheTimerItem;
|
Next item in timer list
|
Entry timer
[Expand]
PEntryTimerItem = ^TEntryTimerItem;
TEntryTimerItem = record
Key:Integer;
|
Ordering key for timer list
|
Entry:TObject;
|
The disk entry referenced by this timer list item
|
Prev:PEntryTimerItem;
|
Previous item in timer list
|
Media type
TMediaType = (mtUNKNOWN,mtINVALID,mtFLOPPY,mtFIXED,mtREMOVABLE,mtCDROM,mtDVD,mtOTHER);
|
|
Floppy type
TFloppyType = (ftUNKNOWN,ftINVALID,ft360K,ft12M,ft720K,ft144M,ft288M,ftATAPI);
|
|
Image type
TImageType = (itUNKNOWN,itINVALID,itMEMORY,itFILE,itDEVICE,itISO,itBOCHS,itVMWARE,itVPC,itVBOX);
|
|
Cache state
TCacheState = (csCLEAN,csDIRTY);
|
|
Cache mode
TCacheMode = (cmNONE,cmREADONLY,cmREADWRITE);
|
|
Cache page type
TCachePageType = (ptNONE,ptDEVICE);
|
|
Cache page state
TCachePageState = (psUNKNOWN,psEMPTY,psCLEAN,psDIRTY);
|
|
Cache page content
TCachePageContent = (pcUNKNOWN,pcDATA,pcDIRECTORY,pcENTRY,pcSYSTEM);
|
|
Cache statistics
[Expand]
PCacheStatistics = ^TCacheStatistics;
TCacheStatistics = record
| Information
|
PageSize:LongWord;
|
|
PageCount:LongWord;
|
|
CacheSize:LongWord;
|
|
CacheMode:TCacheMode;
|
|
CacheState:TCacheState;
|
|
FlushTimeout:LongWord;
|
|
DiscardTimeout:LongWord;
|
|
| Read/Write
|
ReadCached:Int64;
|
|
ReadDirect:Int64;
|
|
WriteBack:Int64;
|
|
WriteThrough:Int64;
|
|
WriteDirect:Int64;
|
|
| Hit/Miss
|
HitCount:Int64;
|
|
MissCount:Int64;
|
|
| Allocate Success/Failure
|
FailCount:Int64;
|
|
SuccessCount:Int64;
|
|
| Page Flush/Discard
|
FlushCount:Int64;
|
|
DiscardCount:Int64;
|
|
UnknownCount:Int64;
|
|
| Page Times
|
OldestClean:Int64;
|
|
NewestClean:Int64;
|
|
OldestDirty:Int64;
|
|
NewestDirty:Int64;
|
|
Search
[Expand]
TSearchRec = SysUtils.TRawbyteSearchRec;
TSearchRec = record
| Note: TSearchRec is always defined in SysUtils
|
Time: Integer;
|
|
Size: Integer;
|
|
Attr: Integer;
|
|
Name: TFileName;
|
|
ExcludeAttr: Integer;
|
|
FindHandle: THandle;
|
|
FindData: TWin32FindData;
|
|
File search
[Expand]
TFileSearchRec = record
FindHandle:THandle;
|
|
FindData:TWin32FindData;
|
|
Disk search
[Expand]
TDiskSearchRec = record
Name:String;
|
|
MediaType:TMediaType;
|
|
FloppyType:TFloppyType;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Verbose:Boolean;
|
|
Partition search
[Expand]
TPartitionSearchRec = record
Name:String;
|
|
Index:LongWord;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Verbose:Boolean;
|
|
Volume search
[Expand]
TVolumeSearchRec = record
Name:String;
|
|
Attributes:LongWord;
|
|
VolumeLabel:String;
|
|
VolumeGUID:String;
|
|
VolumeSerial:LongWord;
|
|
DriveType:TDriveType;
|
|
FileSysType:TFileSysType;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Verbose:Boolean;
|
|
Drive search
[Expand]
TDriveSearchRec = record
Name:String;
|
|
Attributes:LongWord;
|
|
VolumeLabel:String;
|
|
VolumeGUID:String;
|
|
VolumeSerial:LongWord;
|
|
DriveType:TDriveType;
|
|
FileSysType:TFileSysType;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Verbose:Boolean;
|
|
Image search
[Expand]
TImageSearchRec = record
Name:String;
|
|
ImageNo:Integer;
|
|
ImageType:TImageType;
|
|
MediaType:TMediaType;
|
|
FloppyType:TFloppyType;
|
|
Attributes:LongWord;
|
|
SectorSize:Word;
|
|
SectorCount:Int64;
|
|
Cylinders:LongWord;
|
|
Heads:LongWord;
|
|
Sectors:LongWord;
|
|
PartitionId:Byte;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Verbose:Boolean;
|
|
Catalog search
[Expand]
TCatalogSearchRec = record
Name:String;
|
|
Path:String;
|
|
CatalogNo:LongWord;
|
|
MediaType:TMediaType;
|
|
FloppyType:TFloppyType;
|
|
Attributes:LongWord;
|
|
SectorSize:Word;
|
|
SectorCount:Int64;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Mount search
[Expand]
TMountSearchRec = record
Name:String;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Junction search
[Expand]
TJunctionSearchRec = record
Name:String;
|
|
FindHandle:THandle;
|
|
Context:LongWord;
|
|
Stream search
[Expand]
TStreamSearchRec = record
FindHandle:THandle;
|
|
Context:Pointer;
|
|
FindData:TWin32FindStreamData;
|
|
Link search
[Expand]
TLinkSearchRec = record
Name:String;
|
|
FindHandle:THandle;
|
|
Context:Pointer;
|
|
FAT12/FAT16 BIOS parameter block
[Expand]
TBiosPB = packed record
BytesPerSector:Word;
|
512,1024,2048,4096 - Usually 512
|
SectorsPerCluster:Byte;
|
1,2,4,8,16,32,64,128
|
ReservedSectors:Word;
|
FAT12/16 - Usually 1, FAT32 - Usually 32
|
NumberOfFats:Byte;
|
Usually 2
|
RootEntryCount:Word;
|
FAT32 always 0, FAT16 usually 512 (RootEntryCount * 32 must be even multiple of BytesPerSector)
|
TotalSectors16:Word;
|
Total Sectors on the drive or 0 if TotalSectors32 used
|
MediaId:Byte;
|
F8 for Fixed media, F0 usually for Removable media
|
SectorsPerFat16:Word;
|
FAT32 always 0, Number of Sectors per FAT
|
SectorsPerTrack:Word;
|
Sectors Per Track for Int13
|
NumberOfHeads:Word;
|
Number of Header for Int13 eg 1.44MB = 2
|
HiddenSectors:LongWord;
|
Number of Hidden Sectors preceeding Partition (Only valid on Partitioned media)
|
TotalSectors32:LongWord;
|
Total Sectors on the drive or 0 if TotalSectors16 used
|
FAT32 BIOS parameter block
[Expand]
TExtBiosPB = packed record
BytesPerSector:Word;
|
512,1024,2048,4096 - Usually 512
|
SectorsPerCluster:Byte;
|
1,2,4,8,16,32,64,128
|
ReservedSectors:Word;
|
FAT12/16 - Usually 1, FAT32 - Usually 32
|
NumberOfFats:Byte;
|
Usually 2
|
RootEntryCount:Word;
|
FAT32 always 0, FAT16 usually 512 (RootEntryCount * 32 must be even multiple of BytesPerSector)
|
TotalSectors16:Word;
|
Total Sectors on the drive or 0 if TotalSectors32 used
|
MediaId:Byte;
|
F8 for Fixed media, F0 usually for Removable media
|
SectorsPerFat16:Word;
|
FAT32 always 0, Number of Sectors per FAT
|
SectorsPerTrack:Word;
|
Sectors Per Track for Int13
|
NumberOfHeads:Word;
|
Number of Header for Int13 eg 1.44MB = 2
|
HiddenSectors:LongWord;
|
Number of Hidden Sectors preceeding Partition (Only valid on Partitioned media)
|
TotalSectors32:LongWord;
|
Total Sectors on the drive or 0 if TotalSectors16 used
|
SectorsPerFat32:LongWord;
|
Number of Sectors per FAT
|
ExtendedFlags:Word;
|
Bits 0-3 -- Zero-based number of active FAT. Only valid if mirroring.
Bits 0-3 - is disabled.
Bits 4-6 - Reserved.
Bit 7 - 0 means the FAT is mirrored at runtime into all FATs.
Bit 7 - 1 means only one FAT is active, it is the one referenced.
Bit 7 - in bits 0-3.
Bits 8-15 -- Reserved.
|
FileSysVersion:Word;
|
FAT32 Version (Current 0:0)
|
RootCluster:LongWord;
|
Usually Cluster 2
|
FileSysInfoSector:Word;
|
Usually 1
|
BackupBootSector:Word;
|
Usually 6
|
Reserved:array[0..11] of Byte;
|
Always 0
|
NTFS BIOS parameter block
[Expand]
TNtfsBiosPB = packed record
BytesPerSector:Word;
|
512,1024,2048,4096 - Usually 512
|
SectorsPerCluster:Byte;
|
1,2,4,8,16,32,64,128 - Usually 8
|
ReservedSectors:Word;
|
Must always be 0 on NTFS (Win2K Volume Manager ?)
|
Reserved1:array[0..2] of Byte;
|
Must always be 0 on NTFS
|
Reserved2:Word;
|
Must always be 0 on NTFS
|
MediaId:Byte;
|
F8 for Fixed media, F0 usually for Removable media
|
Reserved3:Word;
|
Must always be 0 on NTFS
|
SectorsPerTrack:Word;
|
Sectors Per Track for Int13
|
NumberOfHeads:Word;
|
Number of Header for Int13 eg 1.44MB = 2
|
HiddenSectors:LongWord;
|
Number of Hidden Sectors preceeding Partition
|
Reserved4:LongWord;
|
Must always be 0 on NTFS
|
Reserved5:LongWord;
|
Not used by NTFS - Usually 80008000
|
TotalSectors:Int64;
|
Total Sectors on the drive
|
MFTCluster:Int64;
|
Start Cluster of $MFT
|
MFTMirror:Int64;
|
Start Cluster of $MFTMirr
|
ClustersPerFile:LongInt;
|
Clusters Per File Record (Can be negative) (F6 = 1024 - See Notes)
|
ClustersPerIndex:LongInt;
|
Clusters Per Index Record (Can be negative) (F6 = 1024 - See Notes)
|
VolumeSerial:Int64;
|
Volume Serial Number
|
Checksum:LongWord;
|
Checksum (Not Used)
|
Partition entry
[Expand]
TPartitionEntry = packed record
BootIndicator:Byte;
|
80 for active partition
|
StartHead:Byte;
|
Either Bits 0-3 only or Bits 0-7 depending on BIOS
|
StartSector:Byte;
|
Bits 0-5 = Sector, Bits 6-7 = Bits 8-9 of Cylinder
|
StartCylinder:Byte;
|
Bits 0-7 Only, Bits 8-9 in Sector
|
TypeIndicator:Byte;
|
See Table in Interrupt List and Below
|
EndHead:Byte;
|
Either Bits 0-3 only or Bits 0-7 depending on BIOS
|
EndSector:Byte;
|
Bits 0-5 = Sector, Bits 6-7 = Bits 8-9 of Cylinder
|
EndCylinder:Byte;
|
Bits 0-7 Only, Bits 8-9 in Sector
|
SectorOffset:LongWord;
|
Offset in sectors from current position to Start of Partition
|
SectorCount:LongWord;
|
Size in Sectors of the Partition
|
Partition table
[Expand]
TPartitionTable = packed record
PartitionEntry:array[MIN_PARTITION..MAX_PARTITION] of TPartitionEntry;
|
|
Master boot code
TMasterBootCode = packed array[0..445] of Byte;
|
|
Master boot record
[Expand]
PMasterBootRecord = ^TMasterBootRecord;
TMasterBootRecord = packed record
| Note: Standard Master Boot Record
|
BootCode:TMasterBootCode;
|
|
PartitionTable:TPartitionTable;
|
|
Signature:Word;
|
Magic Number $AA55
|
Ext master boot code
TExtMasterBootCode = packed array[0..439] of Byte;
|
|
Ext master boot record
[Expand]
PExtMasterBootRecord = ^TExtMasterBootRecord;
TExtMasterBootRecord = packed record
| Note: NT/2000/XP Master Boot Record
|
BootCode:TExtMasterBootCode;
|
|
DiskSignature:LongWord;
|
|
Reserved1:Word;
|
|
PartitionTable:TPartitionTable;
|
|
Signature:Word;
|
Magic Number $AA55
|
Partition record
[Expand]
PPartitionRecord = ^TPartitionRecord;
TPartitionRecord = packed record
| Note: Similar to TMasterBootRecord
|
Dummy:array[0..445] of Byte;
|
|
PartitionTable:TPartitionTable;
|
Only first 2 ever used
|
Signature:Word;
|
Magic Number $AA55
|
Sector
[Expand]
PSector = ^TSector;
TSector = packed array[0..511] of Byte;
Boot sector jump
TBootSectorJump = packed array[0..2] of Byte;
|
|
Boot sector code
TBootSectorCode = packed array[0..447] of Byte;
|
|
Boot sector
[Expand]
PBootSector = ^TBootSector;
TBootSector = packed record
| Note: FAT12/FAT16 Boot Sector
|
BootJump:TBootSectorJump;
|
JMP - EBh,??h,90h or E9h,??h,??h
|
OEMName:array[0..7] of Char;
|
MSWIN4.0/MSWIN4.1/MSDOS5.0
|
BPB:TBiosPB;
|
See Above
|
DriveNumber:Byte;
|
BIOS Int13 Drive No 00h, 80h, FFh etc
|
Reserved1:Byte;
|
Always 00h
|
BootSignature:Byte;
|
Always 29h
|
VolumeSerial:LongWord;
|
Serial No (Date/Time when Formatted)
|
VolumeName:array[0..10] of Char;
|
Volume Label or "NO NAME"
|
SystemName:array[0..7] of Char;
|
System Type FAT12, FAT16, FAT32 etc
|
BootCode:TBootSectorCode;
|
Executable Code
|
Signature:Word;
|
Magic Number $AA55
|
Ext boot sector jump
TExtBootSectorJump = packed array[0..2] of Byte;
|
|
Ext boot sector code
TExtBootSectorCode = packed array[0..419] of Byte;
|
|
Ext boot sector
[Expand]
PExtBootSector = ^TExtBootSector;
TExtBootSector = packed record
| Note: FAT32 Boot Sector
|
BootJump:TExtBootSectorJump;
|
JMP - EBh,??h,90h or E9h,??h,??h
|
OEMName:array[0..7] of Char;
|
MSWIN4.1
|
BPB:TExtBiosPB;
|
See Above
|
DriveNumber:Byte;
|
BIOS Int13 Drive No 00h, 80h, FFh etc
|
Reserved1:Byte;
|
Always 00h
|
BootSignature:Byte;
|
Always 29h
|
VolumeSerial:LongWord;
|
Serial No (Date/Time when Formatted)
|
VolumeName:array[0..10] of Char;
|
Volume Label or "NO NAME"
|
SystemName:array[0..7] of Char;
|
System Type FAT12, FAT16, FAT32 etc
|
BootCode:TExtBootSectorCode;
|
Executable Code
|
Signature:Word;
|
Magic Number $AA55
|
NTFS boot sector jump
TNtfsBootSectorJump = packed array[0..2] of Byte;
|
|
NTFS boot sector code
TNtfsBootSectorCode = packed array[0..425] of Byte;
|
|
NTFS boot sector
[Expand]
PNtfsBootSector = ^TNtfsBootSector;
TNtfsBootSector = packed record
| Note: NTFS Boot Sector
|
BootJump:TNtfsBootSectorJump;
|
JMP - EBh,??h,90h
|
OEMName:array[0..7] of Char;
|
Always NTFS
|
BPB:TNtfsBiosPB;
|
See Above (73 Bytes BPB and ExtBPB)
|
BootCode:TNtfsBootSectorCode;
|
Executable Code
|
Signature:Word;
|
Magic Number $AA55
|
EXTFS boot sector
[Expand]
PExtfsBootSector = ^TExtfsBootSector;
TExtfsBootSector = packed record
FileSystem logging
[Expand]
PFileSysLogging = ^TFileSysLogging;
TFileSysLogging = record
| Logging Properties
|
Logging:TLoggingDevice;
|
|
Class definitions
File system driver
[Expand]
TFileSysDriver = class(TObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
|
|
FCache:THashCache;
|
|
FImages:TFileSysList;
|
|
FDrives:TFileSysList;
|
|
FVolumes:TFileSysList;
|
|
FDevices:TFileSysList;
|
|
FPartitions:TFileSysList;
|
|
|
|
FControllers:TFileSysList;
|
|
FRecognizers:TFileSysList;
|
|
FRedirectors:TFileSysList;
|
|
FFileSystems:TFileSysList;
|
|
|
|
FRawHandles:TFileSysList;
|
|
FEnumHandles:TFileSysList;
|
|
FFileHandles:TFileSysList;
|
|
FFindHandles:TFileSysList;
|
|
|
|
FCurrentIndex:LongWord;
|
TLS Index for storing current drive
|
|
|
FAllowFloppy:Boolean;
|
Allow Scanning of Floppy Devices
|
FAllowDrives:Boolean;
|
Allow Disk Drives to represent Volumes by drive letter
|
FOemConvert:Boolean;
|
Convert OEM character strings to ANSI
|
|
|
FEntryTimer:TEntryTimer;
|
|
|
|
FDefaultRecognizer:TRecognizer;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function GetCurrent:TDiskDrive;
|
|
function SetCurrent(ACurrent:TDiskDrive):Boolean;
|
|
|
|
function FindMatchingFile(ADrive:TDiskDrive; AVolume:TDiskVolume; var ASearchRec:TSearchRec):Integer;
|
|
public
|
property Cache:THashCache read FCache;
|
|
|
|
property AllowFloppy:Boolean read FAllowFloppy write FAllowFloppy;
|
|
property AllowDrives:Boolean read FAllowDrives write FAllowDrives;
|
|
property OemConvert:Boolean read FOemConvert write FOemConvert;
|
|
|
|
function OpenCache(ACacheSize,ACacheKeys,APageSize:LongWord; ACacheMode:TCacheMode):Boolean;
|
|
function CloseCache:Boolean;
|
|
function FlushCache(AAll:Boolean):Boolean;
|
|
function DiscardCache(AAll:Boolean):Boolean;
|
|
function GetCacheStatistics(var AStatistics:TCacheStatistics):Boolean;
|
|
|
|
function GetCatalogByNo(const APath:String; ACatalogNo:LongWord; ALock:Boolean; AState:LongWord):TDiskCatalog;
|
|
function GetCatalogByName(const APath,AName:String; ALock:Boolean; AState:LongWord):TDiskCatalog;
|
|
function GetCatalogByNext(const APath:String; APrevious:TDiskCatalog; ALock,AUnlock:Boolean; AState:LongWord):TDiskCatalog;
|
|
|
|
function AddImage(AImage:TDiskImage):Boolean;
|
|
function RemoveImage(AImage:TDiskImage):Boolean;
|
|
function CheckImage(AImage:TDiskImage; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetImageByNo(AImageNo:Integer; ALock:Boolean; AState:LongWord):TDiskImage;
|
|
function GetImageByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskImage;
|
|
function GetImageByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TDiskImage;
|
|
function GetImageByController(AController:TDiskController; ALock:Boolean; AState:LongWord):TDiskImage;
|
|
function GetImagesByController(AController:TDiskController; ALock:Boolean; AState:LongWord):TList;
|
|
function GetImageByNext(APrevious:TDiskImage; ALock,AUnlock:Boolean; AState:LongWord):TDiskImage;
|
|
|
|
function GetNextImageNo:Integer;
|
|
function GetMaxImageNo:Integer;
|
|
|
|
function AddDrive(ADrive:TDiskDrive):Boolean;
|
|
function RemoveDrive(ADrive:TDiskDrive):Boolean;
|
|
function CheckDrive(ADrive:TDiskDrive; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetDriveByNo(ADriveNo:Integer; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveByParent(const AParent:String; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveByVolume(AVolume:TDiskVolume; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDrivesByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TList;
|
|
function GetDriveByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDrivesByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TList;
|
|
function GetDriveByNext(APrevious:TDiskDrive; ALock,AUnlock:Boolean; AState:LongWord):TDiskDrive;
|
|
|
|
function GetNextDriveNo(AMediaType:TMediaType):Integer;
|
|
function GetMaxDriveNo(AMediaType:TMediaType):Integer;
|
|
|
|
function AddVolume(AVolume:TDiskVolume):Boolean;
|
|
function RemoveVolume(AVolume:TDiskVolume):Boolean;
|
|
function CheckVolume(AVolume:TDiskVolume; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetVolumeByNo(AVolumeNo:Integer; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeByParent(const AParent:String; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumesByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TList;
|
|
function GetVolumeByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumesByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TList;
|
|
function GetVolumeByNext(APrevious:TDiskVolume; ALock,AUnlock:Boolean; AState:LongWord):TDiskVolume;
|
|
|
|
function GetNextVolumeNo:Integer;
|
|
function GetMaxVolumeNo:Integer;
|
|
|
|
function AddDevice(ADevice:TDiskDevice):Boolean;
|
|
function RemoveDevice(ADevice:TDiskDevice):Boolean;
|
|
function CheckDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetDeviceByNo(ADeviceNo:Integer; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceByImage(AImage:TDiskImage; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceByStorage(AStorage:PStorageDevice; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceByController(AController:TDiskController; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDevicesByController(AController:TDiskController; ALock:Boolean; AState:LongWord):TList;
|
|
function GetDeviceByIdentifier(AController:TDiskController; const AIdentifier:String; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceByNext(APrevious:TDiskDevice; ALock,AUnlock:Boolean; AState:LongWord):TDiskDevice;
|
|
|
|
function GetNextDeviceNo(AMediaType:TMediaType):Integer;
|
|
function GetMaxDeviceNo(AMediaType:TMediaType):Integer;
|
|
|
|
function AddPartition(APartition:TDiskPartition):Boolean;
|
|
function RemovePartition(APartition:TDiskPartition):Boolean;
|
|
function CheckPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetPartitionByNo(ADevice:TDiskDevice; APartitionNo:Integer; AExtended,ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionByName(ADevice:TDiskDevice; const AName:String; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionByPath(const APath:String; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionByEntryNo(ADevice:TDiskDevice; APartition:TDiskPartition; AEntryNo:Integer; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionsByDevice(ADevice:TDiskDevice; ALock:Boolean; AState:LongWord):TList;
|
|
function GetPartitionByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionsByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TList;
|
|
function GetPartitionByNext(APrevious:TDiskPartition; ALock,AUnlock:Boolean; AState:LongWord):TDiskPartition;
|
|
|
|
function GetNextPartitionNo(ADevice:TDiskDevice; AExtended:Boolean):Integer;
|
|
function GetMaxPartitionNo(ADevice:TDiskDevice; AExtended:Boolean):Integer;
|
|
|
|
function AddController(AController:TDiskController):Boolean;
|
|
function RemoveController(AController:TDiskController):Boolean;
|
|
function CheckController(AController:TDiskController; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetControllerByNo(AControllerNo:Integer; ALock:Boolean; AState:LongWord):TDiskController;
|
|
function GetControllerByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskController;
|
|
function GetControllerByNext(APrevious:TDiskController; ALock,AUnlock:Boolean; AState:LongWord):TDiskController;
|
|
|
|
function GetNextControllerNo:Integer;
|
|
function GetMaxControllerNo:Integer;
|
|
|
|
function AddRecognizer(ARecognizer:TRecognizer):Boolean;
|
|
function RemoveRecognizer(ARecognizer:TRecognizer):Boolean;
|
|
function CheckRecognizer(ARecognizer:TRecognizer; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetRecognizerByImage(AImage:TDiskImage; ALock:Boolean; AState:LongWord):TRecognizer;
|
|
function GetRecognizerByVolume(AVolume:TDiskVolume; ALock:Boolean; AState:LongWord):TRecognizer;
|
|
function GetRecognizerByPartition(APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TRecognizer;
|
|
function GetRecognizerByPartitionId(APartitionId:Byte; ALock:Boolean; AState:LongWord):TRecognizer;
|
|
function GetRecognizerByBootSector(ABootSector:PBootSector; const AStartSector,ASectorCount:Int64; ALock:Boolean; AState:LongWord):TRecognizer;
|
|
function GetRecognizerByNext(APrevious:TRecognizer; ALock,AUnlock:Boolean; AState:LongWord):TRecognizer;
|
|
|
|
function AddRedirector(ARedirector:TRedirector):Boolean;
|
|
function RemoveRedirector(ARedirector:TRedirector):Boolean;
|
|
function CheckRedirector(ARedirector:TRedirector; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetRedirectorByPath(const APath:String; ALock:Boolean; AState:LongWord):TRedirector;
|
|
function GetRedirectorByDrive(ADrive:TDiskDrive; ALock:Boolean; AState:LongWord):TRedirector;
|
|
function GetRedirectorByNext(APrevious:TRedirector; ALock,AUnlock:Boolean; AState:LongWord):TRedirector;
|
|
|
|
function AddFileSystem(AFileSystem:TFileSystem):Boolean;
|
|
function RemoveFileSystem(AFileSystem:TFileSystem):Boolean;
|
|
function CheckFileSystem(AFileSystem:TFileSystem; ALock:Boolean; AState:LongWord):Boolean;
|
|
|
|
function GetFileSystemByDrive(ADrive:TDiskDrive; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemByVolume(AVolume:TDiskVolume; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemByRootName(const AName:String; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemByRootPath(const APath:String; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemByNext(APrevious:TFileSystem; ALock,AUnlock:Boolean; AState:LongWord):TFileSystem;
|
|
|
|
function LocateDevices:Boolean;
|
|
function LocatePartitions:Boolean;
|
|
function LocateVolumes:Boolean;
|
|
function LocateDrives:Boolean;
|
|
|
|
function OpenRawHandle(ADevice:TDiskDevice; APartition:TDiskPartition; AVolume:TDiskVolume; ADrive:TDiskDrive; AMode:Integer; ALock:Boolean; AState:LongWord):TRawHandle;
|
|
function CloseRawHandle(AHandle:TRawHandle):Boolean;
|
|
function GetRawHandleByNext(APrevious:TRawHandle; ALock,AUnlock:Boolean; AState:LongWord):TRawHandle;
|
|
|
|
function ReleaseRawHandles(ADevice:TDiskDevice; APartition:TDiskPartition; AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean;
|
|
|
|
function OpenEnumHandle(AFileSystem:TFileSystem; ALock:Boolean; AState:LongWord):TEnumHandle;
|
|
function CloseEnumHandle(AHandle:TEnumHandle):Boolean;
|
|
function GetEnumHandleByNext(APrevious:TEnumHandle; ALock,AUnlock:Boolean; AState:LongWord):TEnumHandle;
|
|
|
|
function UpdateEnumHandles(ADevice:TDiskDevice; APartition:TDiskPartition; ADrive:TDiskDrive; AVolume:TDiskVolume; AImage:TDiskImage; ACatalog:TDiskCatalog):Boolean;
|
|
function ReleaseEnumHandles(AFileSystem:TFileSystem):Boolean;
|
|
|
|
function OpenFileHandle(AVolume:TDiskVolume; ADrive:TDiskDrive; AParent,AEntry:TDiskEntry; AMode:Integer; ALock:Boolean; AState:LongWord):TFileHandle;
|
|
function CloseFileHandle(AHandle:TFileHandle):Boolean;
|
|
function GetFileHandleByNext(APrevious:TFileHandle; ALock,AUnlock:Boolean; AState:LongWord):TFileHandle;
|
|
|
|
function CheckFileHandles(AEntry:TDiskEntry):Boolean;
|
|
function ReleaseFileHandles(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean;
|
|
function DismountFileHandles(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean;
|
|
|
|
function OpenFindHandle(AVolume:TDiskVolume; ADrive:TDiskDrive; AParent:TDiskEntry; const AMask:String; AAttr,AFlags:LongWord; ALock:Boolean; AState:LongWord):TFindHandle;
|
|
function CloseFindHandle(AHandle:TFindHandle):Boolean;
|
|
function GetFindHandleByNext(APrevious:TFindHandle; ALock,AUnlock:Boolean; AState:LongWord):TFindHandle;
|
|
|
|
function UpdateFindHandles(AEntry:TDiskEntry):Boolean;
|
|
function ReleaseFindHandles(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean;
|
|
function DismountFindHandles(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean;
|
|
|
|
function LockMedia(const AName:String):Boolean;
|
|
function UnlockMedia(const AName:String):Boolean;
|
|
function EjectMedia(const AName:String):Boolean;
|
|
|
|
function MediaReady(const AName:String):Boolean;
|
|
function MediaChanged(const AName:String):Boolean;
|
|
function MediaLocked(const AName:String):Boolean;
|
|
|
|
function InsertDevice(const AName:String):Boolean;
|
|
function EjectDevice(const AName:String):Boolean;
|
|
|
|
function OpenDevice(const AName:String; AMode:Integer):Integer;
|
|
procedure CloseDevice(AHandle:Integer);
|
|
function ReadDevice(AHandle:Integer; var ABuffer; ACount:Integer):Integer;
|
|
function WriteDevice(AHandle:Integer; const ABuffer; ACount:Integer):Integer;
|
|
function EraseDevice(AHandle:Integer; ACount:Integer):Integer;
|
|
function SeekDevice(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64;
|
|
|
|
function FindFirstDevice(var ASearchRec:TDiskSearchRec; AVerbose:Boolean):Integer;
|
|
function FindNextDevice(var ASearchRec:TDiskSearchRec):Integer;
|
|
procedure FindDeviceClose(var ASearchRec:TDiskSearchRec);
|
|
|
|
function CreatePartition(const ADevice,AParent:String; APartitionId:Byte; ACount:LongWord; AActive:Boolean):Boolean;
|
|
function DeletePartition(const APath:String):Boolean;
|
|
function ModifyPartition(const APath:String; APartitionId:Byte):Boolean;
|
|
function ActivatePartition(const APath:String; AActive:Boolean):Boolean;
|
|
function ShrinkPartition(const APath:String; const AStart,ASize:Int64):Boolean;
|
|
function ExpandPartition(const APath:String; const AStart,ASize:Int64):Boolean;
|
|
|
|
function OpenPartition(const APath:String; AMode:Integer):Integer;
|
|
procedure ClosePartition(AHandle:Integer);
|
|
function ReadPartition(AHandle:Integer; var ABuffer; ACount:Integer):Integer;
|
|
function WritePartition(AHandle:Integer; const ABuffer; ACount:Integer):Integer;
|
|
function SeekPartition(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64;
|
|
|
|
function FindFirstPartition(const ADevice:String; var ASearchRec:TPartitionSearchRec; AVerbose:Boolean):Integer;
|
|
function FindNextPartition(var ASearchRec:TPartitionSearchRec):Integer;
|
|
procedure FindPartitionClose(var ASearchRec:TPartitionSearchRec);
|
|
|
|
function CreateVolume(const AParent:String; ADriveNo:Integer):Boolean;
|
|
function DeleteVolume(Const AName:String):Boolean;
|
|
function MountVolume(const AName:String; ADriveNo:Integer):Boolean;
|
|
function DismountVolume(const AName:String):Boolean;
|
|
function FormatVolume(const AName:String; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean;
|
|
function DefragmentVolume(const AName:String):Boolean;
|
|
function ConvertVolume(const AName:String; AFileSysType:TFileSysType):Boolean;
|
|
function RepairVolume(const AName:String):Boolean;
|
|
function CopyVolume(const AName,ADest:String):Boolean;
|
|
function ShrinkVolume(const AName:String; const AStart,ASize:Int64):Boolean;
|
|
function ExpandVolume(const AName:String; const AStart,ASize:Int64):Boolean;
|
|
|
|
function OpenVolume(const AName:String; AMode:Integer):Integer;
|
|
procedure CloseVolume(AHandle:Integer);
|
|
function ReadVolume(AHandle:Integer; var ABuffer; ACount:Integer):Integer;
|
|
function WriteVolume(AHandle:Integer; const ABuffer; ACount:Integer):Integer;
|
|
function SeekVolume(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64;
|
|
|
|
function FindFirstVolume(var ASearchRec:TVolumeSearchRec; AVerbose:Boolean):Integer;
|
|
function FindNextVolume(var ASearchRec:TVolumeSearchRec):Integer;
|
|
procedure FindVolumeClose(var ASearchRec:TVolumeSearchRec);
|
|
|
|
function CreateDrive(const AName,AParent:String):Boolean;
|
|
function DeleteDrive(const AName:String):Boolean;
|
|
function FormatDrive(const AName:String; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean;
|
|
|
|
function OpenDrive(const AName:String; AMode:Integer):Integer;
|
|
procedure CloseDrive(AHandle:Integer);
|
|
function ReadDrive(AHandle:Integer; var ABuffer; ACount:Integer):Integer;
|
|
function WriteDrive(AHandle:Integer; const ABuffer; ACount:Integer):Integer;
|
|
function SeekDrive(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64;
|
|
|
|
function FindFirstDrive(var ASearchRec:TDriveSearchRec; AVerbose:Boolean):Integer;
|
|
function FindNextDrive(var ASearchRec:TDriveSearchRec):Integer;
|
|
procedure FindDriveClose(var ASearchRec:TDriveSearchRec);
|
|
|
|
function MountImage(AImageNo:Integer):Boolean;
|
|
function DismountImage(AImageNo:Integer):Boolean;
|
|
function InsertImage(AImageNo:Integer):Boolean;
|
|
function EjectImage(AImageNo:Integer):Boolean;
|
|
function ConvertImage(AImageNo:Integer; AImageType:TImageType):Boolean;
|
|
function CopyImage(AImageNo,ADestNo:Integer):Boolean;
|
|
function ShrinkImage(AImageNo:Integer; const ASize:Int64):Boolean;
|
|
function ExpandImage(AImageNo:Integer; const ASize:Int64):Boolean;
|
|
|
|
function CreateImage(AImageNo:Integer; const AName:String; AImageType:TImageType; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer;
|
|
function OpenImage(AImageNo:Integer;const AName:String; AImageType:TImageType; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer;
|
|
function CloseImage(AImageNo:Integer):Boolean;
|
|
|
|
function CreateSnapshot(AImageNo:Integer):Boolean;
|
|
function DeleteSnapshot(AImageNo:Integer):Boolean;
|
|
function MergeSnapshot(AImageNo:Integer):Boolean;
|
|
|
|
function FindFirstImage(var ASearchRec:TImageSearchRec; AVerbose:Boolean):Integer;
|
|
function FindNextImage(var ASearchRec:TImageSearchRec):Integer;
|
|
procedure FindImageClose(var ASearchRec:TImageSearchRec);
|
|
|
|
function CreateCatalog(const APath,AName:String; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):LongWord;
|
|
function DeleteCatalog(const APath:String; ACatalogNo:LongWord):Boolean;
|
|
|
|
function FindFirstCatalog(const APath:String; var ASearchRec:TCatalogSearchRec):Integer;
|
|
function FindNextCatalog(var ASearchRec:TCatalogSearchRec):Integer;
|
|
procedure FindCatalogClose(var ASearchRec:TCatalogSearchRec);
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function ScheduleEntry(AEntry:TDiskEntry; ATimeout:LongWord):Boolean;
|
|
function UnscheduleEntry(AEntry:TDiskEntry):Boolean;
|
|
|
|
function GetPathDrive(const APath:String):Byte;
|
|
function GetDriveType(ADrive:Byte):TDriveType;
|
|
function GetDriveData(ADrive:Byte):TDriveData;
|
|
function GetDriveAttr(ADrive:Byte):LongWord;
|
|
function GetDriveLabel(ADrive:Byte):String;
|
|
function SetDriveLabel(ADrive:Byte; const ALabel:String):Boolean;
|
|
function GetDriveSerial(ADrive:Byte):LongWord;
|
|
function SetDriveSerial(ADrive:Byte; ASerial:LongWord):Boolean;
|
|
function IsDriveValid(ADrive:Byte):Boolean;
|
|
function GetValidDrives:LongWord;
|
|
function GetValidDriveNames:TStringList;
|
|
function GetValidDriveStrings:String;
|
|
function GetDriveFreeSpace(ADrive:Byte):LongWord;
|
|
function GetDriveFreeSpaceEx(ADrive:Byte):Int64;
|
|
function GetDriveTotalSpace(ADrive:Byte):LongWord;
|
|
function GetDriveTotalSpaceEx(ADrive:Byte):Int64;
|
|
|
|
function GetCurrentDrive:Byte;
|
|
function SetCurrentDrive(const ADrive:String):Boolean;
|
|
|
|
function GetPathVolume(const APath:String):String;
|
|
function GetVolumeType(const AVolume:String):TDriveType;
|
|
function GetVolumeData(const AVolume:String):TDriveData;
|
|
function GetVolumeAttr(const AVolume:String):LongWord;
|
|
function GetVolumeLabel(const AVolume:String):String;
|
|
function SetVolumeLabel(const AVolume:String; const ALabel:String):Boolean;
|
|
function GetVolumeSerial(const AVolume:String):LongWord;
|
|
function SetVolumeSerial(const AVolume:String; ASerial:LongWord):Boolean;
|
|
function IsVolumeValid(const AVolume:String):Boolean;
|
|
function GetValidVolumeNames:TStringList;
|
|
function GetVolumeFreeSpace(const AVolume:String):LongWord;
|
|
function GetVolumeFreeSpaceEx(const AVolume:String):Int64;
|
|
function GetVolumeTotalSpace(const AVolume:String):LongWord;
|
|
function GetVolumeTotalSpaceEx(const AVolume:String):Int64;
|
|
|
|
function FileOpen(const AFileName:String; AMode:Integer):Integer;
|
|
function FileCreate(const AFileName:String):Integer;
|
|
function DeleteFile(const AFileName:String):Boolean;
|
|
procedure FileClose(AHandle:Integer);
|
|
function RenameFile(const AOldName,ANewName:String):Boolean;
|
|
function FileSeek(AHandle,AOffset,AOrigin:Integer):Integer;
|
|
function FileFlush(AHandle:Integer):Boolean;
|
|
function FileTruncate(AHandle:Integer):Boolean;
|
|
function SetEndOfFile(AHandle:Integer):Boolean;
|
|
|
|
function EndOfFile(AHandle:Integer):Boolean;
|
|
function FilePos(AHandle:Integer):Integer;
|
|
function FileSize(AHandle:Integer):Integer;
|
|
|
|
function FileAge(const AFileName:String):Integer;
|
|
function FileExists(const AFileName:String):Boolean;
|
|
function FileGetAttr(const AFileName:String):Integer;
|
|
function FileGetDate(AHandle:Integer):Integer;
|
|
function FileSetAttr(const AFileName:String; AAttr:Integer):Integer;
|
|
function FileSetDate(AHandle:Integer; AAge:Integer):Integer;
|
|
|
|
function FileRead(AHandle:Integer; var ABuffer; ACount:Integer):Integer;
|
|
function FileWrite(AHandle:Integer; const ABuffer; ACount:Integer):Integer;
|
|
|
|
function CreateDir(const ADirName:String):Boolean;
|
|
function RemoveDir(const ADirName:String):Boolean;
|
|
function RenameDir(const AOldName,ANewName:String):Boolean;
|
|
function GetCurrentDir:String;
|
|
function GetCurrentDirEx(ADrive:Byte):String;
|
|
function SetCurrentDir(const ADirName:String):Boolean;
|
|
function DirectoryExists(const ADirName:String):Boolean;
|
|
procedure ForceDirectories(ADirName:String);
|
|
procedure DeleteTree(const ADirName:String);
|
|
|
|
function FindFirst(const APath:String; AAttr:Integer; var ASearchRec:TSearchRec):Integer;
|
|
function FindNext(var ASearchRec:TSearchRec):Integer;
|
|
procedure FindClose(var ASearchRec:TSearchRec);
|
|
|
|
function FindFirstStream(const AFileName:String; var ASearchRec:TStreamSearchRec):Integer;
|
|
function FindNextStream(var ASearchRec:TStreamSearchRec):Integer;
|
|
procedure FindStreamClose(var ASearchRec:TStreamSearchRec);
|
|
|
|
function FindFirstFileName(const AFileName:String; var ASearchRec:TLinkSearchRec):Integer;
|
|
function FindNextFileName(var ASearchRec:TLinkSearchRec):Integer;
|
|
procedure FindFileNameClose(var ASearchRec:TLinkSearchRec);
|
|
|
|
function CreateHardLink(const ALinkName,AFileName:String):Boolean;
|
|
function DeleteHardLink(const ALinkName:String):Boolean;
|
|
|
|
function MountPointExists(const APathName:String):Boolean;
|
|
function CreateMountPoint(const APathName,AVolumeName:String):Boolean;
|
|
function DeleteMountPoint(const APathName:String):Boolean;
|
|
|
|
function JunctionPointExists(const APathName:String):Boolean;
|
|
function CreateJunctionPoint(const APathName,AFolderName:String):Boolean;
|
|
function DeleteJunctionPoint(const APathName:String):Boolean;
|
|
|
|
function SymbolicLinkExists(const ALinkName:String):Boolean;
|
|
function CreateSymbolicLink(const ALinkName,ATargetName:String; ADirectory:Boolean):Boolean;
|
|
function CreateSymbolicLinkEx(const ALinkName,AShortName,ATargetName:String; ADirectory:Boolean):Boolean;
|
|
function DeleteSymbolicLink(const ALinkName:String):Boolean;
|
|
|
|
function GetMountPointTarget(const APathName:String):String;
|
|
function GetJunctionPointTarget(const APathName:String):String;
|
|
function GetSymbolicLinkTarget(const ALinkName:String):String;
|
|
|
|
function SetFileShortName(const AFileName,AShortName:String):Boolean;
|
|
function SetFileShortNameEx(AHandle:Integer; const AShortName:String):Boolean;
|
|
|
|
function GetFileSecurity(const AFileName:String; ADescriptor:Pointer; var ASize:LongWord):Boolean;
|
|
function SetFileSecurity(const AFileName:String; ADescriptor:Pointer):Boolean;
|
|
|
|
function FileCopy(const ASourceFile,ADestFile:String; AFailIfExists:Boolean):Boolean;
|
|
function FileCopyEx(const ASourceFile,ADestFile:String; AFailIfExists:Boolean; AUseSourceDate:Boolean; ADestDate:Integer; AUseSourceAttr:Boolean; ADestAttr:Integer):Boolean;
|
|
|
|
function FileMove(const ASourceFile,ADestFile:String; AFailIfExists:Boolean):Boolean;
|
|
function FileMoveEx(const ASourceFile,ADestFile:String; AFailIfExists:Boolean; AUseSourceDate:Boolean; ADestDate:Integer; AUseSourceAttr:Boolean; ADestAttr:Integer):Boolean;
|
|
|
|
function GetPathName(const AFileName:String):String;
|
|
|
|
function GetShortName(const AFileName:String):String;
|
|
function GetLongName(const AFileName:String):String;
|
|
function GetTrueName(const AFileName:String):String;
|
|
|
|
function AddSlash(const AFilePath:String; ALeading,ATrailing:Boolean):String;
|
|
function DeleteSlash(const AFilePath:String; ALeading,ATrailing:Boolean):String;
|
|
|
|
function FileCreateEx(const AFileName,AShortName:String):Integer;
|
|
function CreateDirEx(const ADirName,AShortName:String):Boolean;
|
|
|
|
function FileSeekEx(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64;
|
|
|
|
function EndOfFileEx(AHandle:Integer):Boolean;
|
|
function FilePosEx(AHandle:Integer):Int64;
|
|
function FileSizeEx(AHandle:Integer):Int64;
|
|
|
|
function FileAgeEx(const AFileName:String):TFileTime;
|
|
|
|
function FileGetAttrEx(AHandle:Integer):Integer;
|
|
|
|
function FileGetDateEx(AHandle:Integer):TFileTime;
|
|
function FileSetDateEx(AHandle:Integer ;AAge:TFileTime):Integer;
|
|
|
|
function GetFileTime(AHandle:Integer; ACreateTime,AAccessTime,AWriteTime:PFileTime):Boolean;
|
|
function SetFileTime(AHandle:Integer; ACreateTime,AAccessTime,AWriteTime:PFileTime):Boolean;
|
|
|
|
function FindOne(const APath:String; var ASearchRec:TFileSearchRec):Integer;
|
|
function FindAll(const APath:String; var ASearchRec:TFileSearchRec):Integer;
|
|
|
|
function FindFirstEx(const APath:String; var ASearchRec:TFileSearchRec):Integer;
|
|
function FindNextEx(var ASearchRec:TFileSearchRec):Integer;
|
|
procedure FindCloseEx(var ASearchRec:TFileSearchRec);
|
|
|
|
function DefineDosDevice(const ADeviceName,ATargetPath:String; AFlags:LongWord):Boolean;
|
|
function GetDiskType(const ARootPath:String):LongWord;
|
Equivalent to Win32 GetDriveType
|
function GetDiskFreeSpace(const ARootPath:String; var ASectorsPerCluster,ABytesPerSector,ANumberOfFreeClusters,ATotalNumberOfClusters:LongWord):Boolean;
|
|
function GetDiskFreeSpaceEx(const APathName:String; var AFreeBytesAvailableToCaller,ATotalNumberOfBytes,ATotalNumberOfFreeBytes:Int64):Boolean;
|
|
function GetLogicalDrives:LongWord;
|
|
function GetLogicalDriveStrings:String;
|
|
function GetVolumeInformation(const ARootPath:String; var AVolumeName:String; var AVolumeSerialNumber,AMaximumComponentLength,AFileSystemFlags:LongWord; var ASystemName:String):Boolean;
|
|
function QueryDosDevice(const ARootPath:String):String;
|
|
function SetVolumeLabel
|
Already Defined
|
|
|
function AreFileApisANSI:Boolean;
|
|
function CloseFile(AHandle:THandle):Boolean;
|
Equivalent to Win32 CloseHandle
|
function CopyFile(const AExistingName,ANewName:String; AFailIfExists:Boolean):Boolean;
|
|
function CreateFile(const AFileName:String; AAccessMode,AShareMode,ACreateFlags,AFileAttributes:LongWord):THandle;
|
|
function DeleteFile
|
Already Defined
|
function FindCloseFile(AHandle:THandle):Boolean;
|
Equivalent to Win32 FindClose
|
function FindFirstFile(const AFileName:String; var AFindData:TWin32FindData):THandle;
|
|
function FindNextFile(AHandle:THandle; var AFindData:TWin32FindData):Boolean;
|
|
function FlushFileBuffers(AHandle:THandle):Boolean;
|
|
function GetBinaryType
|
|
function GetFileAttributes(const AFileName:String):LongWord;
|
|
function GetFileInformationByHandle
|
|
function GetFileSize(AHandle:THandle; var AFileSizeHigh:LongWord):LongWord;
|
|
function GetFileSizeEx
|
Same as FileSizeEx
|
function GetFileTime
|
Already Defined
|
function GetFileType
|
|
function GetFullPathName(const AFileName:String):String;
|
|
function GetShortPathName(const ALongPath:String):String;
|
|
function GetTempDrive
|
|
function GetTempFileName
|
|
function GetTempPath
|
|
function LockFile
|
|
function LockFileEx
|
|
function MoveFile(const AExistingName,ANewName:String):Boolean;
|
|
function MoveFileEx
|
|
function ReadFile(AHandle:THandle; var ABuffer; ABytesToRead:LongWord; var ABytesRead:LongWord):Boolean;
|
|
function ReadFileEx
|
|
function SearchPath
|
|
function SetEndOfFile
|
Already Defined
|
function SetFileApisToANSI:Boolean;
|
|
function SetFileApisToOEM:Boolean;
|
|
function SetFileAttributes(const AFileName:String; AFileAttributes:LongWord):Boolean;
|
|
function SetFilePointer(AHandle:THandle; ADistanceToMove:LongWord; var ADistanceToMoveHigh:LongWord; AMoveMethod:LongWord):LongWord;
|
|
function SetFilePointerEx(AHandle:THandle; const ADistanceToMove:Int64; var ANewFilePointer:Int64; AMoveMethod:LongWord):Boolean;
|
|
function SetFileTime
|
Already Defined
|
function SetHandleCount
|
|
function UnlockFile
|
|
function UnlockFileEx
|
|
function WriteFile(AHandle:THandle; const ABuffer; ABytesToWrite:LongWord; var ABytesWritten:LongWord):Boolean;
|
|
function WriteFileEx
|
|
function GetLongPathName(const AShortPath:String):String;
|
|
function SetFileShortName
|
Already Defined
|
|
|
function CreateDirectory(const APathName:String):Boolean;
|
|
function CreateDirectoryEx
|
|
function GetCurrentDirectory:String;
|
|
function RemoveDirectory(const APathName:String):Boolean;
|
|
function SetCurrentDirectory(const APathName:String):Boolean;
|
|
|
|
function FindFirstStream
|
Already Defined
|
function FindNextStream
|
Already Defined
|
|
|
function CreateHardlink
|
Already Defined
|
function FindFirstFileName
|
Already Defined
|
function FindNextFileName
|
Already Defined
|
|
|
function SetVolumeMountPoint
|
|
function DeleteVolumeMountPoint
|
|
function FindFirstVolumeMountPoint
|
|
function FindNextVolumeMountPoint
|
|
function FindVolumeMountPointClose
|
|
|
|
function CreateSymbolicLink
|
Already Defined
|
|
|
function FindFirstVolume
|
Already Defined
|
function FindNextVolume
|
Already Defined
|
function FindVolumeClose
|
Already Defined
|
|
|
function GetFileSecurity
|
Already Defined
|
function SetFileSecurity
|
Already Defined
|
function GetNamedSecurityInfo
|
|
function SetNamedSecurityInfo
|
|
|
|
function GetDeviceFromRaw(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
function GetDeviceFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDevice;
|
|
|
|
function GetPartitionFromRaw(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetPartitionFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
|
|
function GetVolumeFromPath(const APath:String; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeFromRaw(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeFromFile(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
function GetVolumeFromFind(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskVolume;
|
|
|
|
function GetDriveFromPath(const APath:String; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveFromRaw(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveFromFile(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
function GetDriveFromFind(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskDrive;
|
|
|
|
function GetImageFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskImage;
|
|
|
|
function GetCatalogFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TDiskCatalog;
|
|
|
|
function GetFileSystemFromPath(const APath:String; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemFromEnum(AHandle:Integer; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemFromFile(AHandle:Integer; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
function GetFileSystemFromFind(AHandle:Integer; ALock:Boolean; AState:LongWord):TFileSystem;
|
|
|
|
function GetRawFromHandle(AHandle:Integer; ALock:Boolean; AState:LongWord):TRawHandle;
|
|
function GetEnumFromHandle(AHandle:Integer; ALock:Boolean; AState:LongWord):TEnumHandle;
|
|
function GetFileFromHandle(AHandle:Integer; ALock:Boolean; AState:LongWord):TFileHandle;
|
|
function GetFindFromHandle(AHandle:Integer; ALock:Boolean; AState:LongWord):TFindHandle;
|
|
File system list
[Expand]
TFileSysList = class(TLinkedObjList)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
procedure ClearList;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
File system list extended
[Expand]
TFileSysListEx = class(TLinkedObjList)
constructor Create(ALock:TSynchronizerHandle);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
procedure ClearList;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
File system tree
[Expand]
TFileSysTree = class(TLinkedObjTree)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
procedure ClearList;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
Disk drive
[Expand]
TDiskDrive = class(TListObject)
constructor Create(ADriver:TFileSysDriver; AVolume:TDiskVolume; ADriveNo:Integer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FVolume:TDiskVolume;
|
|
|
|
FDriveNo:Integer;
|
|
|
|
FDriveType:TDriveType;
|
|
|
|
FFileSystem:TFileSystem;
|
|
|
|
FRemovable:Boolean;
|
Drive is removable - Set by DriveInit
|
FRecognizable:Boolean;
|
Drive allows Recognize Drive
|
FRecognized:Boolean;
|
Recognized Drive - Set by Recognizer
|
|
|
FSectorSize:Word;
|
Sector Size of Drive or Device
|
FStartSector:Int64;
|
Start Sector on Drive or Device
|
FSectorCount:LongWord;
|
Total Sectors in Drive
|
FSectorShiftCount:Word;
|
Sectors to Bytes Shift Count
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String;
|
|
function GetRoot:String;
|
|
function GetParent:String;
|
|
|
|
function GetMaxFile:Integer;
|
|
function GetMaxPath:Integer;
|
|
function GetAttributes:LongWord;
|
|
function GetSystemName:String;
|
|
function GetVolumeName:String;
|
|
function GetVolumeGUID:String;
|
|
function GetVolumeSerial:LongWord;
|
|
|
|
function GetDriveType:TDriveType;
|
|
function GetFileSysType:TFileSysType;
|
|
|
|
procedure SetFileSystem(AFileSystem:TFileSystem);
|
|
|
|
function GetRemovable:Boolean;
|
|
function GetRecognizable:Boolean;
|
|
function GetRecognized:Boolean;
|
|
|
|
function GetSectorSize:Word;
|
|
function GetStartSector:Int64;
|
|
function GetSectorCount:LongWord;
|
|
function GetSectorShiftCount:Word;
|
|
|
|
function GetDevice:TDiskDevice;
|
|
function GetPartition:TDiskPartition;
|
|
|
|
function GetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
function SetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
public
|
property Name:String read GetName;
|
|
property Root:String read GetRoot;
|
|
property Parent:String read GetParent;
|
|
property Volume:TDiskVolume read FVolume;
|
|
property DriveNo:Integer read FDriveNo;
|
|
|
|
property MaxFile:Integer read GetMaxFile;
|
|
property MaxPath:Integer read GetMaxPath;
|
|
property Attributes:LongWord read GetAttributes;
|
|
property SystemName:String read GetSystemName;
|
|
property VolumeName:String read GetVolumeName;
|
|
property VolumeGUID:String read GetVolumeGUID;
|
|
property VolumeSerial:LongWord read GetVolumeSerial;
|
|
|
|
property DriveType:TDriveType read GetDriveType;
|
|
property FileSysType:TFileSysType read GetFileSysType;
|
|
|
|
property FileSystem:TFileSystem read FFileSystem write SetFileSystem;
|
|
|
|
property Removable:Boolean read GetRemovable;
|
|
property Recognizable:Boolean read GetRecognizable;
|
|
property Recognized:Boolean read GetRecognized write FRecognized;
|
|
|
|
property SectorSize:Word read GetSectorSize;
|
|
property StartSector:Int64 read GetStartSector;
|
|
property SectorCount:LongWord read GetSectorCount;
|
|
property SectorShiftCount:Word read GetSectorShiftCount;
|
|
|
|
property Device:TDiskDevice read GetDevice;
|
|
property Partition:TDiskPartition read GetPartition;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function DriveInit:Boolean; virtual;
|
|
Raw handle
[Expand]
TRawHandle = class(TListObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
Device:TDiskDevice;
|
|
Partition:TDiskPartition;
|
|
Volume:TDiskVolume;
|
|
Drive:TDiskDrive;
|
|
|
|
OpenMode:Integer;
|
|
ShareMode:Integer;
|
|
|
|
Size:Int64;
|
|
Position:Int64;
|
|
Handle:Integer;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
Enumerate handle
[Expand]
TEnumHandle = class(TListObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
FileSystem:TFileSystem;
|
|
|
|
Handle:Integer;
|
|
|
|
CurrentDevice:TDiskDevice;
|
|
CurrentPartition:TDiskPartition;
|
|
CurrentDrive:TDiskDrive;
|
|
CurrentVolume:TDiskVolume;
|
|
CurrentImage:TDiskImage;
|
|
CurrentCatalog:TDiskCatalog;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
File handle
[Expand]
TFileHandle = class(TListObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
Volume:TDiskVolume;
|
|
Drive:TDiskDrive;
|
|
|
|
OpenMode:Integer;
|
|
ShareMode:Integer;
|
|
|
|
Position:Int64;
|
|
Handle:Integer;
|
|
|
|
DataValue:LongWord;
|
Available to FileSystem for private use
|
DataOffset:LongWord;
|
Available to FileSystem for private use
|
|
|
ParentEntry:TDiskEntry;
|
|
HandleEntry:TDiskEntry;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
Find handle
[Expand]
TFindHandle = class(TListObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
public
|
Volume:TDiskVolume;
|
|
Drive:TDiskDrive;
|
|
|
|
Any:Boolean;
|
|
Mask:String;
|
|
Attr:LongWord;
|
|
Flags:LongWord;
|
|
Handle:Integer;
|
|
|
|
ParentEntry:TDiskEntry;
|
|
CurrentEntry:TDiskEntry;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
Disk controller
[Expand]
TDiskController = class(TListObject)
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
|
|
FControllerNo:Integer;
|
\Controller0, \Controller1 etc - See Notes
|
FDescription:String;
|
Description of Controller - eg "Standard ATA Controller"
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String;
|
|
function GetDescription:String;
|
|
function GetFixedDiskCount:Integer; virtual;
|
|
function GetFloppyDiskCount:Integer; virtual;
|
|
function LCHStoLBA(ADevice:TDiskDevice; Cylinder,Head,Sector:Word; var LBA:LongWord):Boolean;
|
|
function PCHStoLBA(ADevice:TDiskDevice; Cylinder,Head,Sector:LongWord; var LBA:LongWord):Boolean;
|
|
function LBAtoLCHS(ADevice:TDiskDevice; LBA:LongWord; var Cylinder,Head,Sector:Word):Boolean;
|
|
function LBAtoPCHS(ADevice:TDiskDevice; LBA:LongWord; var Cylinder,Head,Sector:LongWord):Boolean;
|
|
function LCHStoPCHS(ADevice:TDiskDevice; LCylinder,LHead,LSector:Word; var PCylinder,PHead,PSector:LongWord):Boolean;
|
|
function PCHStoLCHS(ADevice:TDiskDevice; PCylinder,PHead,PSector:LongWord; var LCylinder,LHead,LSector:Word):Boolean;
|
|
public
|
property Name:String read GetName;
|
|
property ControllerNo:Integer read FControllerNo;
|
|
property Description:String read GetDescription;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
|
|
function ControllerInit:Boolean; virtual;
|
|
|
|
function LocateDevices:Boolean; virtual;
|
|
|
|
function Read(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean; virtual;
|
|
function Write(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; const ABuffer):Boolean; virtual;
|
|
function Erase(ADevice:TDiskDevice; ASector:LongWord; ACount:Word):Boolean; virtual;
|
|
|
|
function Reset(ADevice:TDiskDevice):Boolean; virtual;
|
|
|
|
function LockMedia(ADevice:TDiskDevice):Boolean; virtual;
|
|
function UnlockMedia(ADevice:TDiskDevice):Boolean; virtual;
|
|
function EjectMedia(ADevice:TDiskDevice):Boolean; virtual;
|
|
|
|
function MediaReady(ADevice:TDiskDevice):Boolean; virtual;
|
|
function MediaChanged(ADevice:TDiskDevice):Boolean; virtual;
|
|
function MediaLocked(ADevice:TDiskDevice):Boolean; virtual;
|
|
|
|
function Information(ADevice:TDiskDevice):String; virtual;
|
|
|
|
function VendorId(ADevice:TDiskDevice):Word; virtual;
|
|
function DeviceId(ADevice:TDiskDevice):Word; virtual;
|
|
|
|
function Manufacturer(ADevice:TDiskDevice):String; virtual;
|
|
function Product(ADevice:TDiskDevice):String; virtual;
|
|
function SerialNumber(ADevice:TDiskDevice):String; virtual;
|
|
|
|
function HostBus(ADevice:TDiskDevice):String; virtual;
|
|
function BusNumber(ADevice:TDiskDevice):Word; virtual;
|
|
function DeviceNumber(ADevice:TDiskDevice):Word; virtual;
|
|
function FunctionNumber(ADevice:TDiskDevice):Word; virtual;
|
|
function BaseAddress(ADevice:TDiskDevice):Word; virtual;
|
|
function InterfaceType(ADevice:TDiskDevice):String; virtual;
|
|
|
|
function Slave(ADevice:TDiskDevice):Boolean; virtual;
|
|
function LogicalUnitNo(ADevice:TDiskDevice):LongWord; virtual;
|
|
function FireWireGUID(ADevice:TDiskDevice):Int64; virtual;
|
|
function WorldWideNo(ADevice:TDiskDevice):Int64; virtual;
|
|
|
|
function PhysicalPort(ADevice:TDiskDevice):Word; virtual;
|
|
function ControlPort(ADevice:TDiskDevice):Word; virtual;
|
|
function IRQ(ADevice:TDiskDevice):LongWord; virtual;
|
|
|
|
function PIO(ADevice:TDiskDevice):Boolean; virtual;
|
|
function DMA(ADevice:TDiskDevice):Boolean; virtual;
|
|
function LBA(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Version(ADevice:TDiskDevice):LongWord; virtual;
|
|
|
|
function MediaType(ADevice:TDiskDevice):TMediaType; virtual;
|
|
function FloppyType(ADevice:TDiskDevice):TFloppyType; virtual;
|
|
function Ready(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Locked(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Lockable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Ejectable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Readable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Writeable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Eraseable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function Removable(ADevice:TDiskDevice):Boolean; virtual;
|
|
function ChangeLine(ADevice:TDiskDevice):Boolean; virtual;
|
|
|
|
function PhysicalCylinders(ADevice:TDiskDevice):LongWord; virtual;
|
|
function PhysicalHeads(ADevice:TDiskDevice):LongWord; virtual;
|
|
function PhysicalSectors(ADevice:TDiskDevice):LongWord; virtual;
|
|
|
|
function LogicalCylinders(ADevice:TDiskDevice):LongWord; virtual;
|
|
function LogicalHeads(ADevice:TDiskDevice):LongWord; virtual;
|
|
function LogicalSectors(ADevice:TDiskDevice):LongWord; virtual;
|
|
|
|
function SectorSize(ADevice:TDiskDevice):Word; virtual;
|
|
function SectorCount(ADevice:TDiskDevice):Int64; virtual;
|
|
function SectorShiftCount(ADevice:TDiskDevice):Word; virtual;
|
|
Disk device
[Expand]
TDiskDevice = class(TListObject)
constructor Create(ADriver:TFileSysDriver; AController:TDiskController; AImage:TDiskImage; AStorage:PStorageDevice; ADeviceNo:Integer; const AIdentifier:String);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FController:TDiskController;
|
|
FImage:TDiskImage;
|
|
FStorage:PStorageDevice;
|
|
|
|
FDeviceNo:Integer;
|
00h, 01h, 80h, 81h etc - See Notes
|
FIdentifier:String;
|
Controller Specific Identifier
|
FInformation:String;
|
Description of Device - eg "Standard ATA Disk"
|
|
|
FVendorId:Word;
|
PCI or USB Vendor Id
|
FDeviceId:Word;
|
PCI or USB Device Id
|
|
|
FManufacturer:String;
|
Device Manufacturer name
|
FProduct:String;
|
Device Product name
|
FSerialNumber:String;
|
Device Serial Number
|
|
|
FHostBus:String;
|
PCI, ISA etc
|
FBusNumber:Word;
|
PCI Bus No
|
FDeviceNumber:Word;
|
PCI Device No
|
FFunctionNumber:Word;
|
PCI Function No
|
FBaseAddress:Word;
|
ISA Base Address
|
FInterfaceType:String;
|
ATA, ATAPI, SCSI, USB, 1394, FIBRE
|
|
|
FSlave:Boolean;
|
Device is Slave
|
FLogicalUnitNo:LongWord;
|
LUN No eg SCSI, ATAPI or USB
|
FFireWireGUID:Int64;
|
FireWire GUID No
|
FWorldWideNo:Int64;
|
Fibre Channel WWN
|
|
|
FPhysicalPort:Word;
|
Physical IO Port
|
FControlPort:Word;
|
Drive Control Port
|
FIRQ:LongWord;
|
IRQ No
|
|
|
FPIO:Boolean;
|
PIO Transfer Enabled
|
FDMA:Boolean;
|
DMA Transfer Enabled
|
FLBA:Boolean;
|
Supports LBA (eg Int13 Extensions)
|
FVersion:LongWord;
|
Version Information (eg Int13 Extensions Version 01h,20h,21h,30h)
|
|
|
FMediaType:TMediaType;
|
Media Type eg Fixed, Removable, Floppy
|
FFloppyType:TFloppyType;
|
Floppy Type eg 360K, 1.44M, ATAPI
|
FReady:Boolean;
|
Media is Inserted in Drive
|
FLocked:Boolean;
|
Media is Locked in Drive
|
FLockable:Boolean;
|
Media is Lockable
|
FEjectable:Boolean;
|
Media is Ejectable
|
FReadable:Boolean;
|
Media is Readable
|
FWriteable:Boolean;
|
Media is Writeable
|
FEraseable:Boolean;
|
Media is Eraseable
|
FRemovable:Boolean;
|
Media is Removable
|
FChangeLine:Boolean;
|
Supports ChangeLine detection
|
|
|
FPhysicalCylinders:LongWord;
|
Physical Cylinders on Drive
|
FPhysicalHeads:LongWord;
|
Physical Heads on Drive
|
FPhysicalSectors:LongWord;
|
Physical Sectors per Track
|
|
|
FLogicalCylinders:LongWord;
|
Logical Cylinders on Drive
|
FLogicalHeads:LongWord;
|
Logical Heads on Drive
|
FLogicalSectors:LongWord;
|
Logical Sectors per Track
|
|
|
FSectorSize:Word;
|
Bytes Per Sector
|
FSectorCount:Int64;
|
Total Sectors
|
FSectorShiftCount:Word;
|
Sectors to Bytes Shift Count
|
|
|
FPageCount:Word;
|
Cache Page Count for this Device
|
FPageShift:Word;
|
Cache Page Shift for this Device
|
FPageMask:LongWord;
|
Cache Page Mask for this Device
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String;
|
|
|
|
function GetIdentifier:String;
|
|
function GetInformation:String;
|
|
|
|
function GetManufacturer:String;
|
|
function GetProduct:String;
|
|
function GetSerialNumber:String;
|
|
|
|
function GetHostBus:String;
|
|
function GetInterfaceType:String;
|
|
|
|
function GetFreeSectors:Int64;
|
Unused Sectors on Device
|
function GetAvailableSectors:Int64;
|
Largest block of Unused Sectors
|
|
|
function GetAvailableBlock(var AStart,ACount:Int64):Boolean;
|
|
|
|
function GetDiskSignature:LongWord; virtual;
|
|
procedure SetDiskSignature(ADiskSignature:LongWord); virtual;
|
|
|
|
function GetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
function SetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
public
|
property Name:String read GetName;
|
|
property Controller:TDiskController read FController;
|
|
property Image:TDiskImage read FImage;
|
|
property Storage:PStorageDevice read FStorage;
|
|
|
|
property DeviceNo:Integer read FDeviceNo;
|
|
property Identifier:String read GetIdentifier;
|
|
property Information:String read GetInformation;
|
|
|
|
property VendorId:Word read FVendorId;
|
|
property DeviceId:Word read FDeviceId;
|
|
|
|
property Manufacturer:String read GetManufacturer;
|
|
property Product:String read GetProduct;
|
|
property SerialNumber:String read GetSerialNumber;
|
|
|
|
property HostBus:String read GetHostBus;
|
|
property BusNumber:Word read FBusNumber;
|
|
property DeviceNumber:Word read FDeviceNumber;
|
|
property FunctionNumber:Word read FFunctionNumber;
|
|
property BaseAddress:Word read FBaseAddress;
|
|
property InterfaceType:String read GetInterfaceType;
|
|
|
|
property Slave:Boolean read FSlave;
|
|
property LogicalUnitNo:LongWord read FLogicalUnitNo;
|
|
property FireWireGUID:Int64 read FFireWireGUID;
|
|
property WorldWideNo:Int64 read FWorldWideNo;
|
|
|
|
property PhysicalPort:Word read FPhysicalPort;
|
|
property ControlPort:Word read FControlPort;
|
|
property IRQ:LongWord read FIRQ;
|
|
|
|
property PIO:Boolean read FPIO;
|
|
property DMA:Boolean read FDMA;
|
|
property LBA:Boolean read FLBA;
|
|
property Version:LongWord read FVersion;
|
|
|
|
property MediaType:TMediaType read FMediaType;
|
|
property FloppyType:TFloppyType read FFloppyType;
|
|
property Ready:Boolean read FReady;
|
|
property Locked:Boolean read FLocked;
|
|
property Lockable:Boolean read FLockable;
|
|
property Ejectable:Boolean read FEjectable;
|
|
property Readable:Boolean read FReadable;
|
|
property Writeable:Boolean read FWriteable;
|
|
property Eraseable:Boolean read FEraseable;
|
|
property Removable:Boolean read FRemovable;
|
|
property ChangeLine:Boolean read FChangeLine;
|
|
|
|
property PhysicalCylinders:LongWord read FPhysicalCylinders;
|
|
property PhysicalHeads:LongWord read FPhysicalHeads;
|
|
property PhysicalSectors:LongWord read FPhysicalSectors;
|
|
|
|
property LogicalCylinders:LongWord read FLogicalCylinders;
|
|
property LogicalHeads:LongWord read FLogicalHeads;
|
|
property LogicalSectors:LongWord read FLogicalSectors;
|
|
|
|
property SectorSize:Word read FSectorSize;
|
|
property SectorCount:Int64 read FSectorCount;
|
|
property SectorShiftCount:Word read FSectorShiftCount;
|
|
|
|
property PageCount:Word read FPageCount write FPageCount;
|
|
property PageShift:Word read FPageShift write FPageShift;
|
|
property PageMask:LongWord read FPageMask write FPageMask;
|
|
|
|
property FreeSectors:Int64 read GetFreeSectors;
|
|
property AvailableSectors:Int64 read GetAvailableSectors;
|
|
|
|
property DiskSignature:LongWord read GetDiskSignature write SetDiskSignature;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function DeviceInit:Boolean; virtual;
|
|
|
|
function LocatePartitions:Boolean; virtual;
|
|
function LocateVolumes:Boolean; virtual;
|
|
|
|
function CreateVolume:TDiskVolume; virtual;
|
|
function DeleteVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
|
|
function CreatePartition(AParent:TDiskPartition; APartitionId:Byte; ACount:LongWord; AActive:Boolean):Boolean; virtual;
|
|
function DeletePartition(APartition:TDiskPartition):Boolean; virtual;
|
|
function ModifyPartition(APartition:TDiskPartition; APartitionId:Byte):Boolean; virtual;
|
|
function ActivatePartition(APartition:TDiskPartition; AActive:Boolean):Boolean; virtual;
|
|
function ShrinkPartition(APartition:TDiskPartition; const AStart,ASize:Int64):Boolean; virtual;
|
|
function ExpandPartition(APartition:TDiskPartition; const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function Reset:Boolean;
|
|
|
|
function LockMedia:Boolean;
|
|
function UnlockMedia:Boolean;
|
|
function EjectMedia:Boolean;
|
|
|
|
function MediaReady:Boolean;
|
|
function MediaChanged:Boolean;
|
|
function MediaLocked:Boolean;
|
|
|
|
function InsertDevice:Boolean; virtual;
|
|
function EjectDevice:Boolean; virtual;
|
|
|
|
function OpenDevice(AMode:Integer):Integer; virtual;
|
|
procedure CloseDevice(AHandle:Integer); virtual;
|
|
function ReadDevice(AHandle:Integer; var ABuffer; ACount:Integer):Integer; virtual;
|
|
function WriteDevice(AHandle:Integer; const ABuffer; ACount:Integer):Integer; virtual;
|
|
function EraseDevice(AHandle:Integer; ACount:Integer):Integer; virtual;
|
|
function SeekDevice(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64; virtual;
|
|
Disk partition
[Expand]
TDiskPartition = class(TListObject)
constructor Create(ADriver:TFileSysDriver; ADevice:TDiskDevice; APartition:TDiskPartition; APartitionNo:Integer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FDevice:TDiskDevice;
|
|
FPartition:TDiskPartition;
|
|
|
|
FPartitionNo:Integer;
|
\Partition1, \Partition2 etc - See Notes
|
|
|
FEntryNo:Integer;
|
0,1,2,3
|
FPartitionId:Byte;
|
Partition Type from Table
|
|
|
FBeginHead:Word;
|
Logical Starting Head (not Physical)
|
FBeginSector:Word;
|
Logical Starting Sector (not Physical)
|
FBeginCylinder:Word;
|
Logical Starting Cylinder (not Physical)
|
FEndHead:Word;
|
Logical Ending Head (not Physical)
|
FEndSector:Word;
|
Logical Ending Sector (not Physical)
|
FEndCylinder:Word;
|
Logical Ending Cylinder (not Physical)
|
FSectorOffset:LongWord;
|
Offset in Sectors from Location of Table to StartSector
|
|
|
FActive:Boolean;
|
Active Partition Indicator ($80)
|
FExtended:Boolean;
|
Extended Partition Type (no Volume) - Set by Recognizer
|
FRecognizable:Boolean;
|
Partition allows Recognize Partition
|
FRecognized:Boolean;
|
Recognized Partition Id - Set by Recognizer
|
|
|
FNonVolume:Boolean;
|
Non Volume Partition (eg Linux Swap) - Set by Recognizer
|
FMultiVolume:Boolean;
|
Multiple Volume Partition (eg Netware) - Set by Recognizer
|
|
|
FStartSector:Int64;
|
Absolute Start Sector on Device
|
FSectorCount:LongWord;
|
Total Sectors in Partition
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String;
|
|
function GetPath:String;
|
|
function GetParent:String;
|
|
function GetLogical:Boolean;
|
|
function GetPrimary:Boolean;
|
|
procedure SetExtended(AExtended:Boolean);
|
|
|
|
function GetFreeSectors:LongWord;
|
Unused Sectors in Partition
|
function GetAvailableSectors:LongWord;
|
Largest block of Unused Sectors
|
|
|
function GetAvailableBlock(var AStart,ACount:LongWord):Boolean;
|
|
|
|
function GetRoot:TDiskPartition;
|
|
function GetParentStart:LongWord;
|
|
|
|
function GetPartitionRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
function SetPartitionRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
public
|
property Name:String read GetName;
|
|
property Path:String read GetPath;
|
|
property Parent:String read GetParent;
|
|
property Device:TDiskDevice read FDevice;
|
|
property Partition:TDiskPartition read FPartition;
|
|
property PartitionNo:Integer read FPartitionNo;
|
|
|
|
property EntryNo:Integer read FEntryNo write FEntryNo;
|
|
property PartitionId:Byte read FPartitionId;
|
|
|
|
property BeginHead:Word read FBeginHead;
|
|
property BeginSector:Word read FBeginSector;
|
|
property BeginCylinder:Word read FBeginCylinder;
|
|
property EndHead:Word read FEndHead;
|
|
property EndSector:Word read FEndSector;
|
|
property EndCylinder:Word read FEndCylinder;
|
|
property SectorOffset:LongWord read FSectorOffset;
|
|
|
|
property Active:Boolean read FActive;
|
|
property Logical:Boolean read GetLogical;
|
|
property Primary:Boolean read GetPrimary;
|
|
property Extended:Boolean read FExtended write SetExtended;
|
|
property Recognizable:Boolean read FRecognizable;
|
|
property Recognized:Boolean read FRecognized write FRecognized;
|
|
|
|
property NonVolume:Boolean read FNonVolume write FNonVolume;
|
|
property MultiVolume:Boolean read FMultiVolume write FMultiVolume;
|
|
|
|
property StartSector:Int64 read FStartSector;
|
|
property SectorCount:LongWord read FSectorCount;
|
|
|
|
property FreeSectors:LongWord read GetFreeSectors;
|
|
property AvailableSectors:LongWord read GetAvailableSectors;
|
|
|
|
property Root:TDiskPartition read GetRoot;
|
|
property ParentStart:LongWord read GetParentStart;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
|
|
function PartitionInit:Boolean; virtual;
|
|
|
|
function LocatePartitions:Boolean; virtual;
|
|
function LocateVolumes:Boolean; virtual;
|
|
|
|
function CreateVolume:TDiskVolume; virtual;
|
|
function DeleteVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
|
|
function OpenPartition(AMode:Integer):Integer; virtual;
|
|
procedure ClosePartition(AHandle:Integer); virtual;
|
|
function ReadPartition(AHandle:Integer; var ABuffer; ACount:Integer):Integer; virtual;
|
|
function WritePartition(AHandle:Integer; const ABuffer; ACount:Integer):Integer; virtual;
|
|
function SeekPartition(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64; virtual;
|
|
Disk volume
[Expand]
TDiskVolume = class(TListObject)
constructor Create(ADriver:TFileSysDriver; ADevice:TDiskDevice; APartition:TDiskPartition; AVolumeNo:Integer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FDevice:TDiskDevice;
|
|
FPartition:TDiskPartition;
|
|
|
|
FVolumeNo:Integer;
|
\Volume1 , \Volume2, etc - See Notes
|
FSegmentNo:Integer;
|
Segment0, Segment1 etc - for Multiple Segment volumes (eg Netware)
|
|
|
FDriveType:TDriveType;
|
|
|
|
FFileSystem:TFileSystem;
|
|
|
|
FRemovable:Boolean;
|
Volume is Removable - Set by VolumeInit
|
FRecognizable:Boolean;
|
Volume allows Recognize Volume
|
FRecognized:Boolean;
|
Recognized Volume - Set by Recognizer
|
|
|
FSectorSize:Word;
|
Sector Size of Device
|
FStartSector:Int64;
|
Absolute Start Sector on Device
|
FSectorCount:LongWord;
|
Total Sectors in Volume
|
FSectorShiftCount:Word;
|
Sectors to Bytes Shift Count
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String;
|
|
function GetParent:String;
|
|
|
|
function GetMaxFile:Integer;
|
|
function GetMaxPath:Integer;
|
|
function GetAttributes:LongWord;
|
|
function GetSystemName:String;
|
|
function GetVolumeName:String;
|
|
function GetVolumeGUID:String;
|
|
function GetVolumeSerial:LongWord;
|
|
function GetFileSysType:TFileSysType;
|
|
|
|
procedure SetFileSystem(AFileSystem:TFileSystem);
|
|
|
|
function GetSectorSize:Word;
|
|
function GetStartSector:Int64;
|
|
function GetSectorCount:LongWord;
|
|
function GetSectorShiftCount:Word;
|
|
|
|
function MediaTypeToDriveType(AMediaType:TMediaType):TDriveType;
|
|
|
|
function GetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
function SetBootRecord(ARecord:Pointer,ASector:LongWord):Boolean; virtual;
|
|
public
|
property Name:String read GetName;
|
|
property Parent:String read GetParent;
|
|
property Device:TDiskDevice read FDevice;
|
|
property Partition:TDiskPartition read FPartition;
|
|
property VolumeNo:Integer read FVolumeNo;
|
|
property SegmentNo:Integer read FSegmentNo;
|
|
|
|
property MaxFile:Integer read GetMaxFile;
|
|
property MaxPath:Integer read GetMaxPath;
|
|
property Attributes:LongWord read GetAttributes;
|
|
property SystemName:String read GetSystemName;
|
|
property VolumeName:String read GetVolumeName;
|
|
property VolumeGUID:String read GetVolumeGUID;
|
|
property VolumeSerial:LongWord read GetVolumeSerial;
|
|
|
|
property DriveType:TDriveType read FDriveType;
|
|
property FileSysType:TFileSysType read GetFileSysType;
|
|
|
|
property FileSystem:TFileSystem read FFileSystem write SetFileSystem;
|
|
|
|
property Removable:Boolean read FRemovable;
|
|
property Recognizable:Boolean read FRecognizable;
|
|
property Recognized:Boolean read FRecognized write FRecognized;
|
|
|
|
property SectorSize:Word read GetSectorSize;
|
|
property StartSector:Int64 read GetStartSector;
|
|
property SectorCount:LongWord read GetSectorCount;
|
|
property SectorShiftCount:Word read GetSectorShiftCount;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function VolumeInit:Boolean; virtual;
|
|
|
|
function CreateDrive(ADriveNo:Integer):TDiskDrive; virtual;
|
|
function DeleteDrive(ADrive:TDiskDrive):Boolean; virtual;
|
|
|
|
function MountVolume(ADriveNo:Integer):Boolean; virtual;
|
|
function DismountVolume:Boolean; virtual;
|
|
function FormatVolume(AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; virtual;
|
|
function DefragmentVolume:Boolean; virtual;
|
|
function ConvertVolume(AFileSysType:TFileSysType):Boolean; virtual;
|
|
function RepairVolume:Boolean; virtual;
|
|
function CopyVolume(ADest:TDiskVolume):Boolean; virtual;
|
|
function ShrinkVolume(const AStart,ASize:Int64):Boolean; virtual;
|
|
function ExpandVolume(const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function OpenVolume(AMode:Integer):Integer; virtual;
|
|
procedure CloseVolume(AHandle:Integer); virtual;
|
|
function ReadVolume(AHandle:Integer; var ABuffer; ACount:Integer):Integer; virtual;
|
|
function WriteVolume(AHandle:Integer; const ABuffer; ACount:Integer):Integer; virtual;
|
|
function SeekVolume(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64; virtual;
|
|
Disk image
[Expand]
TDiskImage = class(TListObject)
constructor Create(ADriver:TFileSysDriver; AController:TDiskController; const AName:String; AImageNo:Integer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FController:TDiskController;
|
|
|
|
FName:String;
|
|
FImageNo:Integer;
|
|
|
|
FLocked:Boolean;
|
|
FChanged:Boolean;
|
|
FAttributes:LongWord;
|
|
|
|
FImageType:TImageType;
|
|
FMediaType:TMediaType;
|
|
FFloppyType:TFloppyType;
|
|
|
|
FCylinders:LongWord;
|
Physical Cylinders on Drive
|
FHeads:LongWord;
|
Physical Heads on Drive
|
FSectors:LongWord;
|
Physical Sectors per Track
|
FLogicalShiftCount:Word;
|
Physical to Logical Shift Count
|
|
|
FSectorSize:Word;
|
Bytes Per Sector
|
FSectorCount:Int64;
|
Total Sectors
|
FSectorShiftCount:Word;
|
Sectors to Bytes Shift Count
|
|
|
FPartitionId:Byte;
|
Partition Type for Table
|
FFileSysType:TFileSysType;
|
|
|
|
FDevice:TDiskDevice;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetReady:Boolean; virtual;
|
|
function GetReadable:Boolean; virtual;
|
|
function GetWriteable:Boolean; virtual;
|
|
function GetEraseable:Boolean; virtual;
|
|
|
|
function GetCylinders:LongWord; virtual;
|
|
function GetHeads:LongWord; virtual;
|
|
function GetSectors:LongWord; virtual;
|
|
function GetLogicalShiftCount:Word; virtual;
|
|
|
|
function GetSectorSize:Word; virtual;
|
|
function GetSectorCount:Int64; virtual;
|
|
function GetSectorShiftCount:Word; virtual;
|
|
|
|
function GetPartitionId:Byte; virtual;
|
|
|
|
function GetName:String; virtual;
|
|
procedure SetName(const AName:String); virtual;
|
|
procedure SetDevice(ADevice:TDiskDevice);
|
|
public
|
property Controller:TDiskController read FController;
|
|
|
|
property Name:String read GetName write SetName;
|
|
property ImageNo:Integer read FImageNo;
|
|
|
|
property Ready:Boolean read GetReady;
|
|
property Locked:Boolean read FLocked;
|
|
property Changed:Boolean read FChanged;
|
|
property Readable:Boolean read GetReadable;
|
|
property Writeable:Boolean read GetWriteable;
|
|
property Eraseable:Boolean read GetEraseable;
|
|
property Attributes:LongWord read FAttributes;
|
|
|
|
property ImageType:TImageType read FImageType;
|
|
property MediaType:TMediaType read FMediaType;
|
|
property FloppyType:TFloppyType read FFloppyType;
|
|
|
|
property Cylinders:LongWord read FCylinders;
|
|
property Heads:LongWord read FHeads;
|
|
property Sectors:LongWord read FSectors;
|
|
property LogicalShiftCount:Word read FLogicalShiftCount;
|
|
|
|
property SectorSize:Word read FSectorSize;
|
|
property SectorCount:Int64 read FSectorCount;
|
|
property SectorShiftCount:Word read FSectorShiftCount;
|
|
|
|
property PartitionId:Byte read FPartitionId;
|
|
property FileSysType:TFileSysType read FFileSysType;
|
|
|
|
property Device:TDiskDevice read FDevice write SetDevice;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterOwner:Boolean;
|
|
|
|
function ImageInit:Boolean; virtual;
|
|
|
|
function LockMedia:Boolean; virtual;
|
|
function UnlockMedia:Boolean; virtual;
|
|
function EjectMedia:Boolean; virtual;
|
|
|
|
function MediaReady:Boolean; virtual;
|
|
function MediaChanged:Boolean; virtual;
|
|
function MediaLocked:Boolean; virtual;
|
|
|
|
function Read(ASector:LongWord; ACount:Word; var ABuffer):Boolean; virtual;
|
|
function Write(ASector:LongWord; ACount:Word; const ABuffer):Boolean; virtual;
|
|
function Allocated(ASector:LongWord; ACount:Word):Word; virtual;
|
|
|
|
function MountImage:Boolean; virtual;
|
|
function DismountImage:Boolean; virtual;
|
|
function InsertImage:Boolean; virtual;
|
|
function EjectImage:Boolean; virtual;
|
|
function ConvertImage(AImageType:TImageType):Boolean; virtual;
|
|
function CopyImage(ADest:TDiskImage):Boolean; virtual;
|
|
function ShrinkImage(const ASize:Int64):Boolean; virtual;
|
|
function ExpandImage(const ASize:Int64):Boolean; virtual;
|
|
|
|
function CreateImage(AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer; virtual;
|
|
function OpenImage(AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer; virtual;
|
|
function CloseImage:Boolean; virtual;
|
|
function ResizeImage(const ASectorCount:Int64):Boolean; virtual;
|
|
|
|
function CreateSnapshot:Boolean; virtual;
|
|
function DeleteSnapshot:Boolean; virtual;
|
|
function MergeSnapshot:Boolean; virtual;
|
|
Recognizer
[Expand]
TRecognizer = class(TListObject)
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
|
|
FAllowDrive:Boolean;
|
Enable mounting with an attached Drive
|
FAllowDefault:Boolean;
|
Enable mounting of unrecognized media (Unpartitioned Media Only)
|
|
|
FDirtyCheck:Boolean;
|
Enable checking Volume when dirty flag set on mount
|
FQuickCheck:Boolean;
|
Enable quick check only when checking dirty Volume
|
|
|
FPartitioner:TDiskPartitioner;
|
|
FFormatter:TDiskFormatter;
|
|
FDefragger:TDiskDefragger;
|
|
FConverter:TDiskConverter;
|
|
FRepairer:TDiskRepairer;
|
|
FResizer:TDiskResizer;
|
|
FCopier:TDiskCopier;
|
|
FImager:TDiskImager;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String; virtual;
|
|
public
|
property Name:String read GetName;
|
|
|
|
property AllowDrive:Boolean read FAllowDrive write FAllowDrive;
|
|
property AllowDefault:Boolean read FAllowDefault write FAllowDefault;
|
|
|
|
property DirtyCheck:Boolean read FDirtyCheck write FDirtyCheck;
|
|
property QuickCheck:Boolean read FQuickCheck write FQuickCheck;
|
|
|
|
property Partitioner:TDiskPartitioner read FPartitioner write FPartitioner;
|
|
property Formatter:TDiskFormatter read FFormatter write FFormatter;
|
|
property Defragger:TDiskDefragger read FDefragger write FDefragger;
|
|
property Converter:TDiskConverter read FConverter write FConverter;
|
|
property Repairer:TDiskRepairer read FRepairer write FRepairer;
|
|
property Resizer:TDiskResizer read FResizer write FResizer;
|
|
property Copier:TDiskCopier read FCopier write FCopier;
|
|
property Imager:TDiskImager read FImager write FImager;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
|
|
function RecognizePartitionId(APartitionId:Byte):Boolean; virtual;
|
|
function RecognizeBootSector(ABootSector:PBootSector; const AStartSector,ASectorCount:Int64):Boolean; virtual;
|
|
|
|
function RecognizePartition(APartition:TDiskPartition):Boolean; virtual;
|
|
function RecognizeVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
function MountVolume(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean; virtual;
|
|
function DismountVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
|
|
function RecognizeImage(AImage:TDiskImage):Boolean; virtual;
|
|
function MountImage(AImage:TDiskImage):Boolean; virtual;
|
|
function DismountImage(AImage:TDiskImage):Boolean; virtual;
|
|
function InsertImage(AImage:TDiskImage):Boolean; virtual;
|
|
function EjectImage(AImage:TDiskImage):Boolean; virtual;
|
|
Redirector
[Expand]
TRedirector = class(TListObject)
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function LocateDrives:Boolean; virtual;
|
|
|
|
function RedirectPath(const APath:String):Boolean; virtual;
|
|
function RedirectDrive(ADrive:TDiskDrive):Boolean; virtual;
|
|
function AttachPath(const APath:String; ADrive:TDiskDrive):Boolean; virtual;
|
|
function DetachDrive(ADrive:TDiskDrive):Boolean; virtual;
|
|
Disk partitioner
[Expand]
TDiskPartitioner = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
FInitChar:Byte;
|
Character to initialize sectors when adding partitions
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function CheckLogical(ADevice:TDiskDevice; AParent:TDiskPartition; APartitionId:Byte):Boolean; virtual;
|
|
function CheckExtended(ADevice:TDiskDevice; AParent:TDiskPartition; APartitionId:Byte):Boolean; virtual;
|
|
|
|
function GetLogicalChild(ADevice:TDiskDevice; APartition:TDiskPartition; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetExtendedSibling(ADevice:TDiskDevice; AParent:TDiskPartition; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
function GetExtendedParent(ADevice:TDiskDevice; AParent:TDiskPartition; AStart:LongWord; ALock:Boolean; AState:LongWord):TDiskPartition;
|
|
|
|
function GetEndCHS(ADevice:TDiskDevice; AStart,ACount:LongWord; var ACylinder,AHead,ASector:Word):Boolean; virtual;
|
|
function GetStartCHS(ADevice:TDiskDevice; AStart,ACount:LongWord; var ACylinder,AHead,ASector:Word):Boolean; virtual;
|
|
|
|
function GetSectorCount(ADevice:TDiskDevice; AStart,ACount:LongWord):LongWord; virtual;
|
|
function GetStartSector(ADevice:TDiskDevice; AExtended,ALogical:Boolean; AStart:LongWord; var ACount:LongWord):LongWord; virtual;
|
|
function GetSectorOffset(ADevice:TDiskDevice; AParent:TDiskPartition; AExtended:Boolean; AStart:LongWord):LongWord; virtual;
|
|
function GetPartitionId(ADevice:TDiskDevice; AParent:TDiskPartition; AStart,ACount:LongWord; APartitionId:Byte):Byte; virtual;
|
|
|
|
function InitPartition(ADevice:TDiskDevice; AParent:TDiskPartition; AStart,ACount:LongWord; APartitionId:Byte):Boolean; virtual;
|
|
|
|
function CreatePartitionRecord(ADevice:TDiskDevice; ARecord:PPartitionRecord):Boolean;
|
|
function CreatePartitionEntry(ADevice:TDiskDevice; AStart,ACount,AOffset:LongWord; APartitionId:Byte; AActive:Boolean; var AEntry:TPartitionEntry):Boolean;
|
|
|
|
function FillSectors(ADevice:TDiskDevice; APartition:TDiskPartition; ASector,ACount:LongWord; AValue:Byte):Boolean;
|
|
function ReadSectors(ADevice:TDiskDevice; APartition:TDiskPartition; ASector,ACount:LongWord; var ABuffer):Boolean;
|
|
function WriteSectors(ADevice:TDiskDevice; APartition:TDiskPartition; ASector,ACount:LongWord; const ABuffer):Boolean;
|
|
public
|
property InitChar:Byte read FInitChar write FInitChar;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptPartition(ADevice:TDiskDevice; APartition,AParent:TDiskPartition; APartitionId:Byte):Boolean; virtual;
|
|
|
|
function CreatePartition(ADevice:TDiskDevice; AParent:TDiskPartition; APartitionId:Byte; ACount:LongWord; AActive:Boolean):Boolean; virtual;
|
|
function DeletePartition(APartition:TDiskPartition):Boolean; virtual;
|
|
function ModifyPartition(APartition:TDiskPartition; APartitionId:Byte; AOverride:Boolean):Boolean; virtual;
|
|
function ActivatePartition(APartition:TDiskPartition; AActive:Boolean):Boolean; virtual;
|
|
Disk formatter
[Expand]
TDiskFormatter = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function FillSectors(AVolume:TDiskVolume; ADrive:TDiskDrive; ASector,ACount:LongWord; AValue:Byte):Boolean;
|
|
function ReadSectors(AVolume:TDiskVolume; ADrive:TDiskDrive; ASector,ACount:LongWord; var ABuffer):Boolean;
|
|
function WriteSectors(AVolume:TDiskVolume; ADrive:TDiskDrive; ASector,ACount:LongWord; const ABuffer):Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; virtual;
|
|
|
|
function FormatVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; virtual;
|
|
Disk defragger
[Expand]
TDiskDefragger = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
|
|
function DefragmentVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
Disk converter
[Expand]
TDiskConverter = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume:TDiskVolume; AFileSysType:TFileSysType):Boolean; virtual;
|
|
|
|
function ConvertVolume(AVolume:TDiskVolume; AFileSysType:TFileSysType):Boolean; virtual;
|
|
|
|
function AcceptImage(AImage:TDiskImage; AImageType:TImageType):Boolean; virtual;
|
|
|
|
function ConvertImage(AImage:TDiskImage; AImageType:TImageType):Boolean; virtual;
|
|
Disk repairer
[Expand]
TDiskRepairer = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
|
|
function RepairVolume(AVolume:TDiskVolume):Boolean; virtual;
|
|
Disk resizer
[Expand]
TDiskResizer = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function ShrinkVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; virtual;
|
|
function ExpandVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function AcceptPartition(APartition:TDiskPartition; const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function ShrinkPartition(APartition:TDiskPartition; const AStart,ASize:Int64):Boolean; virtual;
|
|
function ExpandPartition(APartition:TDiskPartition; const AStart,ASize:Int64):Boolean; virtual;
|
|
|
|
function AcceptImage(AImage:TDiskImage; const ASize:Int64):Boolean; virtual;
|
|
|
|
function ShrinkImage(AImage:TDiskImage; const ASize:Int64):Boolean; virtual;
|
|
function ExpandImage(AImage:TDiskImage; const ASize:Int64):Boolean; virtual;
|
|
Disk copier
[Expand]
TDiskCopier = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptVolume(AVolume,ADest:TDiskVolume):Boolean; virtual;
|
|
|
|
function CopyVolume(AVolume,ADest:TDiskVolume):Boolean; virtual;
|
|
|
|
function AcceptImage(AImage,ADest:TDiskImage):Boolean; virtual;
|
|
|
|
function CopyImage(AImage,ADest:TDiskImage):Boolean; virtual;
|
|
Disk imager
[Expand]
TDiskImager = class(TObject)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FRecognizer:TRecognizer;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
|
|
function AcceptImage(AImage:TDiskImage; const AName:String; AImageType:TImageType; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):Boolean; virtual;
|
|
|
|
function CreateImage(AImage:TDiskImage; const AName:String; AImageType:TImageType; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer; virtual;
|
|
function OpenImage(AImage:TDiskImage; const AName:String; AImageType:TImageType; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64; ACylinders,AHeads,ASectors:LongWord; APartitionId:Byte):Integer; virtual;
|
|
function CloseImage(AImage:TDiskImage):Boolean; virtual;
|
|
|
|
function AcceptSnapshot(AImage:TDiskImage):Boolean; virtual;
|
|
|
|
function CreateSnapshot(AImage:TDiskImage):Boolean; virtual;
|
|
function DeleteSnapshot(AImage:TDiskImage):Boolean; virtual;
|
|
function MergeSnapshot(AImage:TDiskImage):Boolean; virtual;
|
|
File system
[Expand]
TFileSystem = class(TListObject)
constructor Create(ADriver:TFileSysDriver; AVolume:TDiskVolume; ADrive:TDiskDrive);
|
|
destructor Destroy; override;
|
|
private
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
FVolume:TDiskVolume;
|
|
FDrive:TDiskDrive;
|
|
|
|
FPathChar:String;
|
Path separator character
|
FNameChar:String;
|
Name separator character
|
FFileChar:String;
|
File separator character
|
FRootChar:String;
|
Root specifier character (eg C:)
|
FRootName:String;
|
|
FRootPath:String;
|
Root Path must be prefixed with \\.
|
FMaxFile:Integer;
|
|
FMaxPath:Integer;
|
|
FMaxAltFile:Integer;
|
|
FMaxAltPath:Integer;
|
|
FAttributes:LongWord;
|
|
FMaxAttributes:LongWord;
|
|
FMaskAttributes:LongWord;
|
|
FMountPointTag:LongWord;
|
|
FSymbolicLinkTag:LongWord;
|
|
FSystemName:String;
|
|
FVolumeName:String;
|
|
FVolumeGUID:String;
|
|
FVolumeSerial:LongWord;
|
|
FFileSysType:TFileSysType;
|
|
|
|
FSectorSize:Word;
|
|
FStartSector:Int64;
|
|
FSectorCount:LongWord;
|
|
|
|
FRoot:TDiskEntry;
|
|
|
|
FCurrentIndex:LongWord;
|
TLS Index for storing current directory
|
|
|
FChunks:TFileSysList;
|
|
FTables:TFileSysList;
|
|
FBlocks:TFileSysList;
|
|
FEntries:TFileSysTree;
|
|
FCatalogs:TFileSysList;
|
|
FAcls:TFileSysList;
|
|
|
|
FChunkLocal:TMutexHandle;
|
Local Lock shared by all DiskChunk objects
|
FTableLocal:TMutexHandle;
|
Local Lock shared by all DiskTable objects
|
FBlockLocal:TMutexHandle;
|
Local Lock shared by all DiskBlock objects
|
FEntryLocal:TMutexHandle;
|
Local Lock shared by all DiskEntry objects
|
FCatalogLocal:TMutexHandle;
|
Local Lock shared by all DiskCatalog objects
|
FSecurityLocal:TMutexHandle;
|
Local Lock shared by all DiskSecurity objects
|
FAclLocal:TMutexHandle;
|
Local Lock shared by all DiskAcl objects
|
FAceLocal:TMutexHandle;
|
Local Lock shared by all DiskAce objects
|
|
|
FMarkDirty:Boolean;
|
Mark the volume as dirty when dismounting (Either by request or due to error)
|
FMarkClean:Boolean;
|
Mark the volume as clean when dismounting (Only by request)
|
FMarkError:Boolean;
|
Error was encounted on volume, mark as dirty when dismounting
|
FLogDirty:Boolean;
|
LogFile was dirty when mounted (if supported by filesystem)
|
FMountDirty:Boolean;
|
Volume was dirty when mounted, leave marked as dirty when dismounting
|
|
|
FOemConvert:Boolean;
|
Default to True overidden by descendants if not supported
|
FNumericTail:Boolean;
|
Default to True overidden by descendants if not supported
|
|
|
FReadOnly:Boolean;
|
Default to False overidden by descendants if True
|
FLongNames:Boolean;
|
Default to True overidden by descendants if not supported
|
FDataStreams:Boolean;
|
Default to False overidden by descendants if supported
|
FReparsePoints:Boolean;
|
Default to False overidden by descendants if supported
|
FCaseSensitive:Boolean;
|
Default to False overidden by descendants if supported
|
FCasePreserved:Boolean;
|
Default to False overidden by descendants if supported
|
FUnicodeNames:Boolean;
|
Default to False overidden by descendants if supported
|
FPersistentAcls:Boolean;
|
Default to False overidden by descendants if supported
|
FFileCompression:Boolean;
|
Default to False overidden by descendants if supported
|
FVolumeQuotas:Boolean;
|
Default to False overidden by descendants if supported
|
FSparseFiles:Boolean;
|
Default to False overidden by descendants if supported
|
FRemoteStorage:Boolean;
|
Default to False overidden by descendants if supported
|
FVolumeCompressed:Boolean;
|
Default to False overidden by descendants if supported
|
FObjectIds:Boolean;
|
Default to False overidden by descendants if supported
|
FEncryption:Boolean;
|
Default to False overidden by descendants if supported
|
|
|
FBootCatalog:Boolean;
|
Default to False overidden by descendants if supported
|
FVirtualVolume:Boolean;
|
Default to False overidden by descendants if supported
|
FFolderEncryption:Boolean;
|
Default to False overidden by descendants if supported
|
FFolderCompression:Boolean;
|
Default to False overidden by descendants if supported
|
|
|
FBootSector:LongWord;
|
Relative to StartSector
|
FBootBackup:LongWord;
|
Relative to StartSector
|
|
|
FSectorBuffer:Pointer;
|
Buffer of exactly sector size
|
FSectorLock:TMutexHandle;
|
Lock for sector buffer
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function SectorLock:Boolean;
|
|
function SectorUnlock:Boolean;
|
|
|
|
procedure SetDrive(ADrive:TDiskDrive); virtual;
|
|
procedure SetVolume(AVolume:TDiskVolume); virtual;
|
|
|
|
function GetPathChar:String; virtual;
|
|
function GetNameChar:String; virtual;
|
|
function GetFileChar:String; virtual;
|
|
function GetRootChar:String; virtual;
|
|
function GetRootName:String; virtual;
|
|
function GetRootPath:String; virtual;
|
|
function GetSystemName:String; virtual;
|
|
function GetVolumeName:String; virtual;
|
|
function GetVolumeGUID:String; virtual;
|
|
|
|
function LoadPathChar:String; virtual;
|
|
function LoadNameChar:String; virtual;
|
|
function LoadFileChar:String; virtual;
|
|
function LoadRootChar:String; virtual;
|
|
function LoadRootName:String; virtual;
|
|
function LoadRootPath:String; virtual;
|
|
function LoadMaxFile:Integer; virtual;
|
|
function LoadMaxPath:Integer; virtual;
|
|
function LoadMaxAltFile:Integer; virtual;
|
|
function LoadMaxAltPath:Integer; virtual;
|
|
function LoadAttributes:LongWord; virtual;
|
Get the Volume Attributes
|
function LoadMaxAttributes:LongWord; virtual;
|
Get the Maximum File Attributes (used when setting file attributes)
|
function LoadMaskAttributes:LongWord; virtual;
|
Get the File Attributes Mask (used when getting file attributes)
|
function LoadMountPointTag:LongWord; virtual;
|
|
function LoadSymbolicLinkTag:LongWord; virtual;
|
|
function LoadSystemName:String; virtual;
|
|
function LoadVolumeName:String; virtual;
|
|
function LoadVolumeGUID:String; virtual;
|
|
function LoadVolumeSerial:LongWord; virtual;
|
|
function LoadFileSysType:TFileSysType; virtual;
|
|
|
|
function LoadSectorSize:Word; virtual;
|
|
function LoadStartSector:Int64; virtual;
|
|
function LoadSectorCount:LongWord; virtual;
|
|
|
|
function GetCurrent:TDiskEntry; virtual;
|
|
function SetCurrent(ACurrent:TDiskEntry):Boolean; virtual;
|
|
|
|
function FillSectors(ASector,ACount:LongWord; AValue:Byte):Boolean;
|
|
|
|
function ReadSectors(ASector,ACount:LongWord; var ABuffer):Boolean;
|
|
function WriteSectors(ASector,ACount:LongWord; const ABuffer):Boolean;
|
|
|
|
function ReadEntry(AParent,AEntry:TDiskEntry; var ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; virtual;
|
|
function WriteEntry(AParent,AEntry:TDiskEntry; const ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; virtual;
|
|
|
|
function LoadTables:Boolean; virtual;
|
|
function LoadBlocks:Boolean; virtual;
|
|
function LoadEntries(AParent:TDiskEntry):Boolean; virtual;
|
|
function LoadCatalogs:Boolean; virtual;
|
|
|
|
function LoadTable(ATableNo:LongWord):Boolean; virtual;
|
|
function LoadBlock(ABlockNo:LongWord):Boolean; virtual;
|
|
| Note: LoadEntry can be implemented if needed but is not defined here.
|
| Note: LoadCatalog can be implemented if needed but is not defined here.
|
|
|
function UnloadEntries(AParent:TDiskEntry):Boolean; virtual;
|
|
|
|
function AddEntry(AParent:TDiskEntry; const AName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; virtual;
|
|
function AddEntryEx(AParent:TDiskEntry; const AName,AAltName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; virtual;
|
|
function RemoveEntry(AParent,AEntry:TDiskEntry):Boolean; virtual;
|
|
function RenameEntry(AParent,AEntry:TDiskEntry; const AName:String):Boolean; virtual;
|
|
function RenameEntryEx(AParent,AEntry:TDiskEntry; const AAltName:String):Boolean; virtual;
|
|
function MoveEntry(ASource,ADest,AEntry:TDiskEntry):Boolean; virtual;
|
|
|
|
function AddCatalog(AEntry:TDiskEntry; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):TDiskCatalog; virtual;
|
|
function RemoveCatalog(ACatalog:TDiskCatalog):Boolean; virtual;
|
|
function CheckCatalog(ACatalog:TDiskCatalog; ALock:Boolean; AState:LongWord):Boolean; virtual;
|
|
|
|
function GetCatalogByNo(ACatalogNo:LongWord; ALock:Boolean; AState:LongWord):TDiskCatalog; virtual;
|
|
function GetCatalogByName(const AName:String; ALock:Boolean; AState:LongWord):TDiskCatalog; virtual;
|
|
function GetCatalogByNext(APrevious:TDiskCatalog; ALock,AUnlock:Boolean; AState:LongWord):TDiskCatalog; virtual;
|
|
|
|
function GetNextCatalogNo:LongWord; virtual;
|
|
function GetMaxCatalogNo:LongWord; virtual;
|
|
|
|
function AddHardlink(AEntry,AParent:TDiskEntry; const AName:String; AReference:Boolean):TDiskEntry; virtual;
|
|
function RemoveHardlink(AParent,AEntry:TDiskEntry):Boolean; virtual;
|
|
|
|
function AddMountPoint(AEntry:TDiskEntry; const ATarget:String):Boolean; virtual;
|
|
function RemoveMountPoint(AEntry:TDiskEntry):Boolean; virtual;
|
|
|
|
function AddJunctionPoint(AEntry:TDiskEntry; const ATarget:String):Boolean; virtual;
|
|
function RemoveJunctionPoint(AEntry:TDiskEntry):Boolean; virtual;
|
|
|
|
function AddSymbolicLink(AParent:TDiskEntry; const AName,ATarget:String; AFolder,AReference:Boolean):TDiskEntry; virtual;
|
|
function AddSymbolicLinkEx(AParent:TDiskEntry; const AName,AAltName,ATarget:String; AFolder,AReference:Boolean):TDiskEntry; virtual;
|
|
function RemoveSymbolicLink(AParent,AEntry:TDiskEntry):Boolean; virtual;
|
|
|
|
function SetTable(ATable:TDiskTable):Boolean; virtual;
|
|
function SetBlock(ABlock:TDiskBlock):Boolean; virtual;
|
|
function SetEntry(AParent,AEntry:TDiskEntry):Boolean; virtual;
|
|
function SetCatalog(ACatalog:TDiskCatalog):Boolean; virtual;
|
|
function SetReparse(AParent,AEntry:TDiskEntry; AReparse:TDiskReparse):Boolean; virtual;
|
|
function SetSecurity(AParent,AEntry:TDiskEntry; ASecurity:TDiskSecurity):Boolean; virtual;
|
|
|
|
function SizeEntry(AParent,AEntry:TDiskEntry; const ASize:Int64):Boolean; virtual;
|
|
|
|
function GetTable(ATableNo:LongWord):TDiskTable; virtual;
|
|
function GetTableEx(ATableNo:LongWord; AWrite:Boolean):TDiskTable; virtual;
|
|
function GetBlock(ABlockNo:LongWord):TDiskBlock; virtual;
|
|
function GetBlockEx(ABlockNo:LongWord; AWrite:Boolean):TDiskBlock; virtual;
|
|
function GetEntry(AParent:TDiskEntry; const AName:String; AAttributes:LongWord):TDiskEntry; virtual;
|
|
function GetEntryEx(AParent:TDiskEntry; const AName:String; AAttributes:LongWord; AAdd,ARemove,AWrite:Boolean):TDiskEntry; virtual;
|
|
function GetCatalog(ACatalogNo:LongWord):TDiskCatalog; virtual;
|
|
function GetCatalogEx(ACatalogNo:LongWord; AWrite:Boolean):TDiskCatalog; virtual;
|
|
function GetReparse(AEntry:TDiskEntry):TDiskReparse; virtual;
|
|
function GetSecurity(AEntry:TDiskEntry):TDiskSecurity; virtual;
|
|
|
|
function MatchEntry(AParent,APrevious:TDiskEntry; const AName:String; AAttributes:LongWord; AAny:Boolean):TDiskEntry; virtual;
|
|
function MatchEntryEx(AParent,APrevious:TDiskEntry; const AName:String; AAttributes:LongWord; AAny,AAdd,ARemove,AWrite:Boolean):TDiskEntry; virtual;
|
|
|
|
function GetEntryPath(AEntry:TDiskEntry; AAltName:Boolean):String;
|
|
function GetEntryName(AEntry:TDiskEntry; AAltName:Boolean):String;
|
|
|
|
function SplitPath(const APath:String; var ARelative:Boolean; AFolders:TStrings; var AName:String):Boolean; virtual;
|
|
function SplitName(const AName:String; var AFile,AStream:String):Boolean; virtual;
|
|
function SplitFile(const AFile:String; var AName,AExt:String):Boolean; virtual;
|
|
function SplitStream(const AStream:String; var AName,AType:String):Boolean; virtual;
|
|
|
|
function BuildPath(ARelative:Boolean; AFolders:TLinkedStringList; const AName:String):String; virtual;
|
|
function BuildName(const AFile,AStream:String):String; virtual;
|
|
function BuildFile(const AName,AExt:String):String; virtual;
|
|
function BuildStream(const AName,AType:String):String; virtual;
|
|
|
|
function CheckName(const AName:String):Boolean; virtual;
|
|
function CompareName(const AName,AMatch:String; AWildcard:Boolean):Boolean; virtual;
|
|
|
|
function CheckAltName(const AAltName:String):Boolean; virtual;
|
|
function CompareAltName(const AAltName,AMatch:String; AWildcard:Boolean):Boolean; virtual;
|
|
|
|
function CheckLinkName(const AName:String):Boolean; virtual;
|
|
|
|
function GetSecurityFromDescriptor(ADescriptor:Pointer):TDiskSecurity; virtual;
|
|
function GetDescriptorFromSecurity(ASecurity:TDiskSecurity; ADescriptor:Pointer; var ASize:LongWord):Boolean; virtual;
|
|
public
|
property Volume:TDiskVolume read FVolume write SetVolume;
|
|
property Drive:TDiskDrive read FDrive write SetDrive;
|
|
|
|
property PathChar:String read GetPathChar;
|
|
property NameChar:String read GetNameChar;
|
|
property FileChar:String read GetFileChar;
|
|
property RootChar:String read GetRootChar;
|
|
property RootName:String read GetRootName;
|
|
property RootPath:String read GetRootPath;
|
|
property MaxFile:Integer read FMaxFile;
|
|
property MaxPath:Integer read FMaxPath;
|
|
property MaxAltFile:Integer read FMaxAltFile;
|
|
property MaxAltPath:Integer read FMaxAltPath;
|
|
property Attributes:LongWord read FAttributes;
|
|
property MaxAttributes:LongWord read FMaxAttributes;
|
|
property MaskAttributes:LongWord read FMaskAttributes;
|
|
property MountPointTag:LongWord read FMountPointTag;
|
|
property SymbolicLinkTag:LongWord read FSymbolicLinkTag;
|
|
property SystemName:String read GetSystemName;
|
|
property VolumeName:String read GetVolumeName;
|
|
property VolumeGUID:String read GetVolumeGUID;
|
|
property VolumeSerial:LongWord read FVolumeSerial;
|
|
property FileSysType:TFileSysType read FFileSysType;
|
|
|
|
property SectorSize:Word read FSectorSize;
|
|
property StartSector:Int64 read FStartSector;
|
|
property SectorCount:LongWord read FSectorCount;
|
|
|
|
property MarkDirty:Boolean read FMarkDirty write FMarkDirty;
|
|
property MarkClean:Boolean read FMarkClean write FMarkClean;
|
|
property MarkError:Boolean read FMarkError;
|
|
property LogDirty:Boolean read FLogDirty;
|
|
property MountDirty:Boolean read FMountDirty;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function ReaderConvert:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
function WriterConvert:Boolean;
|
|
|
|
function FileSystemInit:Boolean; virtual;
|
|
|
|
function MountFileSystem:Boolean; virtual;
|
|
function DismountFileSystem:Boolean; virtual;
|
|
function InitializeFileSystem(ASectorsPerCluster:LongWord; AFileSysType:TFileSysType):Boolean; virtual;
|
|
|
|
function CreateCatalog(const AName:String; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):LongWord; virtual;
|
|
function DeleteCatalog(ACatalogNo:LongWord):Boolean; virtual;
|
|
|
|
function FindFirstCatalog(var ASearchRec:TCatalogSearchRec):Integer; virtual;
|
|
function FindNextCatalog(var ASearchRec:TCatalogSearchRec):Integer; virtual;
|
|
procedure FindCatalogClose(var ASearchRec:TCatalogSearchRec); virtual;
|
|
|
|
function GetDriveLabel:String; virtual;
|
|
function SetDriveLabel(const ALabel:String):Boolean; virtual;
|
|
function GetDriveSerial:LongWord; virtual;
|
|
function SetDriveSerial(ASerial:LongWord):Boolean; virtual;
|
|
|
|
function GetDriveFreeSpace:LongWord; virtual;
|
|
function GetDriveFreeSpaceEx:Int64; virtual;
|
|
function GetDriveTotalSpace:LongWord; virtual;
|
|
function GetDriveTotalSpaceEx:Int64; virtual;
|
|
|
|
function FileOpen(const FileName:String; Mode:Integer):Integer; virtual;
|
|
function FileCreate(const FileName:String):Integer; virtual;
|
|
function DeleteFile(const FileName:String):Boolean; virtual;
|
|
procedure FileClose(Handle:Integer); virtual;
|
|
function RenameFile(const OldName,NewName:String):Boolean; virtual;
|
|
function FileSeek(Handle,Offset,Origin:Integer):Integer; virtual;
|
|
function FileSeekEx(Handle:Integer; const Offset:Int64; Origin:Integer):Int64; virtual;
|
|
function FileFlush(Handle:Integer):Boolean; virtual;
|
|
function FileTruncate(Handle:Integer):Boolean; virtual;
|
|
|
|
function FilePos(Handle:Integer):Integer; virtual;
|
|
function FilePosEx(Handle:Integer):Int64; virtual;
|
|
|
|
function FileGetAttr(const FileName:String):Integer; virtual;
|
|
function FileGetDate(Handle:Integer):Integer; virtual;
|
|
function FileGetSize(Handle:Integer):Integer; virtual;
|
|
function FileGetSizeEx(Handle:Integer):Int64; virtual;
|
|
function FileSetAttr(const FileName:String; Attr:Integer):Integer; virtual;
|
|
function FileSetDate(Handle:Integer; Age:Integer):Integer; virtual;
|
|
function FileSetSize(Handle:Integer; Size:Integer):Integer; virtual;
|
|
function FileSetSizeEx(Handle:Integer; const Size:Int64):Integer; virtual;
|
|
|
|
function FileRead(Handle:Integer; var Buffer; Count:Integer):Integer; virtual;
|
|
function FileWrite(Handle:Integer; const Buffer; Count:Integer):Integer; virtual;
|
|
|
|
function CreateDir(const DirName:String):Boolean; virtual;
|
|
function RemoveDir(const DirName:String):Boolean; virtual;
|
|
function GetCurrentDir:String; virtual;
|
|
function SetCurrentDir(const DirName:String):Boolean; virtual;
|
|
|
|
function FindOne(const Path:String; var SearchRec:TFileSearchRec):Integer; virtual;
|
|
function FindAll(const Path:String; var SearchRec:TFileSearchRec):Integer; virtual;
|
|
|
|
function FindFirstEx(const Path:String; var SearchRec:TFileSearchRec):Integer; virtual;
|
|
function FindNextEx(var SearchRec:TFileSearchRec):Integer; virtual;
|
|
procedure FindCloseEx(var SearchRec:TFileSearchRec); virtual;
|
|
|
|
function FindFirstStream(const FileName:String; var SearchRec:TStreamSearchRec):Integer; virtual;
|
|
function FindNextStream(var SearchRec:TStreamSearchRec):Integer; virtual;
|
|
procedure FindStreamClose(var SearchRec:TStreamSearchRec); virtual;
|
|
|
|
function FindFirstFileName(const FileName:String; var SearchRec:TLinkSearchRec):Integer; virtual;
|
|
function FindNextFileName(var SearchRec:TLinkSearchRec):Integer; virtual;
|
|
procedure FindFileNameClose(var SearchRec:TLinkSearchRec); virtual;
|
|
|
|
function CreateHardLink(const LinkName,FileName:String):Boolean; virtual;
|
|
function DeleteHardLink(const LinkName:String):Boolean; virtual;
|
|
|
|
function CreateMountPoint(const PathName,VolumeName:String):Boolean; virtual;
|
|
function DeleteMountPoint(const PathName:String):Boolean; virtual;
|
|
|
|
function CreateJunctionPoint(const PathName,FolderName:String):Boolean; virtual;
|
|
function DeleteJunctionPoint(const PathName:String):Boolean; virtual;
|
|
|
|
function CreateSymbolicLink(const LinkName,TargetName:String; Directory:Boolean):Boolean; virtual;
|
|
function CreateSymbolicLinkEx(const LinkName,ShortName,TargetName:String; Directory:Boolean):Boolean; virtual;
|
|
function DeleteSymbolicLink(const LinkName:String):Boolean; virtual;
|
|
|
|
function GetMountPointTarget(const PathName:String):String; virtual;
|
|
function GetJunctionPointTarget(const PathName:String):String; virtual;
|
|
function GetSymbolicLinkTarget(const LinkName:String):String; virtual;
|
|
|
|
function SetFileShortName(const FileName,ShortName:String):Boolean; virtual;
|
|
function SetFileShortNameEx(Handle:Integer; const ShortName:String):Boolean; virtual;
|
|
|
|
function GetFileSecurity(const FileName:String; Descriptor:Pointer; var Size:LongWord):Boolean; virtual;
|
|
function SetFileSecurity(const FileName:String; Descriptor:Pointer):Boolean; virtual;
|
|
|
|
function GetPathName(const FileName:String):String; virtual;
|
|
|
|
function GetShortName(const FileName:String):String; virtual;
|
|
function GetLongName(const FileName:String):String; virtual;
|
|
function GetTrueName(const FileName:String):String; virtual;
|
|
|
|
function FileCreateEx(const FileName,ShortName:String):Integer; virtual;
|
|
function CreateDirEx(const DirName,ShortName:String):Boolean; virtual;
|
|
|
|
function FileGetAttrEx(Handle:Integer):Integer; virtual;
|
|
|
|
function FileGetDateEx(Handle:Integer):TFileTime; virtual;
|
|
function FileSetDateEx(Handle:Integer; Age:TFileTime):Integer; virtual;
|
|
function GetFileTime(Handle:Integer; CreateTime,AccessTime,ModifyTime:PFileTime):Boolean; virtual;
|
|
function SetFileTime(Handle:Integer; CreateTime,AccessTime,ModifyTime:PFileTime):Boolean; virtual;
|
|
|
|
function CloseFile(Handle:THandle):Boolean; virtual;
|
Equivalent to Win32 CloseHandle
|
Disk chunk
[Expand]
TDiskChunk = class(TListObject)
| Note: A disk chunk for multi segment Volumes such as NWFS/NSS.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
Disk table
[Expand]
TDiskTable = class(TListObject)
| Note: A disk table such as a FAT or MFT table.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
private
|
FTableNo:LongWord;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
property TableNo:LongWord read FTableNo write FTableNo;
|
|
Disk block
[Expand]
TDiskBlock = class(TListObject)
| Note: A disk block such as a FAT entry.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
private
|
FBlockNo:LongWord;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
property BlockNo:LongWord read FBlockNo write FBlockNo;
|
|
Disk entry
[Expand]
TDiskEntry = class(TTreeObject)
| Note: A disk entry such as a File, Folder, Stream or Label.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
private
|
FName:String;
|
|
FHash:LongWord;
|
|
FAltName:String;
|
|
FAltHash:LongWord;
|
|
|
|
FSize:Int64;
|
|
FAttributes:LongWord;
|
|
FWriteTime:TFileTime;
|
|
FCreateTime:TFileTime;
|
|
FAccessTime:TFileTime;
|
|
|
|
FReparseTag:LongWord;
|
|
|
|
FEntriesLoaded:Boolean;
|
|
|
|
FReferenceCount:LongWord;
|
|
|
|
FRecent:TDiskEntry;
|
|
|
|
function GetName:String;
|
|
procedure SetName(const AName:String);
|
|
function GetAltName:String;
|
|
procedure SetAltName(const AAltName:String);
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
property Name:String read GetName write SetName;
|
|
property Hash:LongWord read FHash;
|
|
property AltName:String read GetAltName write SetAltName;
|
|
property AltHash:LongWord read FAltHash;
|
|
|
|
property Size:Int64 read FSize write FSize;
|
|
property Attributes:LongWord read FAttributes write FAttributes;
|
|
property WriteTime:TFileTime read FWriteTime write FWriteTime;
|
|
property CreateTime:TFileTime read FCreateTime write FCreateTime;
|
|
property AccessTime:TFileTime read FAccessTime write FAccessTime;
|
|
|
|
property ReparseTag:LongWord read FReparseTag write FReparseTag;
|
|
|
|
property EntriesLoaded:Boolean read FEntriesLoaded write FEntriesLoaded;
|
|
|
|
property ReferenceCount:LongWord read FReferenceCount;
|
|
|
|
property Recent:TDiskEntry read FRecent write FRecent;
|
|
|
|
function AddReference:Boolean; virtual;
|
|
function RemoveReference:Boolean; virtual;
|
|
|
|
function FindFirstName(AHandle:TFindHandle; AReference:Boolean):TDiskEntry; virtual;
|
|
function FindPrevName(AHandle:TFindHandle; AReference:Boolean):TDiskEntry; virtual;
|
|
function FindNextName(AHandle:TFindHandle; AReference:Boolean):TDiskEntry; virtual;
|
|
function FindLastName(AHandle:TFindHandle; AReference:Boolean):TDiskEntry; virtual;
|
|
Disk catalog
[Expand]
TDiskCatalog = class(TListObject)
| Note: A disk catalog such as a bootable section.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
protected
|
FLock:TSynchronizerHandle;
|
|
FLocalLock:TMutexHandle;
|
|
|
|
FName:String;
|
|
FHash:LongWord;
|
|
FPath:String;
|
|
FCatalogNo:LongWord;
|
|
|
|
FMediaType:TMediaType;
|
|
FFloppyType:TFloppyType;
|
|
FAttributes:LongWord;
|
Initial/Default, Bootable, No Emulation, 1.2M, 1.44M, 2.88M, Hard Disk
|
FSectorSize:Word;
|
|
FSectorCount:Int64;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetName:String; virtual;
|
|
procedure SetName(const AName:String); virtual;
|
|
function GetPath:String; virtual;
|
|
procedure SetPath(const APath:String); virtual;
|
|
function GetMediaType:TMediaType; virtual;
|
|
procedure SetMediaType(AMediaType:TMediaType); virtual;
|
|
function GetFloppyType:TFloppyType; virtual;
|
|
procedure SetFloppyType(AFloppyType:TFloppyType); virtual;
|
|
function GetAttributes:LongWord; virtual;
|
|
procedure SetAttributes(AAttributes:LongWord); virtual;
|
|
function GetSectorSize:Word; virtual;
|
|
procedure SetSectorSize(ASectorSize:Word); virtual;
|
|
function GetSectorCount:Int64; virtual;
|
|
procedure SetSectorCount(const ASectorCount:Int64); virtual;
|
|
public
|
property Name:String read GetName write SetName;
|
|
property Hash:LongWord read FHash;
|
|
property Path:String read GetPath write SetPath;
|
|
property CatalogNo:LongWord read FCatalogNo write FCatalogNo;
|
|
|
|
property MediaType:TMediaType read GetMediaType write SetMediaType;
|
|
property FloppyType:TFloppyType read GetFloppyType write SetFloppyType;
|
|
property Attributes:LongWord read GetAttributes write SetAttributes;
|
|
property SectorSize:Word read GetSectorSize write SetSectorSize;
|
|
property SectorCount:Int64 read GetSectorCount write SetSectorCount;
|
|
|
|
function ReaderLock:Boolean;
|
|
function ReaderUnlock:Boolean;
|
|
function WriterLock:Boolean;
|
|
function WriterUnlock:Boolean;
|
|
Disk reparse
[Expand]
TDiskReparse = class(TObject)
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function GetTarget:String; virtual;
|
|
procedure SetTarget(const ATarget:String); virtual;
|
|
public
|
property Target:String read GetTarget write SetTarget;
|
|
Disk security
[Expand]
TDiskSecurity = class(TObject)
| Note: A disk security descriptor.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
constructor CreateFromSecurity(ALocalLock:TMutexHandle; ASecurity:TDiskSecurity); virtual;
|
|
constructor CreateFromDescriptor(ALocalLock:TMutexHandle; ADescriptor:Pointer); virtual;
|
|
destructor Destroy; override;
|
|
private
|
FAcls:TFileSysList;
|
|
FAclLock:TMutexHandle;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
public
|
function SecuritySize:LongWord; virtual;
|
|
|
|
function SecurityDescriptor:Pointer; virtual;
|
|
function SecurityDescriptorEx(ALocal:Boolean):Pointer; virtual;
|
|
function InheritedDescriptor:Pointer; virtual;
|
|
function MergedDescriptor(AChild:Pointer):Pointer; virtual;
|
|
function ReleaseDescriptor(ADescriptor:Pointer; AInherited,AMerged:Boolean):Boolean; virtual;
|
|
|
|
function CopyToSecurity(ASecurity:TDiskSecurity):Boolean; virtual;
|
|
function CopyFromSecurity(ASecurity:TDiskSecurity):Boolean; virtual;
|
|
|
|
function CopyToDescriptor(ADescriptor:Pointer; ASize:LongWord):Boolean; virtual;
|
|
function CopyToDescriptorEx(ADescriptor:Pointer; ASize:LongWord; ALocal:Boolean):Boolean; virtual;
|
|
function CopyFromDescriptor(ADescriptor:Pointer; ASize:LongWord):Boolean; virtual;
|
|
Disk access control list
[Expand]
TDiskAcl = class(TListObject)
| Note: A security descriptor access control list.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
private
|
FAces:TFileSysList;
|
|
FAceLock:TMutexHandle;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
Disk access control entry
[Expand]
TDiskAce = class(TListObject)
| Note: A security descriptor access control entry.
|
|
|
constructor Create(ALocalLock:TMutexHandle);
|
|
destructor Destroy; override;
|
|
protected
|
FLocalLock:TMutexHandle;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
Cache
[Expand]
TCache = class(TObject)
| Note: A simple block cache with Read Only/Read Write modes and Free/Clean/Dirty page tracking. (No longer used)
|
|
|
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FDriver:TFileSysDriver;
|
|
|
|
FLock:TCriticalSectionHandle;
|
|
|
|
FBuffer:Pointer;
|
|
FPageSize:LongWord;
|
|
FPageCount:LongWord;
|
|
FCacheSize:LongWord;
|
|
FCacheMode:TCacheMode;
|
|
FCacheState:TCacheState;
|
|
FCacheTimeout:LongWord;
|
|
|
|
FReadCached:Int64;
|
|
FReadDirect:Int64;
|
|
|
|
FWriteBack:Int64;
|
|
FWriteThrough:Int64;
|
|
FWriteDirect:Int64;
|
|
|
|
FHitCount:Int64;
|
|
FMissCount:Int64;
|
|
|
|
FFailCount:Int64;
|
|
FSuccessCount:Int64;
|
|
|
|
FFlushCount:Int64;
|
|
FDiscardCount:Int64;
|
|
FUnknownCount:Int64;
|
|
|
|
FFirstPage:TCachePage;
|
First Cache Page (Any State)
|
FLastPage:TCachePage;
|
Last Cache Page (Any State)
|
FFirstEmpty:TCachePage;
|
First Free Page
|
FLastEmpty:TCachePage;
|
Last Free Page
|
FFirstClean:TCachePage;
|
First Clean Page (Used with no Write pending)
|
FLastClean:TCachePage;
|
Last Clean Page (Used with no Write pending)
|
FFirstDirty:TCachePage;
|
First Dirty Page (Used with Write pending)
|
FLastDirty:TCachePage;
|
Last Dirty Page (Used with Write pending)
|
|
|
FTimer:TCacheTimer;
|
|
FThread:TCacheThread;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function AddPage(APage:TCachePage):Boolean;
|
|
function RemovePage(APage:TCachePage):Boolean;
|
|
function AddEmpty(APage:TCachePage):Boolean;
|
|
function AddClean(APage:TCachePage):Boolean;
|
|
function AddDirty(APage:TCachePage):Boolean;
|
|
function AddUnknown(APage:TCachePage):Boolean;
|
|
|
|
function UpdateClean(APage:TCachePage):Boolean;
|
|
function UpdateDirty(APage:TCachePage):Boolean;
|
|
|
|
function RoundPageSize(APageSize:LongWord):LongWord;
|
|
function RoundCacheSize(ACacheSize,APageSize:LongWord):LongWord;
|
|
|
|
function LinkPage(APage:TCachePage):Boolean;
|
|
function UnlinkPage(APage:TCachePage):Boolean;
|
|
function LinkEmpty(APage:TCachePage):Boolean;
|
|
function UnlinkEmpty(APage:TCachePage):Boolean;
|
|
function LinkClean(APage:TCachePage):Boolean;
|
|
function UnlinkClean(APage:TCachePage):Boolean;
|
|
function LinkDirty(APage:TCachePage):Boolean;
|
|
function UnlinkDirty(APage:TCachePage):Boolean;
|
|
public
|
property PageSize:LongWord read FPageSize;
|
|
property PageCount:LongWord read FPageCount;
|
|
property CacheSize:LongWord read FCacheSize;
|
|
property CacheMode:TCacheMode read FCacheMode;
|
|
property CacheState:TCacheState read FCacheState;
|
|
property CacheTimeout:LongWord read FCacheTimeout;
|
|
|
|
property ReadCached:Int64 read FReadCached;
|
|
property ReadDirect:Int64 read FReadDirect;
|
|
|
|
property WriteBack:Int64 read FWriteBack;
|
|
property WriteThrough:Int64 read FWriteThrough;
|
|
property WriteDirect:Int64 read FWriteDirect;
|
|
|
|
property HitCount:Int64 read FHitCount;
|
|
property MissCount:Int64 read FMissCount;
|
|
|
|
property FailCount:Int64 read FFailCount;
|
|
property SuccessCount:Int64 read FSuccessCount;
|
|
|
|
property FlushCount:Int64 read FFlushCount;
|
|
property DiscardCount:Int64 read FDiscardCount;
|
|
property UnknownCount:Int64 read FUnknownCount;
|
|
|
|
function OpenCache(ACacheSize,APageSize:LongWord; ACacheMode:TCacheMode):Boolean;
|
|
function CloseCache:Boolean;
|
|
|
|
function DeviceRead(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean;
|
|
function DeviceErase(ADevice:TDiskDevice; ASector:LongWord; ACount:Word):Boolean;
|
|
|
|
function GetDevicePage(ADevice:TDiskDevice; ASector:LongWord):TCachePage; virtual;
|
|
function GetEmptyPage:TCachePage;
|
|
|
|
function AllocDevicePage(ADevice:TDiskDevice; ASector:LongWord; AWrite:Boolean):TCachePage; virtual;
|
|
|
|
function DiscardPage(APage:TCachePage):Boolean;
|
|
function DiscardCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function ReleaseDevicePages(ADevice:TDiskDevice):Boolean;
|
|
|
|
function FlushPage(APage:TCachePage):Boolean;
|
|
function FlushPageEx(APage:TCachePage):Boolean;
|
|
function FlushCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Cache extended
[Expand]
TCacheEx = class(TCache)
| Note: A modified version of TCache which tracks the last used page for faster repeat access. (No longer used)
|
|
|
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FLastUsed:TCachePage;
|
Most recently used Page
|
public
|
function GetDevicePage(ADevice:TDiskDevice; ASector:LongWord):TCachePage; override;
|
|
|
|
function AllocDevicePage(ADevice:TDiskDevice; ASector:LongWord; AWrite:Boolean):TCachePage; override;
|
|
Hash cache
[Expand]
THashCache = class(TObject)
| Note: A block cache with hash keys for faster page lookup.
|
|
|
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FDriver:TFileSysDriver;
|
|
|
|
FLock:TCriticalSectionHandle;
|
|
|
|
FKeyBits:Byte;
|
|
FKeyMask:LongWord;
|
|
FKeyBuckets:Pointer;
|
|
|
|
FBuffer:Pointer;
|
|
FPageSize:LongWord;
|
|
FPageCount:LongWord;
|
|
FCacheSize:LongWord;
|
|
FCacheKeys:LongWord;
|
|
FCacheMode:TCacheMode;
|
|
FCacheState:TCacheState;
|
|
FFlushTimeout:LongWord;
|
|
FDiscardTimeout:LongWord;
|
|
|
|
FReadCached:Int64;
|
|
FReadDirect:Int64;
|
|
|
|
FWriteBack:Int64;
|
|
FWriteThrough:Int64;
|
|
FWriteDirect:Int64;
|
|
|
|
FHitCount:Int64;
|
|
FMissCount:Int64;
|
|
|
|
FFailCount:Int64;
|
|
FSuccessCount:Int64;
|
|
|
|
FFlushCount:Int64;
|
|
FDiscardCount:Int64;
|
|
FUnknownCount:Int64;
|
|
|
|
FFirstPage:TCachePage;
|
First Cache Page (Any State)
|
FLastPage:TCachePage;
|
Last Cache Page (Any State)
|
FFirstEmpty:TCachePage;
|
First Free Page
|
FLastEmpty:TCachePage;
|
Last Free Page
|
FFirstClean:TCachePage;
|
First Clean Page (Used with no Write pending)
|
FLastClean:TCachePage;
|
Last Clean Page (Used with no Write pending)
|
FFirstDirty:TCachePage;
|
First Dirty Page (Used with Write pending)
|
FLastDirty:TCachePage;
|
Last Dirty Page (Used with Write pending)
|
|
|
FTimer:THashCacheTimer;
|
|
FThread:THashCacheThread;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function AddPage(APage:TCachePage):Boolean;
|
|
function RemovePage(APage:TCachePage):Boolean;
|
|
function AddEmpty(APage:TCachePage):Boolean;
|
|
function AddClean(APage:TCachePage):Boolean;
|
|
function AddDirty(APage:TCachePage):Boolean;
|
|
function AddUnknown(APage:TCachePage):Boolean;
|
|
|
|
function UpdateClean(APage:TCachePage):Boolean;
|
|
function UpdateDirty(APage:TCachePage):Boolean;
|
|
|
|
function RoundPageSize(APageSize:LongWord):LongWord;
|
|
function RoundCacheSize(ACacheSize,APageSize:LongWord):LongWord;
|
|
function AdjustCacheKeys(ACacheKeys:LongWord):LongWord;
|
|
|
|
function CalculatePageCount(ADevice:TDiskDevice):Word;
|
|
function CalculatePageShift(ADevice:TDiskDevice):Word;
|
|
function CalculatePageMask(ADevice:TDiskDevice):LongWord;
|
|
|
|
function KeyLink(APage:THashCachePage):Boolean;
|
|
function KeyUnlink(APage:THashCachePage):Boolean;
|
|
function KeyFirst(AKeyHash:LongWord):THashCachePage;
|
|
|
|
function LinkPage(APage:TCachePage):Boolean;
|
|
function UnlinkPage(APage:TCachePage):Boolean;
|
|
function LinkEmpty(APage:TCachePage):Boolean;
|
|
function UnlinkEmpty(APage:TCachePage):Boolean;
|
|
function LinkClean(APage:TCachePage):Boolean;
|
|
function UnlinkClean(APage:TCachePage):Boolean;
|
|
function LinkDirty(APage:TCachePage):Boolean;
|
|
function UnlinkDirty(APage:TCachePage):Boolean;
|
|
public
|
property PageSize:LongWord read FPageSize;
|
|
property PageCount:LongWord read FPageCount;
|
|
property CacheSize:LongWord read FCacheSize;
|
|
property CacheKeys:LongWord read FCacheKeys;
|
|
property CacheMode:TCacheMode read FCacheMode;
|
|
property CacheState:TCacheState read FCacheState;
|
|
property FlushTimeout:LongWord read FFlushTimeout;
|
|
property DiscardTimeout:LongWord read FDiscardTimeout;
|
|
|
|
property ReadCached:Int64 read FReadCached;
|
|
property ReadDirect:Int64 read FReadDirect;
|
|
|
|
property WriteBack:Int64 read FWriteBack;
|
|
property WriteThrough:Int64 read FWriteThrough;
|
|
property WriteDirect:Int64 read FWriteDirect;
|
|
|
|
property HitCount:Int64 read FHitCount;
|
|
property MissCount:Int64 read FMissCount;
|
|
|
|
property FailCount:Int64 read FFailCount;
|
|
property SuccessCount:Int64 read FSuccessCount;
|
|
|
|
property FlushCount:Int64 read FFlushCount;
|
|
property DiscardCount:Int64 read FDiscardCount;
|
|
property UnknownCount:Int64 read FUnknownCount;
|
|
|
|
function OpenCache(ACacheSize,ACacheKeys,APageSize:LongWord; ACacheMode:TCacheMode):Boolean;
|
|
function CloseCache:Boolean;
|
|
|
|
function DeviceRead(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean;
|
|
function DeviceWrite(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; const ABuffer):Boolean;
|
|
function DeviceErase(ADevice:TDiskDevice; ASector:LongWord; ACount:Word):Boolean;
|
|
|
|
function GetDevicePage(ADevice:TDiskDevice; ASector:LongWord):TCachePage; virtual;
|
|
function GetEmptyPage:TCachePage;
|
|
|
|
function AllocDevicePage(ADevice:TDiskDevice; ASector:LongWord; AWrite:Boolean):TCachePage; virtual;
|
|
|
|
function DiscardPage(APage:TCachePage):Boolean;
|
|
function DiscardCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function ReleaseDevicePages(ADevice:TDiskDevice):Boolean;
|
|
|
|
function FlushPage(APage:TCachePage):Boolean;
|
|
function FlushPageEx(APage:TCachePage):Boolean;
|
|
function FlushCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Incremental cache
[Expand]
TIncrementalCache = class(TObject)
| Note: An expanded THashCache with incremental read ahead and dirty region write back.
|
|
|
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
private
|
FDriver:TFileSysDriver;
|
|
|
|
FLock:TCriticalSectionHandle;
|
|
|
|
FKeyBits:Byte;
|
|
FKeyMask:LongWord;
|
|
FKeyBuckets:Pointer;
|
|
|
|
FBuffer:Pointer;
|
|
FPageSize:LongWord;
|
|
FPageCount:LongWord;
|
|
FCacheSize:LongWord;
|
|
FCacheKeys:LongWord;
|
|
FCacheMode:TCacheMode;
|
|
FCacheState:TCacheState;
|
|
FFlushTimeout:LongWord;
|
|
FDiscardTimeout:LongWord;
|
|
|
|
FReadCached:Int64;
|
|
FReadDirect:Int64;
|
|
|
|
FWriteBack:Int64;
|
|
FWriteThrough:Int64;
|
|
FWriteDirect:Int64;
|
|
|
|
FHitCount:Int64;
|
|
FMissCount:Int64;
|
|
|
|
FFailCount:Int64;
|
|
FSuccessCount:Int64;
|
|
|
|
FFlushCount:Int64;
|
|
FDiscardCount:Int64;
|
|
FUnknownCount:Int64;
|
|
|
|
FFirstPage:TCachePage;
|
First Cache Page (Any State)
|
FLastPage:TCachePage;
|
Last Cache Page (Any State)
|
FFirstEmpty:TCachePage;
|
First Free Page
|
FLastEmpty:TCachePage;
|
Last Free Page
|
FFirstClean:TCachePage;
|
First Clean Page (Used with no Write pending)
|
FLastClean:TCachePage;
|
Last Clean Page (Used with no Write pending)
|
FFirstDirty:TCachePage;
|
First Dirty Page (Used with Write pending)
|
FLastDirty:TCachePage;
|
Last Dirty Page (Used with Write pending)
|
|
|
FTimer:TIncrementalCacheTimer;
|
|
FThread:TIncrementalCacheThread;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function AddPage(APage:TCachePage):Boolean;
|
|
function RemovePage(APage:TCachePage):Boolean;
|
|
function AddEmpty(APage:TCachePage):Boolean;
|
|
function AddClean(APage:TCachePage):Boolean;
|
|
function AddDirty(APage:TCachePage):Boolean;
|
|
function AddUnknown(APage:TCachePage):Boolean;
|
|
|
|
function UpdateClean(APage:TCachePage):Boolean;
|
|
function UpdateDirty(APage:TCachePage):Boolean;
|
|
|
|
function RoundPageSize(APageSize:LongWord):LongWord;
|
|
function RoundCacheSize(ACacheSize,APageSize:LongWord):LongWord;
|
|
function AdjustCacheKeys(ACacheKeys:LongWord):LongWord;
|
|
|
|
function CalculatePageCount(ADevice:TDiskDevice):Word;
|
|
function CalculatePageShift(ADevice:TDiskDevice):Word;
|
|
function CalculatePageMask(ADevice:TDiskDevice):LongWord;
|
|
|
|
function KeyLink(APage:THashCachePage):Boolean;
|
|
function KeyUnlink(APage:THashCachePage):Boolean;
|
|
function KeyFirst(AKeyHash:LongWord):THashCachePage;
|
|
|
|
function LinkPage(APage:TCachePage):Boolean;
|
|
function UnlinkPage(APage:TCachePage):Boolean;
|
|
function LinkEmpty(APage:TCachePage):Boolean;
|
|
function UnlinkEmpty(APage:TCachePage):Boolean;
|
|
function LinkClean(APage:TCachePage):Boolean;
|
|
function UnlinkClean(APage:TCachePage):Boolean;
|
|
function LinkDirty(APage:TCachePage):Boolean;
|
|
function UnlinkDirty(APage:TCachePage):Boolean;
|
|
|
|
function PrepareDeviceRead(ADevice:TDiskDevice; APage:TCachePage; var ASector:LongWord; var ACount:Word):Boolean;
|
|
function PrepareDeviceWrite(ADevice:TDiskDevice; APage:TCachePage; var ASector:LongWord; var ACount:Word):Boolean;
|
|
public
|
property PageSize:LongWord read FPageSize;
|
|
property PageCount:LongWord read FPageCount;
|
|
property CacheSize:LongWord read FCacheSize;
|
|
property CacheKeys:LongWord read FCacheKeys;
|
|
property CacheMode:TCacheMode read FCacheMode;
|
|
property CacheState:TCacheState read FCacheState;
|
|
property FlushTimeout:LongWord read FFlushTimeout;
|
|
property DiscardTimeout:LongWord read FDiscardTimeout;
|
|
|
|
property ReadCached:Int64 read FReadCached;
|
|
property ReadDirect:Int64 read FReadDirect;
|
|
|
|
property WriteBack:Int64 read FWriteBack;
|
|
property WriteThrough:Int64 read FWriteThrough;
|
|
property WriteDirect:Int64 read FWriteDirect;
|
|
|
|
property HitCount:Int64 read FHitCount;
|
|
property MissCount:Int64 read FMissCount;
|
|
|
|
property FailCount:Int64 read FFailCount;
|
|
property SuccessCount:Int64 read FSuccessCount;
|
|
|
|
property FlushCount:Int64 read FFlushCount;
|
|
property DiscardCount:Int64 read FDiscardCount;
|
|
property UnknownCount:Int64 read FUnknownCount;
|
|
|
|
function OpenCache(ACacheSize,ACacheKeys,APageSize:LongWord; ACacheMode:TCacheMode):Boolean;
|
|
function CloseCache:Boolean;
|
|
|
|
function DeviceRead(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean;
|
|
function DeviceWrite(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; const ABuffer):Boolean;
|
|
function DeviceErase(ADevice:TDiskDevice; ASector:LongWord; ACount:Word):Boolean;
|
|
|
|
function GetDevicePage(ADevice:TDiskDevice; ASector:LongWord):TCachePage; virtual;
|
|
function GetEmptyPage:TCachePage;
|
|
|
|
function AllocDevicePage(ADevice:TDiskDevice; ASector:LongWord; AWrite:Boolean):TCachePage; virtual;
|
|
|
|
function DiscardPage(APage:TCachePage):Boolean;
|
|
function DiscardCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function ReleaseDevicePages(ADevice:TDiskDevice):Boolean;
|
|
|
|
function FlushPage(APage:TCachePage):Boolean;
|
|
function FlushPageEx(APage:TCachePage):Boolean;
|
|
function FlushCache(AFirst,AAll:Boolean):Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Cache page
[Expand]
TCachePage = class(TObject)
constructor Create;
|
|
destructor Destroy; override;
|
|
private
|
FDevice:TDiskDevice;
|
|
|
|
FData:Pointer;
|
|
|
|
FSector:LongWord;
|
|
FCount:Word;
|
|
|
|
FPageTime:Int64;
|
Time Page was Allocated from Empty (Ticks)
|
FWriteTime:Int64;
|
Time Page was Allocated to Dirty (Ticks)
|
FPageType:TCachePageType;
|
|
FPageState:TCachePageState;
|
|
|
|
FPrevPage:TCachePage;
|
Previous page in Page list
|
FNextPage:TCachePage;
|
Next page in Page list
|
|
|
FPrevLink:TCachePage;
|
Previous page in Empty/Clean/Dirty list
|
FNextLink:TCachePage;
|
Next page in Empty/Clean/Dirty list
|
public
|
property Device:TDiskDevice read FDevice write FDevice;
|
|
|
|
property Data:Pointer read FData write FData;
|
|
|
|
property Sector:LongWord read FSector write FSector;
|
|
property Count:Word read FCount write FCount;
|
|
|
|
property PageTime:Int64 read FPageTime write FPageTime;
|
|
property WriteTime:Int64 read FWriteTime write FWriteTime;
|
|
property PageType:TCachePageType read FPageType write FPageType;
|
|
property PageState:TCachePageState read FPageState write FPageState;
|
|
|
|
property PrevPage:TCachePage read FPrevPage write FPrevPage;
|
|
property NextPage:TCachePage read FNextPage write FNextPage;
|
|
|
|
property PrevLink:TCachePage read FPrevLink write FPrevLink;
|
|
property NextLink:TCachePage read FNextLink write FNextLink;
|
|
Hash cache page
[Expand]
THashCachePage = class(TCachePage)
private
|
FKeyHash:LongWord;
|
|
FKeyPrev:THashCachePage;
|
|
FKeyNext:THashCachePage;
|
|
public
|
property KeyHash:LongWord read FKeyHash write FKeyHash;
|
|
property KeyPrev:THashCachePage read FKeyPrev write FKeyPrev;
|
|
property KeyNext:THashCachePage read FKeyNext write FKeyNext;
|
|
Incremental cache page
[Expand]
TIncrementalCachePage = class(THashCachePage)
private
|
FReadSector:LongWord;
|
|
FReadCount:Word;
|
|
|
|
FDirtySector:LongWord;
|
|
FDirtyCount:Word;
|
|
public
|
property ReadSector:LongWord read FReadSector write FReadSector;
|
|
property ReadCount:Word read FReadCount write FReadCount;
|
|
|
|
property DirtySector:LongWord read FDirtySector write FDirtySector;
|
|
property DirtyCount:Word read FDirtyCount write FDirtyCount;
|
|
|
|
function ReadData:Pointer;
|
|
function DirtyData:Pointer;
|
|
Cache timer
[Expand]
TCacheTimer = class(TObject)
constructor Create(ACache:TCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:TCache;
|
|
|
|
FLock:TMutexHandle;
|
|
FInterval:LongWord;
|
|
FCheckTimer:TTimerHandle;
|
|
FProcessSemaphore:TSemaphoreHandle;
|
|
|
|
FFirst:PCacheTimerItem;
|
|
FLast:PCacheTimerItem;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function Dequeue(AMax:Integer):TCachePage;
|
|
|
|
function FirstKey:Integer;
|
|
function InsertKey(APage:TCachePage; AKey:Integer):Boolean;
|
|
function DeleteKey(APage:TCachePage):Boolean;
|
|
function DecrementKey:Integer;
|
|
public
|
function StartTimer(AInterval:LongWord):Boolean;
|
|
function StopTimer:Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Hash cache timer
[Expand]
THashCacheTimer = class(TObject)
constructor Create(ACache:THashCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:THashCache;
|
|
|
|
FLock:TMutexHandle;
|
|
FInterval:LongWord;
|
|
FCheckTimer:TTimerHandle;
|
|
FProcessSemaphore:TSemaphoreHandle;
|
|
|
|
FFirst:PCacheTimerItem;
|
|
FLast:PCacheTimerItem;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function Dequeue(AMax:Integer):TCachePage;
|
|
|
|
function FirstKey:Integer;
|
|
function InsertKey(APage:TCachePage; AKey:Integer):Boolean;
|
|
function DeleteKey(APage:TCachePage):Boolean;
|
|
function DecrementKey:Integer;
|
|
public
|
function StartTimer(AInterval:LongWord):Boolean;
|
|
function StopTimer:Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Incremental cache timer
[Expand]
TIncrementalCacheTimer = class(TObject)
constructor Create(ACache:TIncrementalCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:TIncrementalCache;
|
|
|
|
FLock:TMutexHandle;
|
|
FInterval:LongWord;
|
|
FCheckTimer:TTimerHandle;
|
|
FProcessSemaphore:TSemaphoreHandle;
|
|
|
|
FFirst:PCacheTimerItem;
|
|
FLast:PCacheTimerItem;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function Dequeue(AMax:Integer):TCachePage;
|
|
|
|
function FirstKey:Integer;
|
|
function InsertKey(APage:TCachePage; AKey:Integer):Boolean;
|
|
function DeleteKey(APage:TCachePage):Boolean;
|
|
function DecrementKey:Integer;
|
|
public
|
function StartTimer(AInterval:LongWord):Boolean;
|
|
function StopTimer:Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function SchedulePage(APage:TCachePage; ATimeout:LongWord):Boolean;
|
|
function UnschedulePage(APage:TCachePage):Boolean;
|
|
Cache thread
[Expand]
TCacheThread = class(TThread)
constructor Create(ACache:TCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:TCache;
|
|
|
|
procedure Execute; override;
|
|
Hash cache thread
[Expand]
THashCacheThread = class(TThread)
constructor Create(ACache:THashCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:THashCache;
|
|
|
|
procedure Execute; override;
|
|
Incremental cache thread
[Expand]
TIncrementalCacheThread = class(TThread)
constructor Create(ACache:TIncrementalCache);
|
|
destructor Destroy; override;
|
|
protected
|
FCache:TIncrementalCache;
|
|
|
|
procedure Execute; override;
|
|
Entry timer
[Expand]
TEntryTimer = class(TObject)
constructor Create(ADriver:TFileSysDriver);
|
|
destructor Destroy; override;
|
|
protected
|
FDriver:TFileSysDriver;
|
|
|
|
FLock:TMutexHandle;
|
|
FInterval:LongWord;
|
|
FCheckTimer:TTimerHandle;
|
|
FProcessTimer:TTimerHandle;
|
|
|
|
FFirst:PEntryTimerItem;
|
|
FLast:PEntryTimerItem;
|
|
|
|
function AcquireLock:Boolean;
|
|
function ReleaseLock:Boolean;
|
|
|
|
function Dequeue:TDiskEntry;
|
|
|
|
function FirstKey:Integer;
|
|
function InsertKey(AEntry:TDiskEntry; AKey:Integer):Boolean;
|
|
function DeleteKey(AEntry:TDiskEntry):Boolean;
|
|
function DecrementKey:Integer;
|
|
public
|
function StartTimer(AInterval:LongWord):Boolean;
|
|
function StopTimer:Boolean;
|
|
|
|
function CheckTimer:Boolean;
|
|
function ProcessTimer:Boolean;
|
|
|
|
function ScheduleEntry(AEntry:TDiskEntry; ATimeout:LongWord):Boolean;
|
|
function UnscheduleEntry(AEntry:TDiskEntry):Boolean;
|
|
Default recognizer
[Expand]
TDefaultRecognizer = class(TRecognizer)
constructor Create(ADriver:TFileSysDriver);
|
|
protected
|
function GetName:String; override;
|
|
public
|
function RecognizePartitionId(APartitionId:Byte):Boolean; override;
|
|
|
|
function RecognizePartition(APartition:TDiskPartition):Boolean; override;
|
|
Default partitioner
[Expand]
TDefaultPartitioner = class(TDiskPartitioner)
constructor Create(ADriver:TFileSysDriver; ARecognizer:TRecognizer);
|
|
public
|
function AcceptPartition(ADevice:TDiskDevice; APartition,AParent:TDiskPartition; APartitionId:Byte):Boolean; override;
|
|
Extended disk controller
[Expand]
TExtDiskController = class(TDiskController)
protected
|
function GetCylinders(ADevice:TDiskDevice):LongWord;
|
|
function GetHeads(ADevice:TDiskDevice):LongWord;
|
|
function GetSectors(ADevice:TDiskDevice):LongWord;
|
|
function GetLogicalShiftCount(ADevice:TDiskDevice):Word;
|
|
ATA disk controller
[Expand]
TATADiskController = class(TDiskController)
constructor Create(ADriver:TFileSysDriver);
|
|
public
|
function ControllerInit:Boolean; override;
|
|
|
|
function LocateDevices:Boolean; override;
|
|
ATAPI disk controller
[Expand]
TATAPIDiskController = class(TDiskController)
constructor Create(ADriver:TFileSysDriver);
|
|
public
|
function ControllerInit:Boolean; override;
|
|
|
|
function LocateDevices:Boolean; override;
|
|
SCSI disk contoller
[Expand]
TSCSIDiskController = class(TDiskController)
constructor Create(ADriver:TFileSysDriver);
|
|
public
|
function ControllerInit:Boolean; override;
|
|
|
|
function LocateDevices:Boolean; override;
|
|
USB disk controller
[Expand]
TUSBDiskController = class(TExtDiskController)
constructor Create(ADriver:TFileSysDriver);
|
|
public
|
function ControllerInit:Boolean; override;
|
|
|
|
function LocateDevices:Boolean; override;
|
|
|
|
function Read(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean; override;
|
|
function Write(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; const ABuffer):Boolean; override;
|
|
|
|
function Reset(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function LockMedia(ADevice:TDiskDevice):Boolean; override;
|
|
function UnlockMedia(ADevice:TDiskDevice):Boolean; override;
|
|
function EjectMedia(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function MediaReady(ADevice:TDiskDevice):Boolean; override;
|
|
function MediaChanged(ADevice:TDiskDevice):Boolean; override;
|
|
function MediaLocked(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function Information(ADevice:TDiskDevice):String; override;
|
|
|
|
function VendorId(ADevice:TDiskDevice):Word; override;
|
|
function DeviceId(ADevice:TDiskDevice):Word; override;
|
|
|
|
function Manufacturer(ADevice:TDiskDevice):String; override;
|
|
function Product(ADevice:TDiskDevice):String; override;
|
|
function SerialNumber(ADevice:TDiskDevice):String; override;
|
|
|
|
function LogicalUnitNo(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function LBA(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function MediaType(ADevice:TDiskDevice):TMediaType; override;
|
|
function FloppyType(ADevice:TDiskDevice):TFloppyType; override;
|
|
function Ready(ADevice:TDiskDevice):Boolean; override;
|
|
function Locked(ADevice:TDiskDevice):Boolean; override;
|
|
function Lockable(ADevice:TDiskDevice):Boolean; override;
|
|
function Ejectable(ADevice:TDiskDevice):Boolean; override;
|
|
function Readable(ADevice:TDiskDevice):Boolean; override;
|
|
function Writeable(ADevice:TDiskDevice):Boolean; override;
|
|
function Removable(ADevice:TDiskDevice):Boolean; override;
|
|
function ChangeLine(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function PhysicalCylinders(ADevice:TDiskDevice):LongWord; override;
|
|
function PhysicalHeads(ADevice:TDiskDevice):LongWord; override;
|
|
function PhysicalSectors(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function LogicalCylinders(ADevice:TDiskDevice):LongWord; override;
|
|
function LogicalHeads(ADevice:TDiskDevice):LongWord; override;
|
|
function LogicalSectors(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function SectorSize(ADevice:TDiskDevice):Word; override;
|
|
function SectorCount(ADevice:TDiskDevice):Int64; override;
|
|
MMC disk controller
[Expand]
TMMCDiskController = class(TExtDiskController)
constructor Create(ADriver:TFileSysDriver);
|
|
public
|
function ControllerInit:Boolean; override;
|
|
|
|
function LocateDevices:Boolean; override;
|
|
|
|
function Read(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; var ABuffer):Boolean; override;
|
|
function Write(ADevice:TDiskDevice; ASector:LongWord; ACount:Word; const ABuffer):Boolean; override;
|
|
function Erase(ADevice:TDiskDevice; ASector:LongWord; ACount:Word):Boolean; override;
|
|
|
|
function Reset(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function LockMedia(ADevice:TDiskDevice):Boolean; override;
|
|
function UnlockMedia(ADevice:TDiskDevice):Boolean; override;
|
|
function EjectMedia(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function MediaReady(ADevice:TDiskDevice):Boolean; override;
|
|
function MediaChanged(ADevice:TDiskDevice):Boolean; override;
|
|
function MediaLocked(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function Information(ADevice:TDiskDevice):String; override;
|
|
|
|
function VendorId(ADevice:TDiskDevice):Word; override;
|
|
function DeviceId(ADevice:TDiskDevice):Word; override;
|
|
|
|
function Manufacturer(ADevice:TDiskDevice):String; override;
|
|
function Product(ADevice:TDiskDevice):String; override;
|
|
function SerialNumber(ADevice:TDiskDevice):String; override;
|
|
|
|
function LogicalUnitNo(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function LBA(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function MediaType(ADevice:TDiskDevice):TMediaType; override;
|
|
function FloppyType(ADevice:TDiskDevice):TFloppyType; override;
|
|
function Ready(ADevice:TDiskDevice):Boolean; override;
|
|
function Locked(ADevice:TDiskDevice):Boolean; override;
|
|
function Lockable(ADevice:TDiskDevice):Boolean; override;
|
|
function Ejectable(ADevice:TDiskDevice):Boolean; override;
|
|
function Readable(ADevice:TDiskDevice):Boolean; override;
|
|
function Writeable(ADevice:TDiskDevice):Boolean; override;
|
|
function Eraseable(ADevice:TDiskDevice):Boolean; override;
|
|
function Removable(ADevice:TDiskDevice):Boolean; override;
|
|
function ChangeLine(ADevice:TDiskDevice):Boolean; override;
|
|
|
|
function PhysicalCylinders(ADevice:TDiskDevice):LongWord; override;
|
|
function PhysicalHeads(ADevice:TDiskDevice):LongWord; override;
|
|
function PhysicalSectors(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function LogicalCylinders(ADevice:TDiskDevice):LongWord; override;
|
|
function LogicalHeads(ADevice:TDiskDevice):LongWord; override;
|
|
function LogicalSectors(ADevice:TDiskDevice):LongWord; override;
|
|
|
|
function SectorSize(ADevice:TDiskDevice):Word; override;
|
|
function SectorCount(ADevice:TDiskDevice):Int64; override;
|
|
File system handle stream
[Expand]
TFSHandleStream = class(TStream)
constructor Create(AHandle:Integer);
|
|
private
|
FHandle:Integer;
|
|
protected
|
procedure SetSize(NewSize:LongInt); override;
|
|
public
|
function Read(var Buffer; Count:LongInt):LongInt; override;
|
|
function Write(const Buffer; Count:LongInt):LongInt; override;
|
|
function Seek(Offset:LongInt; Origin:Word):LongInt; override;
|
|
property Handle:Integer read FHandle;
|
|
File system file stream
[Expand]
TFSFileStream = class(TFSHandleStream)
constructor Create(const FileName:String; Mode:Word);
|
|
destructor Destroy; override;
|
|
private
|
|
|
public
|
|
|
File system handle stream extended
[Expand]
TFSHandleStreamEx = class(TStreamEx)
constructor Create(AHandle:Integer);
|
|
private
|
FHandle:Integer;
|
|
protected
|
procedure SetSize(NewSize:LongInt); override;
|
|
procedure SetSizeEx(const NewSize:Int64); override;
|
|
public
|
function Read(var Buffer; Count:LongInt):LongInt; override;
|
|
function Write(const Buffer; Count:LongInt):LongInt; override;
|
|
function Seek(Offset:LongInt; Origin:Word):LongInt; override;
|
|
function SeekEx(const Offset:Int64; Origin:Word):Int64; override;
|
|
property Handle:Integer read FHandle;
|
|
File system file stream extended
[Expand]
TFSFileStreamEx = class(TFSHandleStreamEx)
constructor Create(const FileName:String; Mode:Word);
|
|
destructor Destroy; override;
|
|
private
|
|
|
public
|
|
|
Public variables
FileSystem logging
FILESYS_DEFAULT_LOG_LEVEL:LongWord = FILESYS_LOG_LEVEL_DEBUG;
|
Minimum level for FileSystem messages. Only messages with level greater than or equal to this will be printed.
|
FILESYS_LOG_ENABLED:Boolean;
|
|
FileSystem specific variables
FileSysDriver:TFileSysDriver;
|
|
Function declarations
Initialization functions
[Expand]
procedure FileSysInit;
Description: To be documented
[Expand]
function FileSysStart:LongWord;
Description: To be documented
[Expand]
function FileSysStop:LongWord;
Description: To be documented
[Expand]
procedure FileSysAsyncStart(Data:Pointer);
Description: To be documented
FileSystem functions (Delphi/FreePascal RTL Equivalent)
Drive functions
[Expand]
function FSGetPathDrive(const APath:String):Byte; inline;
Description: To be documented
[Expand]
function FSGetDriveType(ADrive:Byte):TDriveType; inline;
Description: To be documented
[Expand]
function FSGetDriveData(ADrive:Byte):TDriveData; inline;
Description: To be documented
[Expand]
function FSGetDriveAttr(ADrive:Byte):LongWord; inline;
Description: To be documented
[Expand]
function FSGetDriveLabel(ADrive:Byte):String; inline;
Description: To be documented
[Expand]
function FSSetDriveLabel(ADrive:Byte; const ALabel:String):Boolean; inline;
Description: To be documented
[Expand]
function FSGetDriveSerial(ADrive:Byte):LongWord; inline;
Description: To be documented
[Expand]
function FSSetDriveSerial(ADrive:Byte; ASerial:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSIsDriveValid(ADrive:Byte):Boolean; inline;
Description: To be documented
[Expand]
function FSGetValidDrives:LongWord; inline;
Description: To be documented
[Expand]
function FSGetValidDriveNames:TStringList; inline;
Description: To be documented
[Expand]
function FSGetValidDriveStrings:String; inline;
Description: To be documented
[Expand]
function FSGetDriveFreeSpace(ADrive:Byte):LongWord; inline;
Description: To be documented
[Expand]
function FSGetDriveFreeSpaceEx(ADrive:Byte):Int64; inline;
Description: To be documented
[Expand]
function FSGetDriveTotalSpace(ADrive:Byte):LongWord; inline;
Description: To be documented
[Expand]
function FSGetDriveTotalSpaceEx(ADrive:Byte):Int64; inline;
Description: To be documented
[Expand]
function FSGetCurrentDrive:Byte; inline;
Description: To be documented
[Expand]
function FSSetCurrentDrive(const ADrive:String):Boolean; inline;
Description: To be documented
File functions
[Expand]
function FSFileOpen(const AFileName:String; AMode:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileCreate(const AFileName:String):Integer; inline;
Description: To be documented
[Expand]
function FSDeleteFile(const AFileName:String):Boolean; inline;
Description: To be documented
[Expand]
procedure FSFileClose(AHandle:Integer); inline;
Description: To be documented
[Expand]
function FSRenameFile(const AOldName,ANewName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSFileSeek(AHandle,AOffset,AOrigin:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileFlush(AHandle:Integer):Boolean; inline;
Description: To be documented
[Expand]
function FSFileTruncate(AHandle:Integer):Boolean; inline;
Description: To be documented
[Expand]
function FSSetEndOfFile(AHandle:THandle):Boolean; inline;
Description: To be documented
[Expand]
function FSEndOfFile(AHandle:Integer):Boolean; inline;
Description: To be documented
[Expand]
function FSFilePos(AHandle:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileSize(AHandle:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileAge(const AFileName:String):Integer; inline;
Description: To be documented
[Expand]
function FSFileExists(const AFileName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSFileGetAttr(const AFileName:String):Integer; inline;
Description: To be documented
[Expand]
function FSFileGetDate(AHandle:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileSetAttr(const AFileName:String; AAttr:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileSetDate(AHandle:Integer; AAge:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileRead(AHandle:Integer; var ABuffer; ACount:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileWrite(AHandle:Integer; const ABuffer; ACount:Integer):Integer; inline;
Description: To be documented
Directory functions
[Expand]
function FSCreateDir(const ADirName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSRemoveDir(const ADirName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSRenameDir(const AOldName,ANewName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSGetCurrentDir:String; inline;
Description: To be documented
[Expand]
function FSSetCurrentDir(const ADirName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSDirectoryExists(const ADirName:String):Boolean; inline;
Description: To be documented
[Expand]
procedure FSForceDirectories(ADirName:String); inline;
Description: To be documented
[Expand]
procedure FSDeleteTree(const ADirName:String); inline;
Description: To be documented
Search functions
[Expand]
function FSFindFirst(const APath:String; AAttr:Integer; var ASearchRec:TSearchRec):Integer; inline;
Description: To be documented
[Expand]
function FSFindNext(var ASearchRec:TSearchRec):Integer; inline;
Description: To be documented
[Expand]
procedure FSFindClose(var ASearchRec:TSearchRec); inline;
Description: To be documented
Additional functions
[Expand]
function FSFileCopy(const ASourceFile,ADestFile:String; AFailIfExists:Boolean):Boolean; inline;
Description: To be documented
[Expand]
function FSFileCopyEx(const ASourceFile,ADestFile:String; AFailIfExists:Boolean; AUseSourceDate:Boolean; ADestDate:Integer; AUseSourceAttr:Boolean; ADestAttr:Integer):Boolean; inline;
Description: To be documented
[Expand]
function FSGetShortName(const AFileName:String):String; inline;
Description: To be documented
[Expand]
function FSGetLongName(const AFileName:String):String; inline;
Description: To be documented
[Expand]
function FSGetTrueName(const AFileName:String):String; inline;
Description: To be documented
Extended functions
[Expand]
function FSFileSeekEx(AHandle:Integer; const AOffset:Int64; AOrigin:Integer):Int64; inline;
Description: To be documented
[Expand]
function FSEndOfFileEx(AHandle:Integer):Boolean; inline;
Description: To be documented
[Expand]
function FSFilePosEx(AHandle:Integer):Int64; inline;
Description: To be documented
[Expand]
function FSFileSizeEx(AHandle:THandle):Int64; inline;
Description: To be documented
[Expand]
function FSFileAgeEx(const AFileName:String):TFileTime; inline;
Description: To be documented
[Expand]
function FSFileGetAttrEx(AHandle:Integer):Integer; inline;
Description: To be documented
[Expand]
function FSFileGetDateEx(AHandle:Integer):TFileTime; inline;
Description: To be documented
[Expand]
function FSFileSetDateEx(AHandle:Integer; AAge:TFileTime):Integer; inline;
Description: To be documented
[Expand]
function FSGetFileTime(AHandle:THandle; ACreateTime,AAccessTime,AWriteTime:PFileTime):Boolean; inline;
Description: To be documented
[Expand]
function FSSetFileTime(AHandle:THandle; ACreateTime,AAccessTime,AWriteTime:PFileTime):Boolean; inline;
Description: To be documented
[Expand]
function FSFindFirstEx(const APath:String; var ASearchRec:TFileSearchRec):Integer; inline;
Description: To be documented
[Expand]
function FSFindNextEx(var ASearchRec:TFileSearchRec):Integer; inline;
Description: To be documented
[Expand]
procedure FSFindCloseEx(var ASearchRec:TFileSearchRec); inline;
Description: To be documented
FileSystem functions (Win32 Compatibility)
Drive functions
[Expand]
function FSDefineDosDevice(const ADeviceName,ATargetPath:String; AFlags:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSGetDiskType(const ARootPath:String):LongWord; inline;
Description: Equivalent to Win32 GetDriveType
[Expand]
function FSGetDiskFreeSpace(const ARootPath:String; var ASectorsPerCluster,ABytesPerSector,ANumberOfFreeClusters,ATotalNumberOfClusters:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSGetDiskFreeSpaceEx(const APathName:String; var AFreeBytesAvailableToCaller,ATotalNumberOfBytes,ATotalNumberOfFreeBytes:Int64):Boolean; inline;
Description: To be documented
[Expand]
function FSGetLogicalDrives:LongWord; inline;
Description: To be documented
[Expand]
function FSGetLogicalDriveStrings:String; inline;
Description: To be documented
[Expand]
function FSGetVolumeInformation(const ARootPath:String; var AVolumeName:String; var AVolumeSerialNumber,AMaximumComponentLength,AFileSystemFlags:LongWord; var ASystemName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSQueryDosDevice(const ARootPath:String):String; inline;
Description: To be documented
[Expand]
function FSSetVolumeLabel(const AVolume:String; const ALabel:String):Boolean; inline;
Description: To be documented
File functions
[Expand]
function FSAreFileApisANSI:Boolean; inline;
Description: To be documented
[Expand]
function FSCloseFile(AHandle:THandle):Boolean; inline;
Description: Equivalent to Win32 CloseHandle
[Expand]
function FSCopyFile(const AExistingName,ANewName:String; AFailIfExists:Boolean):Boolean; inline;
Description: To be documented
[Expand]
function FSCreateFile(const AFileName:String; AAccessMode,AShareMode,ACreateFlags,AFileAttributes:LongWord):THandle; inline;
Description: To be documented
[Expand]
function FSFindCloseFile(AHandle:THandle):Boolean; inline;
Description: Equivalent to Win32 FindClose
[Expand]
function FSFindFirstFile(const AFileName:String; var AFindData:TWin32FindData):THandle; inline;
Description: To be documented
[Expand]
function FSFindNextFile(AHandle:THandle; var AFindData:TWin32FindData):Boolean; inline;
Description: To be documented
[Expand]
function FSFlushFileBuffers(AHandle:THandle):Boolean; inline;
Description: To be documented
[Expand]
function FSGetFileAttributes(const AFileName:String):LongWord; inline;
Description: To be documented
[Expand]
function FSGetFileSize(AHandle:THandle; var AFileSizeHigh:LongWord):LongWord; inline;
Description: To be documented
[Expand]
function FSGetFullPathName(const AFileName:String):String; inline;
Description: To be documented
[Expand]
function FSGetShortPathName(const ALongPath:String):String; inline;
Description: To be documented
[Expand]
function FSMoveFile(const AExistingName,ANewName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSReadFile(AHandle:THandle; var ABuffer; ABytesToRead:LongWord; var ABytesRead:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSSetFileApisToANSI:Boolean; inline;
Description: To be documented
[Expand]
function FSSetFileApisToOEM:Boolean; inline;
Description: To be documented
[Expand]
function FSSetFileAttributes(const AFileName:String; AFileAttributes:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSSetFilePointer(AHandle:THandle; ADistanceToMove:LongWord; var ADistanceToMoveHigh:LongWord; AMoveMethod:LongWord):LongWord; inline;
Description: To be documented
[Expand]
function FSSetFilePointerEx(AHandle:THandle; const ADistanceToMove:Int64; var ANewFilePointer:Int64; AMoveMethod:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSWriteFile(AHandle:THandle;const ABuffer; ABytesToWrite:LongWord; var ABytesWritten:LongWord):Boolean; inline;
Description: To be documented
[Expand]
function FSGetLongPathName(const AShortPath:String):String; inline;
Description: To be documented
[Expand]
function FSSetFileShortName(const AFileName,AShortName:String):Boolean;
Description: To be documented
[Expand]
function FSSetFileShortNameEx(AHandle:THandle; const AShortName:String):Boolean;
Description: To be documented
[Expand]
function FSCreateHardLink(const ALinkName,AFileName:String):Boolean;
Description: To be documented
[Expand]
function FSCreateSymbolicLink(const ALinkName,ATargetName:String; ADirectory:Boolean):Boolean;
Description: To be documented
Directory functions
[Expand]
function FSCreateDirectory(const APathName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSGetCurrentDirectory:String; inline;
Description: To be documented
[Expand]
function FSRemoveDirectory(const APathName:String):Boolean; inline;
Description: To be documented
[Expand]
function FSSetCurrentDirectory(const APathName:String):Boolean; inline;
Description: To be documented
RTL FileSystem functions
System file functions
[Expand]
procedure SystemDoClose(Handle:THandle);
Description: To be documented
[Expand]
procedure SystemDoErase(Name:PChar; NameChangeable:Boolean);
Description: To be documented
[Expand]
procedure SystemDoRename(Name1,Name2:PChar; Name1Changeable,Name2Changeable:Boolean);
Description: To be documented
[Expand]
function SystemDoWrite(Handle:THandle; Address:Pointer; Len:LongInt):LongInt;
Description: To be documented
[Expand]
function SystemDoRead(Handle:THandle; Address:Pointer; Len:LongInt):LongInt;
Description: To be documented
[Expand]
function SystemDoFilePos(Handle:THandle):LongInt;
Description: To be documented
[Expand]
procedure SystemDoSeek(Handle:THandle; Pos:LongInt);
Description: To be documented
[Expand]
function SystemDoSeekEnd(Handle:THandle):LongInt;
Description: To be documented
[Expand]
function SystemDoFileSize(Handle:THandle):LongInt;
Description: To be documented
[Expand]
procedure SystemDoTruncate(Handle:THandle; Pos:LongInt);
Description: To be documented
[Expand]
procedure SystemDoOpen(var F; Name:PFileTextRecChar; Flags:LongInt; NameChangeable:Boolean);
Description: To be documented
| Note
|
FileRec and TextRec have both Handle and Mode as the first items so they could use the same routine for opening/creating.
- When (Flags and $00100) The file will be Appended
- When (Flags and $01000) The file will be Truncated/rewritten
- When (Flags and $10000) There is no check for Close (needed for TextFiles)
|
System directory functions
[Expand]
procedure SystemDoMkDir(const Dir:RawByteString);
Description: To be documented
[Expand]
procedure SystemDoRmDir(const Dir:RawByteString);
Description: To be documented
[Expand]
procedure SystemDoChDir(const Dir:RawByteString);
Description: To be documented
[Expand]
procedure SystemDoGetDir(Drive:Byte; var Dir:RawByteString);
Description: To be documented
Dos disk functions
[Expand]
function DosDiskFree(Drive:Byte):Int64;
Description: To be documented
[Expand]
function DosDiskSize(Drive:Byte):Int64;
Description: To be documented
Dos FindFirst/FindNext functions
[Expand]
function DosFindMatchingFile(var f:SearchRec):Integer;
Description: Internal Only
[Expand]
function DosFindFirst(const Path:PathStr; Attr:Word; var f:SearchRec):Integer;
Description: To be documented
| Note
|
FindFirst/FindNext/FindClose - To be compatible with the DOS. FindFirst/FindNext we always allow faReadOnly and faArchive but only allow other attributes if requested. This is done by matching all files and filtering with FindMatchingFile.
|
[Expand]
function DosFindNext(var f:SearchRec):Integer;
Description: To be documented
[Expand]
procedure DosFindClose(var f:SearchRec);
Description: To be documented
Dos file functions
[Expand]
function DosGetFTime(var f; var Time:LongInt):Integer;
Description: To be documented
[Expand]
function DosSetFTime(var f; Time:LongInt):Integer;
Description: To be documented
[Expand]
function DosGetFAttr(var f; var Attr:Word):Integer;
Description: To be documented
[Expand]
function DosSetFAttr(var f; Attr:Word):Integer;
Description: To be documented
[Expand]
function DosGetShortName(var p:ShortString):Boolean;
Description: To be documented
[Expand]
function DosGetLongName(var p:ShortString):Boolean;
Description: To be documented
SysUtils file functions
[Expand]
function SysUtilsFileOpen(const FileName:RawByteString; Mode:Integer):THandle;
Description: To be documented
[Expand]
function SysUtilsFileCreate(const FileName:RawByteString):THandle;
Description: To be documented
[Expand]
function SysUtilsDeleteFile(const FileName:RawByteString):Boolean;
Description: To be documented
[Expand]
procedure SysUtilsFileClose(Handle:THandle);
Description: To be documented
[Expand]
function SysUtilsRenameFile(const OldName,NewName:RawByteString):Boolean;
Description: To be documented
[Expand]
function SysUtilsFileSeek(Handle:THandle; Offset,Origin:LongInt):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileTruncate(Handle:THandle;Size:Int64):Boolean;
Description: To be documented
[Expand]
function SysUtilsFileAge(const FileName:RawByteString):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileExists(const FileName:RawByteString):Boolean;
Description: To be documented
[Expand]
function SysUtilsFileGetAttr(const FileName:RawByteString):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileGetDate(Handle:THandle):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileSetAttr(const FileName:RawByteString; Attr:LongInt):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileSetDate(Handle:THandle; Age:LongInt):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileRead(Handle:THandle; out Buffer; Count:LongInt):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileWrite(Handle:THandle; const Buffer; Count:LongInt):LongInt;
Description: To be documented
[Expand]
function SysUtilsFileSeekEx(Handle:THandle; Offset:Int64; Origin:LongInt):Int64;
Description: To be documented
[Expand]
function SysUtilsInternalFindFirst(const Path:RawByteString; Attr:LongInt; out SearchRec:TSearchRec; var Name:RawByteString):LongInt;
Description: To be documented
[Expand]
function SysUtilsInternalFindNext(var SearchRec:TSearchRec; var Name:RawByteString):LongInt;
Description: To be documented
[Expand]
procedure SysUtilsInternalFindClose(var Handle:THandle);
Description: To be documented
SysUtils disk functions
[Expand]
function SysUtilsDiskFree(Drive:Byte):Int64;
Description: To be documented
[Expand]
function SysUtilsDiskSize(Drive:Byte):Int64;
Description: To be documented
[Expand]
function SysUtilsDirectoryExists(const Directory:RawByteString):Boolean;
Description: To be documented
FileSystem logging functions
[Expand]
function FileSysLoggingStart(Logging:PLoggingDevice):LongWord;
Description: To be documented
[Expand]
function FileSysLoggingStop(Logging:PLoggingDevice):LongWord;
Description: To be documented
[Expand]
function FileSysLoggingOutput(Logging:PLoggingDevice; const Data:String):LongWord;
Description: To be documented
[Expand]
function FileSysLoggingSetTarget(Logging:PLoggingDevice; const Target:String):LongWord;
Description: To be documented
FileSystem helper functions
[Expand]
function FileSysStorageGetMediaType(Storage:PStorageDevice):TMediaType;
Description: To be documented
[Expand]
function FileSysStorageGetController(Storage:PStorageDevice):TDiskController;
Description: To be documented
[Expand]
procedure FileSysStorageDeviceAdd(Event:PStorageDeviceEvent);
Description: To be documented
[Expand]
procedure FileSysStorageDeviceInsert(Event:PStorageDeviceEvent);
Description: To be documented
[Expand]
function FileSysStorageDeviceRemove(Storage:PStorageDevice):LongWord;
Description: To be documented
[Expand]
function FileSysStorageDeviceEject(Storage:PStorageDevice):LongWord;
Description: To be documented
[Expand]
function FileSysStorageDeviceEnum(Storage:PStorageDevice; Data:Pointer):LongWord;
Description: To be documented
[Expand]
function FileSysStorageDeviceNotify(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;
Description: To be documented
[Expand]
function ComparePartitions(APartition1,APartition2:Pointer):Integer;
Description: Sort partitions in order of start sector
[Expand]
procedure FileSysLog(Level:Integer;const AText:String);
Description: To be documented
[Expand]
procedure FileSysLogInfo(const AText:String); inline;
Description: To be documented
[Expand]
procedure FileSysLogError(const AText:String); inline;
Description: To be documented
[Expand]
procedure FileSysLogDebug(const AText:String); inline;
Description: To be documented
[Expand]
procedure CacheCheckTimer(Data:Pointer);
Description: To be documented
[Expand]
procedure EntryCheckTimer(Data:Pointer);
Description: To be documented
[Expand]
procedure EntryProcessTimer(Data:Pointer);
Description: To be documented
[Expand]
function MediaTypeToString(AType:TMediaType):String;
Description: To be documented
[Expand]
function FloppyTypeToString(AType:TFloppyType):String;
Description: To be documented
[Expand]
function ImageTypeToString(AType:TImageType):String;
Description: To be documented
[Expand]
function DriveTypeToString(AType:TDriveType):String;
Description: To be documented
[Expand]
function FileSysTypeToString(AType:TFileSysType):String;
Description: To be documented
[Expand]
function StringToFileSysType(const AFileSysType:String):TFileSysType;
Description: To be documented
[Expand]
function PartitionIdToString(AId:Byte):String;
Description: To be documented
[Expand]
function StringToPartitionId(const APartitionId:String):Byte;
Description: To be documented
[Expand]
function CacheModeToString(ACacheMode:TCacheMode):String;
Description: To be documented
[Expand]
function CacheStateToString(ACacheState:TCacheState):String;
Description: To be documented
[Expand]
function CachePageTimeToDateTime(const APageTime:Int64):TDateTime;
Description: To be documented
Return to Unit Reference
