public PrimaryVolumeDescriptor(Hardware.Devices.DiskDevice disk, uint startBlock, uint numBlocks, byte[] data)
: base(disk, startBlock, numBlocks, data)
{
SystemIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 8, 32);
VolumeIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 40, 32);
VolumeSpaceSize = ByteConverter.ToUInt32(data, 80);
VolumeSetSize = ByteConverter.ToUInt16(data, 120);
VolumeSequenceNumber = ByteConverter.ToUInt16(data, 124);
LogicalBlockSize = ByteConverter.ToUInt16(data, 128);
PathTableSize = ByteConverter.ToUInt32(data, 132);
Location_PathTable_TypeL = ByteConverter.ToUInt32(data, 140);
Location_PathTable_Optional_TypeL = ByteConverter.ToUInt32(data, 144);
RootDirectory = new DirectoryRecord(data, 156, true);
VolumeSetIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 190, 128);
PublisherIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 318, 128);
DataPreparerIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 446, 128);
ApplicationIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 574, 128);
CopyrightFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 702, 38);
AbstractFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 740, 36);
BibliographicFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 776, 37);
VolumeCreationDateTime = new DateTime(data, 813);
VolumeModificationDateTime = new DateTime(data, 830);
VolumeExpirationDateTime = new DateTime(data, 847);
VolumeEffectiveDateTime = new DateTime(data, 864);
FileStructureVersion = data[881];
}
public FOS_System.String TrimEnd()
{
// All characters in the Zs, Zp and Zl Unicode categories, plus U+0009 CHARACTER TABULATION, U+000A LINE FEED, U+000B LINE TABULATION, U+000C FORM FEED, U+000D CARRIAGE RETURN and U+0085 NEXT LINE
FOS_System.String TrimChars = "\u0009\u000A\u000B\u000C\u000D\u0020\u0085\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000";
int removeEnd = 0;
for (int i = this.length - 1; i > -1; removeEnd++, i--)
{
bool ShouldBreak = true;
for (int j = 0; j < TrimChars.length; j++)
{
if (this[i] == TrimChars[j])
{
ShouldBreak = false;
}
}
if (ShouldBreak)
{
break;
}
}
FOS_System.String result = New(this.length - removeEnd);
for (int i = 0; i < this.length - removeEnd; i++)
{
result[i] = this[i];
}
return(result);
}
/// <summary>
/// Attempts to find the specified directory within any file system.
/// </summary>
/// <param name="directoryName">The full path and name of the directory to find.</param>
/// <returns>The directory or null if it isn't found.</returns>
public static Directory Find(FOS_System.String directoryName)
{
FileSystemMapping theMapping = FileSystemManager.GetMapping(directoryName);
if (theMapping == null)
{
return(null);
}
directoryName = theMapping.RemoveMappingPrefix(directoryName);
directoryName = directoryName.ToUpper();
Base baseListing = theMapping.TheFileSystem.GetListing(directoryName);
if (baseListing == null)
{
return(null);
}
else
{
if (baseListing is Directory)
{
return((Directory)baseListing);
}
else
{
return(null);
}
}
}
public static void DBGERR(FOS_System.String testName, FOS_System.String msg)
{
BasicConsole.SetTextColour(BasicConsole.error_colour);
DBGMSG(testName, msg);
BasicConsole.SetTextColour(BasicConsole.default_colour);
errors++;
}
public VolumeDescriptor(Hardware.Devices.DiskDevice disk, uint startBlock, uint numBlocks, byte[] data)
: base(disk, 0, 0)
{
Code = (TypeCodes)data[0];
Id = ByteConverter.GetASCIIStringFromASCII(data, 1, 5);
Version = data[6];
}
private static void EnterCritical(FOS_System.String caller)
{
//BasicConsole.WriteLine("Entering critical section...");
if (AccessLockInitialised)
{
if (AccessLock == null)
{
BasicConsole.WriteLine("HeapAccessLock is initialised but null?!");
BasicConsole.DelayOutput(10);
}
else
{
if (AccessLock.Locked && OutputTrace)
{
BasicConsole.SetTextColour(BasicConsole.warning_colour);
BasicConsole.WriteLine("Warning: Heap about to try to re-enter spin lock...");
BasicConsole.Write("Enter lock caller: ");
BasicConsole.WriteLine(caller);
BasicConsole.SetTextColour(BasicConsole.default_colour);
}
AccessLock.Enter();
}
}
//else
//{
// BasicConsole.WriteLine("HeapAccessLock not initialised - ignoring lock conditions.");
// BasicConsole.DelayOutput(5);
//}
}
public virtual Thread CreateThread(ThreadStartMethod MainMethod, FOS_System.String Name)
{
#if PROCESS_TRACE
BasicConsole.WriteLine("Process: CreateThread: Creating thread...");
#endif
//TODO: Wrap EnableKernelAccessToProcessMemory in try-finally blocks
// Required so that page allocations by new Thread don't create conflicts
ProcessManager.EnableKernelAccessToProcessMemory(this);
Thread newThread = new Thread(this, MainMethod, ThreadIdGenerator++, UserMode, Name);
#if PROCESS_TRACE
BasicConsole.WriteLine("Adding data page...");
#endif
// Add the page to the processes memory layout
uint threadStackVirtAddr = (uint)newThread.State->ThreadStackTop - 4092;
uint threadStackPhysAddr = (uint)VirtMemManager.GetPhysicalAddress(newThread.State->ThreadStackTop - 4092);
TheMemoryLayout.AddDataPage(threadStackPhysAddr, threadStackVirtAddr);
ProcessManager.DisableKernelAccessToProcessMemory(this);
#if PROCESS_TRACE
BasicConsole.WriteLine("Adding thread...");
#endif
Threads.Add(newThread);
if (Registered)
{
Scheduler.InitThread(this, newThread);
}
return(newThread);
}
/// <summary>
/// Initializes a new base listing.
/// </summary>
/// <param name="aFileSystem">The file system to which the listing belongs.</param>
/// <param name="parent">The parent directory of the listing.</param>
/// <param name="aName">The name of the listing.</param>
/// <param name="isDirectory">Whether the listing is a directory or not.</param>
protected Base(FileSystem aFileSystem, Directory parent, FOS_System.String aName, bool isDirectory)
{
TheFileSystem = aFileSystem;
Name = aName;
IsDirectory = isDirectory;
Parent = parent;
}
public FOS_System.String ToString()
{
FOS_System.String result = "";
result = result + "Code pages:\r\n";
UInt32Dictionary.Iterator iterator = CodePages.GetIterator();
while (iterator.HasNext())
{
UInt32Dictionary.KeyValuePair pair = iterator.Next();
uint vAddr = pair.Key;
uint pAddr = pair.Value;
result = result + vAddr + " -> " + pAddr + "\r\n";
}
result = result + "\r\n";
result = result + "Data pages:\r\n";
iterator = DataPages.GetIterator();
while (iterator.HasNext())
{
UInt32Dictionary.KeyValuePair pair = iterator.Next();
uint vAddr = pair.Key;
uint pAddr = pair.Value;
result = result + vAddr + " -> " + pAddr + "\r\n";
}
return(result);
}
public FOS_System.String ToString()
{
FOS_System.String result = "";
result = result + "Code pages:\r\n";
for (int i = 0; i < CodePages.Keys.Count; i++)
{
uint vAddr = CodePages.Keys[i];
uint pAddr = CodePages[vAddr];
result = result + vAddr + " -> " + pAddr + "\r\n";
}
result = result + "\r\n";
result = result + "Data pages:\r\n";
for (int i = 0; i < DataPages.Keys.Count; i++)
{
uint vAddr = DataPages.Keys[i];
uint pAddr = DataPages[vAddr];
result = result + vAddr + " -> " + pAddr + "\r\n";
}
return(result);
}
public virtual Thread CreateThread(ThreadStartMethod MainMethod, FOS_System.String Name)
{
#if PROCESS_TRACE
BasicConsole.WriteLine("Creating thread...");
#endif
Thread newThread = new Thread(this, MainMethod, ThreadIdGenerator++, UserMode, Name);
#if PROCESS_TRACE
BasicConsole.WriteLine("Adding data page...");
#endif
// Add the page to the processes memory layout
uint threadStackVirtAddr = (uint)newThread.State->ThreadStackTop - 4092;
uint threadStackPhysAddr = (uint)VirtMemManager.GetPhysicalAddress(newThread.State->ThreadStackTop - 4092);
TheMemoryLayout.AddDataPage(threadStackPhysAddr, threadStackVirtAddr);
if (ProcessManager.KernelProcess != null)
{
ProcessManager.KernelProcess.TheMemoryLayout.AddDataPage(threadStackPhysAddr, threadStackVirtAddr);
}
#if PROCESS_TRACE
BasicConsole.WriteLine("Adding thread...");
#endif
Threads.Add(newThread);
if (Registered)
{
Scheduler.InitThread(this, newThread);
}
return(newThread);
}
public void Write(FOS_System.String str)
{
for (int i = 0; i < str.length; i++)
{
Write((byte)str[i]);
}
}
/// <summary>
/// Parses a string as an unsigned hexadecimal integer.
/// </summary>
/// <param name="str">The string to parse.</param>
/// <param name="offset">The offset into the string at which to start parsing.</param>
/// <returns>The parsed uint.</returns>
public static uint Parse_HexadecimalUnsigned(FOS_System.String str, int offset)
{
str = str.ToLower();
if (str.length - offset >= 2)
{
if (str[offset] == '0' && str[offset + 1] == 'x')
{
offset += 2;
}
}
uint result = 0;
for (int i = offset; i < str.length; i++)
{
char c = str[i];
if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
{
break;
}
result *= 16;
if (c >= '0' && c <= '9')
{
result += (uint)(c - '0');
}
else
{
result += (uint)(c - 'a') + 10;
}
}
return(result);
}
/// <summary>
/// Opens the specified file.
/// </summary>
/// <param name="fileName">The full path to the file to open.</param>
/// <returns>The file listing or null if not found.</returns>
public static File Open(FOS_System.String fileName)
{
FileSystemMapping theMapping = FileSystemManager.GetMapping(fileName);
if (theMapping == null)
{
return(null);
}
fileName = theMapping.RemoveMappingPrefix(fileName);
fileName = fileName.ToUpper();
Base baseListing = theMapping.TheFileSystem.GetListing(fileName);
if (baseListing == null)
{
return(null);
}
else
{
if (baseListing is File)
{
return((File)baseListing);
}
else
{
return(null);
}
}
}
public VolumeDescriptor(Hardware.Devices.DiskDevice disk, uint startBlock, uint numBlocks, byte[] data)
: base(disk, 0, 0)
{
Code = (TypeCodes)data[0];
Id = ByteConverter.GetASCIIStringFromASCII(data, 1, 5);
Version = data[6];
}
public static Process CreateProcess(ThreadStartMethod MainMethod, FOS_System.String Name, bool UserMode, bool CreateHeap)
{
#if PROCESSMANAGER_TRACE
BasicConsole.WriteLine("Creating process object...");
#endif
return(new Process(MainMethod, ProcessIdGenerator++, Name, UserMode, CreateHeap));
}
/// <summary>
/// Initializes a new base listing.
/// </summary>
/// <param name="aFileSystem">The file system to which the listing belongs.</param>
/// <param name="parent">The parent directory of the listing.</param>
/// <param name="aName">The name of the listing.</param>
/// <param name="isDirectory">Whether the listing is a directory or not.</param>
protected Base(FileSystem aFileSystem, Directory parent, FOS_System.String aName, bool isDirectory)
{
TheFileSystem = aFileSystem;
Name = aName;
IsDirectory = isDirectory;
Parent = parent;
}
public FOS_System.String PadLeft(int totalLength, char padChar)
{
FOS_System.String result = New(totalLength);
if (this.length >= totalLength)
{
for (int i = 0; i < result.length; i++)
{
result[i] = this[i];
}
return(result);
}
int offset = totalLength - this.length;
for (int i = 0; i < this.length; i++)
{
result[i + offset] = this[i];
}
for (int i = 0; i < offset; i++)
{
result[i] = padChar;
}
return(result);
}
/// <summary>
/// Initializes a new FAT directory.
/// </summary>
/// <param name="aFileSystem">The FAT file system to which the directory belongs.</param>
/// <param name="parent">The FAT directory which is the parent of the directory. Null for the root directory.</param>
/// <param name="aName">The name of the directory.</param>
/// <param name="aFirstCluster">The first cluster number of the directory.</param>
public FATDirectory(FATFileSystem aFileSystem, FATDirectory parent, FOS_System.String aName, UInt32 aFirstCluster)
: base(aFileSystem, parent, aName)
{
_theFile = new FATFile(aFileSystem, parent, Name, 0, aFirstCluster)
{
IsDirectoryFile = true
};
}
public uint GetSymbolAddress(ELFDynamicSymbolTableSection.Symbol theSymbol, FOS_System.String theSymbolName)
{
uint address = 0;
uint size = 0;
GetSymbolAddressAndSize(theSymbol, theSymbolName, ref address, ref size);
return(address);
}
/// <summary>
/// Initialises new partition information using the specified data.
/// </summary>
/// <param name="data">The data to read the partition info from.</param>
/// <param name="offset">The offset in the data at which to start reading.</param>
/// <param name="entrySize">The size of a partition entry.</param>
public PartitionInfo(byte[] data, uint offset, uint entrySize)
{
//There is an underlying assumption here that the
// supplied data is of sufficient length (including the
// extra length required for any specified offset).
//TODO: Check the entry size is valid
//TODO: Throw an exception if data.length + offset < entrySize
//Copy in Type ID data
TypeID[0] = data[offset + 0];
TypeID[1] = data[offset + 1];
TypeID[2] = data[offset + 2];
TypeID[3] = data[offset + 3];
TypeID[4] = data[offset + 4];
TypeID[5] = data[offset + 5];
TypeID[6] = data[offset + 6];
TypeID[7] = data[offset + 7];
TypeID[8] = data[offset + 8];
TypeID[9] = data[offset + 9];
TypeID[10] = data[offset + 10];
TypeID[11] = data[offset + 11];
TypeID[12] = data[offset + 12];
TypeID[13] = data[offset + 13];
TypeID[14] = data[offset + 14];
TypeID[15] = data[offset + 15];
//Copy in the partition ID data
ID[0] = data[offset + 16];
ID[1] = data[offset + 17];
ID[2] = data[offset + 18];
ID[3] = data[offset + 19];
ID[4] = data[offset + 20];
ID[5] = data[offset + 21];
ID[6] = data[offset + 22];
ID[7] = data[offset + 23];
ID[8] = data[offset + 24];
ID[9] = data[offset + 25];
ID[10] = data[offset + 26];
ID[11] = data[offset + 27];
ID[12] = data[offset + 28];
ID[13] = data[offset + 29];
ID[14] = data[offset + 30];
ID[15] = data[offset + 31];
//Parse the other partition data
FirstLBA = ByteConverter.ToUInt32(data, offset + 32);
LastLBA = ByteConverter.ToUInt32(data, offset + 40);
Attributes = ByteConverter.ToUInt32(data, offset + 48);
Name = ByteConverter.GetASCIIStringFromUTF16(data, offset + 56, 36).Trim();
#if GPT_TRACE
BasicConsole.WriteLine(((FOS_System.String) "First LBA : ") + FirstLBA);
BasicConsole.WriteLine(((FOS_System.String) "Last LBA : ") + LastLBA);
BasicConsole.WriteLine(((FOS_System.String) "Attributes : ") + Attributes);
BasicConsole.WriteLine(((FOS_System.String) "Name : ") + Name);
#endif
}
public static void Disable(FOS_System.String caller)
{
//BasicConsole.Write(caller);
//BasicConsole.WriteLine(" disabling GC.");
//BasicConsole.DelayOutput(2);
lastDisabler = caller;
GC.Enabled = false;
}
public static byte[] GetASCIIBytes(FOS_System.String asciiString)
{
byte[] result = new byte[asciiString.length];
for (int i = 0; i < asciiString.length; i++)
{
result[i] = (byte)asciiString[i];
}
return(result);
}
public static void *AllocZeroed(UInt32 size, UInt32 boundary, FOS_System.String caller)
{
void *result = Alloc(size, boundary, caller);
if (result == null)
{
return(null);
}
return(Utilities.MemoryUtils.ZeroMem(result, size));
}
public DateTime(byte[] data, uint offset)
{
Year = ByteConverter.GetASCIIStringFromASCII(data, offset + 0, 4);
Month = ByteConverter.GetASCIIStringFromASCII(data, offset + 4, 2).TrimEnd().PadLeft(2, '0');
Day = ByteConverter.GetASCIIStringFromASCII(data, offset + 6, 2).TrimEnd().PadLeft(2, '0');
Hour = ByteConverter.GetASCIIStringFromASCII(data, offset + 8, 2).TrimEnd().PadLeft(2, '0');
Minute = ByteConverter.GetASCIIStringFromASCII(data, offset + 10, 2).TrimEnd().PadLeft(2, '0');
Second = ByteConverter.GetASCIIStringFromASCII(data, offset + 12, 2).TrimEnd().PadLeft(2, '0');
HundrethsSecond = ByteConverter.GetASCIIStringFromASCII(data, offset + 14, 2);
Timezone = data[offset + 16];
}
/// <summary>
/// Parses a string as an signed decimal integer.
/// </summary>
/// <param name="str">The string to parse.</param>
/// <returns>The parsed int.</returns>
public static int Parse_DecimalSigned(FOS_System.String str)
{
bool neg = str.StartsWith("-");
int result = (int)Parse_DecimalUnsigned(str, (neg ? 1 : 0));
if (neg)
{
result *= -1;
}
return(result);
}
/// <summary>
/// Deletes the specified file within the file system.
/// </summary>
/// <param name="name">The name of the file to delete.</param>
/// <returns>True if the file was found and deleted. Otherwise, false.</returns>
public static bool Delete(FOS_System.String name)
{
File theFile = Open(name);
if (theFile == null)
{
return(false);
}
return(theFile.Delete());
}
public FOS_System.String ToString()
{
FOS_System.String result = "";
for (int i = 0; i < ImplicitHeap.Count; i++)
{
result += ((FOS_System.String)((Comparable)ImplicitHeap[i]).Key).PadRight(20, ' ');
}
return(result);
}
/// <summary>
/// Deletes the specified directory within the file system.
/// </summary>
/// <param name="name">The name of the directory to delete.</param>
/// <returns>True if the directory was found and deleted. Otherwise, false.</returns>
public static bool Delete(FOS_System.String name)
{
Directory theDir = Find(name);
if (theDir == null)
{
return(false);
}
return(theDir.Delete());
}
/// <summary>
/// Determines whether the specified listing exists or not within this directory or its sub-directories.
/// </summary>
/// <param name="name">The full path and name of the listing to check for.</param>
/// <param name="listings">The list of listings to search through.</param>
/// <returns>Whether the listing exists or not.</returns>
public static bool ListingExists(FOS_System.String name, List listings)
{
for (int i = 0; i < listings.Count; i++)
{
if (((Base)listings[i]).Name == name)
{
return(true);
}
}
return(false);
}
public FOS_System.String this[uint offset]
{
get
{
FOS_System.String currString = "";
if (offset < data.Length)
{
currString = ByteConverter.GetASCIIStringFromASCII(data, offset, (uint)(data.Length - offset));
}
return(currString);
}
}
public static unsafe FOS_System.String Concat(FOS_System.String str1, FOS_System.String str2)
{
FOS_System.String newStr = New(str1.length + str2.length);
for (int i = 0; i < str1.length; i++)
{
newStr[i] = str1[i];
}
for (int i = 0; i < str2.length; i++)
{
newStr[i + str1.length] = str2[i];
}
return(newStr);
}
public Process(ThreadStartMethod MainMethod, uint AnId, FOS_System.String AName, bool userMode)
{
#if PROCESS_TRACE
BasicConsole.WriteLine("Constructing process object...");
#endif
Id = AnId;
Name = AName;
UserMode = userMode;
#if PROCESS_TRACE
BasicConsole.WriteLine("Creating thread...");
#endif
CreateThread(MainMethod);
}
public DateTime(byte[] data, uint offset)
{
Year = ByteConverter.GetASCIIStringFromASCII(data, offset + 0, 4);
Month = ByteConverter.GetASCIIStringFromASCII(data, offset + 4, 2).TrimEnd().PadLeft(2, '0');
Day = ByteConverter.GetASCIIStringFromASCII(data, offset + 6, 2).TrimEnd().PadLeft(2, '0');
Hour = ByteConverter.GetASCIIStringFromASCII(data, offset + 8, 2).TrimEnd().PadLeft(2, '0');
Minute = ByteConverter.GetASCIIStringFromASCII(data, offset + 10, 2).TrimEnd().PadLeft(2, '0');
Second = ByteConverter.GetASCIIStringFromASCII(data, offset + 12, 2).TrimEnd().PadLeft(2, '0');
HundrethsSecond = ByteConverter.GetASCIIStringFromASCII(data, offset + 14, 2);
Timezone = data[offset + 16];
}
/// <summary>
/// Creates a new exception with specified message.
/// </summary>
/// <param name="aMessage">The exception message.</param>
public Exception(FOS_System.String aMessage)
: base()
{
Message = aMessage;
}
public Thread(Process AnOwner, ThreadStartMethod StartMethod, uint AnId, bool UserMode, FOS_System.String AName)
{
#if THREAD_TRACE
BasicConsole.WriteLine("Constructing thread object...");
#endif
LastActiveState = ActiveStates.NotStarted;
Owner = AnOwner;
//Init thread state
#if THREAD_TRACE
BasicConsole.WriteLine("Allocating state memory...");
#endif
State = (ThreadState*)FOS_System.Heap.Alloc((uint)sizeof(ThreadState), "Thread : Thread() (1)");
// Init Id and EIP
// Set EIP to the first instruction of the main method
#if THREAD_TRACE
BasicConsole.WriteLine("Setting thread info...");
#endif
Id = AnId;
Name = AName;
State->StartEIP = (uint)Utilities.ObjectUtilities.GetHandle(StartMethod);
// Allocate kernel memory for the kernel stack for this thread
// Used when this thread is preempted or does a sys call. Stack is switched to
// this thread-specific kernel stack
#if THREAD_TRACE
BasicConsole.WriteLine("Allocating kernel stack...");
#endif
// TODO: Allocate using virt mem manager not the heap (see ThreadStackTop below)
State->KernelStackTop = (byte*)FOS_System.Heap.Alloc(0x1000, 4) + 0xFFC; //4KiB, 4-byte aligned
// Allocate free memory for the user stack for this thread
// Used by this thread in normal execution
#if THREAD_TRACE
BasicConsole.WriteLine("Mapping thread stack page...");
#endif
State->UserMode = UserMode;
State->ThreadStackTop = (byte*)Hardware.VirtMemManager.MapFreePage(
UserMode ? Hardware.VirtMem.VirtMemImpl.PageFlags.None :
Hardware.VirtMem.VirtMemImpl.PageFlags.KernelOnly) + 4092; //4 KiB, page-aligned
// Set ESP to the top of the stack - 4 byte aligned, high address since x86 stack works
// downwards
#if THREAD_TRACE
BasicConsole.WriteLine("Setting ESP...");
#endif
State->ESP = (uint)State->ThreadStackTop;
// TimeToRun and TimeToRunReload are set up in Scheduler.InitProcess which
// is called when a process is registered.
// Init SS
// Stack Segment = User or Kernel space data segment selector offset
// Kernel data segment selector offset (offset in GDT) = 0x10 (16)
// User data segment selector offset (offset in GDT) = 0x23 (32|3)
// User data segment selector must also be or'ed with 3 for User Privilege level
#if THREAD_TRACE
BasicConsole.WriteLine("Setting SS...");
#endif
State->SS = UserMode ? (ushort)0x23 : (ushort)0x10;
// Init Started
// Not started yet so set to false
#if THREAD_TRACE
BasicConsole.WriteLine("Setting started...");
#endif
State->Started = false;
#if THREAD_TRACE
BasicConsole.WriteLine("Allocating exception state...");
#endif
//TODO: This is currently incorrectly allocated from the current process's heap instead of the heap of the owner process
// Init Exception State
State->ExState = (ExceptionState*)FOS_System.Heap.AllocZeroed((uint)sizeof(ExceptionState), "Thread : Thread() (2)");
#if THREAD_TRACE
BasicConsole.WriteLine("Done.");
#endif
}
/// <summary>
/// See base class.
/// </summary>
public override void Execute()
{
try
{
Hardware.DeviceManager.AddDeviceAddedListener(MainShell.DeviceManager_DeviceAdded, this);
try
{
// Auto-init all to save us writing the command
//InitPCI();
}
catch
{
console.WriteLine();
console.WarningColour();
console.WriteLine("Error initialising PCI subsystem:");
OutputExceptionInfo(ExceptionMethods.CurrentException);
}
try
{
// Auto-init all to save us writing the command
//InitATA();
}
catch
{
console.WriteLine();
console.WarningColour();
console.WriteLine("Error initialising ATA subsystem:");
OutputExceptionInfo(ExceptionMethods.CurrentException);
}
#if PERIODIC_REBOOT
// 60 seconds
Hardware.Timers.PIT.Default.RegisterHandler(TriggerPeriodicReboot, 60000000000L, true, this);
#endif
//Endlessly wait for commands until we hit a total failure condition
// or the user instructs us to halt
while (!terminating)
{
try
{
//Output the current command line
console.Write(CurrentDir + " > ");
//List of supported commands
/* Command { Req Arg } [Opt Arg] *Default val*:
* - Halt
* - ExInfo
* - Init { ALL / PCI / ATA / USB / FS }
* - Output { PCI / ATA / USB / FS / Memory }
* - CheckDisk/ChkD { Drive# }
* - FormatDisk/FmtD { Drive# }
* - Dir { List / Open / New / Delete / Copy }
* - File { Open/Delete/Copy }
* - Test { Interrupts / Delegates / FileSystems /
* ULLTComp / StringConcat/ ObjArray /
* IntArray / DummyObj / DivideBy0 /
* Exceptions1 / Exceptions2 / PCBeep /
* Timer / Keyboard / FieldsTable /
* IsInst / VirtMem / Longs /
* ThreadSleep / Heap / GC /
* ATA / USB }
* - GC { Cleanup }
* - USB { Update / Eject }
* - Start { Filename } [*KM* / UM] [*Raw* / ELF]
* - ILY
* - Show { c / w }
* - Help { <Command Name> }
* - Clear
* - Easter
* - Reboot
*/
//Get the current input line from the user
FOS_System.String line = ReadLine();
//Split the input into command, arguments and options
// All parts are in lower case
List cmdParts = SplitCommand(line);
//Check the user didn't just press enter without any text
if (cmdParts.Count > 0)
{
//Get the command to run - first part of the command
FOS_System.String cmd = (FOS_System.String)cmdParts[0];
//Determine which command we are to run
if (cmd == "halt")
{
//Cleanup devices
console.WriteLine("Ejecting MSDs...");
CleanDiskCaches();
console.WriteLine("Ejected.");
console.WriteLine("Closing...");
//Halt execution of the current shell
terminating = true;
}
else if (cmd == "exinfo")
{
//Output information about the current exception, if any.
// TODO - This should be changed to Last exception.
// Because of the try-catch block inside the loop, there
// will never be a current exception to output.
OutputExceptionInfo(ExceptionMethods.CurrentException);
}
else if (cmd == "init")
{
//Initialise the specified sub-system.
#region Init
//The user may have forgotten to input an option. Assume they
// haven't, then fill in if they have.
FOS_System.String opt1 = null;
//We don't know how many extra options there might be, so we test
// for greater-than instead of equal to. It should be noted that >
// is more efficient than >=. Also, the command is in the cmdParts
// not just the options.
//So, we want the 1st option, which is the 2nd command part. This
// means we need > 1 command part and index 1 in the command parts
// list.
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
//If the user gave us an option
if (opt1 != null)
{
//Determine which option that was
if (opt1 == "all")
{
//Initialise all sub-systems in order
InitATA();
InitPCI();
InitUSB();
InitFS();
}
else if (opt1 == "pci")
{
//Initialise the PCI sub-system
InitPCI();
}
else if (opt1 == "ata")
{
//Initialise the ATA sub-system
InitATA();
}
else if (opt1 == "usb")
{
//Initialise the USB sub-system
// This is dependent upon the PCI sub-system
// but we assume the user was intelligent
// enough to have already initialised PCI.
// (Probably a bad assumption really... ;p )
InitUSB();
}
else if (opt1 == "fs")
{
//Initialise the file (sub-)system
// This is dependent upon the USB or ATA
// sub-system but we assume the user was intelligent
// enough to have already initialised these.
// (Probably a bad assumption really... ;p )
InitFS();
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to init. { PCI/ATA/USB/FS }");
}
#endregion
}
else if (cmd == "output")
{
//For details on how the code here works, see Init
#region Output
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "pci")
{
OutputPCI();
}
else if (opt1 == "ata")
{
OutputATA();
}
else if (opt1 == "usb")
{
OutputUSB();
}
else if (opt1 == "fs")
{
OutputFS();
}
else if (opt1 == "memory" || opt1 == "mem")
{
OutputMemory();
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to output. { PCI/ATA/USB/FS }");
}
#endregion
}
else if (cmd == "checkdisk" || cmd == "chkd")
{
//For details on how the code here works, see Init
#region Check Disk
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
int diskNum = (int)FOS_System.Int32.Parse_DecimalUnsigned(opt1, 0);
if (Hardware.DeviceManager.Devices[diskNum] is Hardware.Devices.DiskDevice)
{
console.Write("Checking disk ");
console.Write_AsDecimal(diskNum);
console.WriteLine("...");
CheckDiskFormatting((Hardware.Devices.DiskDevice)Hardware.DeviceManager.Devices[diskNum]);
}
else
{
console.WriteLine("Cancelled - Specified device is not a disk device.");
}
}
else
{
console.WriteLine("You must specify which disk to check.");
}
#endregion
}
else if (cmd == "formatdisk" || cmd == "fmtd")
{
//For details on how the code here works, see Init
#region Format Disk
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
int diskNum = (int)FOS_System.Int32.Parse_DecimalUnsigned(opt1, 0);
if (Hardware.DeviceManager.Devices[diskNum] is Hardware.Devices.DiskDevice)
{
console.Write("Are you sure you wish to continue? (Y/N) : ");
FOS_System.String str = ReadLine().ToLower();
if (str == "y")
{
console.Write("Formatting disk ");
console.Write_AsDecimal(diskNum);
console.WriteLine("...");
FormatDisk((Hardware.Devices.DiskDevice)Hardware.DeviceManager.Devices[diskNum]);
}
else
{
console.WriteLine("Cancelled.");
}
}
else
{
console.WriteLine("Cancelled - Specified device is not a disk device.");
}
}
else
{
console.WriteLine("You must specify which disk to check.");
}
#endregion
}
else if (cmd == "gc")
{
//For details on how the code here works, see Init
#region GC
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "cleanup")
{
FOS_System.GC.Cleanup();
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to do. { Cleanup }");
}
#endregion
}
else if (cmd == "usb")
{
//For details on how the code here works, see Init
#region USB
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "update")
{
Hardware.USB.USBManager.Update();
}
else if (opt1 == "eject")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2 == "msd")
{
FOS_System.String opt3 = null;
if (cmdParts.Count > 3)
{
opt3 = (FOS_System.String)cmdParts[3];
}
if (opt3 != null)
{
EjectMSD(FOS_System.Int32.Parse_DecimalSigned(opt3));
}
else
{
console.WriteLine("You must specify a device number!");
}
}
else
{
console.WriteLine("Unrecognised device type!");
}
}
else
{
console.WriteLine("You must specify a device type! (msd)");
}
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to do. { Update }");
}
#endregion
}
else if (cmd == "dir")
{
//For details on how the code here works, see Init
//Note: "./" prefix on a dir/file path means current
// directory so it must be replaced by the
// current directory.
#region Dir
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "list")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
console.WriteLine("Listing dir: " + opt2);
OutputDirectoryContents(opt2);
}
else
{
console.WriteLine("You must specify a directory path.");
}
}
else if (opt1 == "open")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
Directory aDir = Directory.Find(opt2);
if (aDir != null)
{
CurrentDir = aDir.GetFullPath();
}
else
{
console.WriteLine("Directory not found!");
}
}
else
{
console.WriteLine("You must specify a directory path.");
}
}
else if (opt1 == "new")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
console.WriteLine("Creating dir: " + opt2);
NewDirectory(opt2);
}
else
{
console.WriteLine("You must specify a directory path.");
}
}
else if (opt1 == "delete")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
console.WriteLine("Deleting dir: " + opt2);
DeleteDirectory(opt2);
}
else
{
console.WriteLine("You must specify a directory path.");
}
}
else if (opt1 == "copy")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
FOS_System.String opt3 = null;
if (cmdParts.Count > 3)
{
opt3 = (FOS_System.String)cmdParts[3];
}
if (opt3 != null)
{
if (opt3.StartsWith("./"))
{
opt3 = CurrentDir + opt3.Substring(2, opt3.length - 2);
}
console.WriteLine("Copy cmd, opt2=\"" + opt2 + "\", opt3=\"" + opt3 + "\"");
CopyDirectory(opt2, opt3);
}
else
{
console.WriteLine("You must specify a destination path.");
}
}
else
{
console.WriteLine("You must specify a source path.");
}
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to do. { List/Open/New/Delete/Copy }");
}
#endregion
}
else if (cmd == "file")
{
//For details on how the code here works, see Init
//Note: "./" prefix on a dir/file path means current
// directory so it must be replaced by the
// current directory.
#region File
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "open")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
OutputFileContents(opt2);
}
else
{
console.WriteLine("You must specify a file path.");
}
}
else if (opt1 == "delete")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
DeleteFile(opt2);
}
else
{
console.WriteLine("You must specify a file path.");
}
}
else if (opt1 == "copy")
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2.StartsWith("./"))
{
opt2 = CurrentDir + opt2.Substring(2, opt2.length - 2);
}
FOS_System.String opt3 = null;
if (cmdParts.Count > 3)
{
opt3 = (FOS_System.String)cmdParts[3];
}
if (opt3 != null)
{
if (opt3.StartsWith("./"))
{
opt3 = CurrentDir + opt3.Substring(2, opt3.length - 2);
}
console.WriteLine("Copy cmd, opt2=\"" + opt2 + "\", opt3=\"" + opt3 + "\"");
CopyFile(opt2, opt3);
}
else
{
console.WriteLine("You must specify a destination path.");
}
}
else
{
console.WriteLine("You must specify a source path.");
}
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify what to do. { Open/Delete/Copy }");
}
#endregion
}
else if (cmd == "test")
{
//For details on how the code here works, see Init
#region Test
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1 == "interrupts")
{
InterruptsTest();
}
else if (opt1 == "delegates")
{
DelegateTest();
}
else if (opt1 == "filesystems")
{
FileSystemTests();
}
else if (opt1 == "ulltcomp")
{
ULongLTComparisonTest();
}
else if (opt1 == "stringconcat")
{
StringConcatTest();
}
else if (opt1 == "objarray")
{
ObjectArrayTest();
}
else if (opt1 == "intarray")
{
IntArrayTest();
}
else if (opt1 == "dummyobj")
{
DummyObjectTest();
}
else if (opt1 == "divideby0")
{
DivideByZeroTest();
}
else if (opt1 == "exceptions1")
{
ExceptionsTestP1();
}
else if (opt1 == "exceptions2")
{
ExceptionsTestP2();
}
else if (opt1 == "pcbeep")
{
PCBeepTest();
}
else if (opt1 == "timer")
{
TimerTest();
}
else if (opt1 == "keyboard")
{
KeyboardTest();
}
else if (opt1 == "fieldstable")
{
FieldsTableTest();
}
else if (opt1 == "isinst")
{
IsInstTest();
}
else if (opt1 == "virtmem")
{
Hardware.VirtMemManager.Test();
}
else if (opt1 == "longs")
{
LongsTest();
}
else if (opt1 == "threadsleep")
{
ThreadSleepTest();
}
else if (opt1 == "heap")
{
HeapTest();
}
else if (opt1 == "gc")
{
GCTest();
}
else if (opt1 == "ata")
{
ATATest();
}
else if (opt1 == "usb")
{
USBTest();
}
else
{
UnrecognisedOption(opt1);
}
}
else
{
console.WriteLine("You must specify which test. { Interrupts / Delegates / FileSystems /\n" +
" ULLTComp / StringConcat / ObjArray /\n" +
" IntArray / DummyObj / DivideBy0 /\n" +
" Exceptions1 / Exceptions2 / PCBeep /\n" +
" Timer / Keyboard / FieldsTable /\n" +
" IsInst / VirtMem }");
}
#endregion
}
else if (cmd == "start")
{
//For details on how the code here works, see Init
#region Start
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
if (opt1 != null)
{
if (opt1.StartsWith("./"))
{
opt1 = CurrentDir + opt1.Substring(2, opt1.length - 2);
}
File aFile = File.Open(opt1);
if (aFile != null)
{
FOS_System.String opt2 = null;
if (cmdParts.Count > 2)
{
opt2 = (FOS_System.String)cmdParts[2];
}
if (opt2 != null)
{
if (opt2 == "km")
{
FOS_System.String opt3 = null;
if (cmdParts.Count > 3)
{
opt3 = (FOS_System.String)cmdParts[3];
}
if (opt3 != null)
{
if (opt3 == "raw")
{
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromRawExe(aFile, false),
Hardware.Processes.Scheduler.Priority.Normal);
}
else if (opt3 == "elf")
{
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromELFExe(aFile, false).TheProcess,
Hardware.Processes.Scheduler.Priority.Normal);
}
else
{
UnrecognisedOption(opt3);
}
}
else
{
//Run as RAW for now
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromRawExe(aFile, false),
Hardware.Processes.Scheduler.Priority.Normal);
}
}
else if (opt2 == "um")
{
FOS_System.String opt3 = null;
if (cmdParts.Count > 3)
{
opt3 = (FOS_System.String)cmdParts[3];
}
if (opt3 != null)
{
if (opt3 == "raw")
{
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromRawExe(aFile, true),
Hardware.Processes.Scheduler.Priority.Normal);
}
else if (opt3 == "elf")
{
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromELFExe(aFile, true).TheProcess,
Hardware.Processes.Scheduler.Priority.Normal);
}
else
{
UnrecognisedOption(opt3);
}
}
else
{
//Run as RAW for now
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromRawExe(aFile, true),
Hardware.Processes.Scheduler.Priority.Normal);
}
}
else
{
UnrecognisedOption(opt2);
}
}
else
{
//Run as KM, ELF for now
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromELFExe(aFile, false).TheProcess,
Hardware.Processes.Scheduler.Priority.Normal);
}
}
else
{
console.WriteLine("File not found.");
}
}
else
{
console.WriteLine("You must specify the file path.");
}
#endregion
}
else if (cmd == "ily")
{
#region ILY
Hardware.Processes.ProcessManager.RegisterProcess(
Processes.DynamicLinkerLoader.LoadProcess_FromRawExe(
File.Open("a:/ily.bin"), false),
Hardware.Processes.Scheduler.Priority.Normal);
#endregion
}
else if (cmd == "show")
{
#region Show
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
ShowLicense(opt1);
#endregion
}
else if (cmd == "help")
{
#region Help
FOS_System.String opt1 = null;
if (cmdParts.Count > 1)
{
opt1 = (FOS_System.String)cmdParts[1];
}
ShowHelp(opt1);
#endregion
}
else if (cmd == "clear")
{
#region Clear
console.Clear();
#endregion
}
else if (cmd == "easter")
{
#region Easter
Hardware.Processes.ProcessManager.CurrentProcess.CreateThread(Tasks.EasterTask.Main, "Easter");
#endregion
}
else if (cmd == "reboot")
{
#region Reboot
Reboot();
#endregion
}
}
}
catch
{
OutputExceptionInfo(ExceptionMethods.CurrentException);
}
}
}
catch
{
OutputExceptionInfo(ExceptionMethods.CurrentException);
//Pause to give us the chance to read the output.
// We do not know what the code outside this shell may do.
Processes.SystemCalls.SleepThread(1000);
}
console.WriteLine("Shell exited.");
}
/// <summary>
/// Initialises new partition information using the specified data.
/// </summary>
/// <param name="data">The data to read the partition info from.</param>
/// <param name="offset">The offset in the data at which to start reading.</param>
/// <param name="entrySize">The size of a partition entry.</param>
public PartitionInfo(byte[] data, uint offset, uint entrySize)
{
//There is an underlying assumption here that the
// supplied data is of sufficient length (including the
// extra length required for any specified offset).
//TODO: Check the entry size is valid
//TODO: Throw an exception if data.length + offset < entrySize
//Copy in Type ID data
TypeID[0] = data[offset + 0];
TypeID[1] = data[offset + 1];
TypeID[2] = data[offset + 2];
TypeID[3] = data[offset + 3];
TypeID[4] = data[offset + 4];
TypeID[5] = data[offset + 5];
TypeID[6] = data[offset + 6];
TypeID[7] = data[offset + 7];
TypeID[8] = data[offset + 8];
TypeID[9] = data[offset + 9];
TypeID[10] = data[offset + 10];
TypeID[11] = data[offset + 11];
TypeID[12] = data[offset + 12];
TypeID[13] = data[offset + 13];
TypeID[14] = data[offset + 14];
TypeID[15] = data[offset + 15];
//Copy in the partition ID data
ID[0] = data[offset + 16];
ID[1] = data[offset + 17];
ID[2] = data[offset + 18];
ID[3] = data[offset + 19];
ID[4] = data[offset + 20];
ID[5] = data[offset + 21];
ID[6] = data[offset + 22];
ID[7] = data[offset + 23];
ID[8] = data[offset + 24];
ID[9] = data[offset + 25];
ID[10] = data[offset + 26];
ID[11] = data[offset + 27];
ID[12] = data[offset + 28];
ID[13] = data[offset + 29];
ID[14] = data[offset + 30];
ID[15] = data[offset + 31];
//Parse the other partition data
FirstLBA = ByteConverter.ToUInt32(data, offset + 32);
LastLBA = ByteConverter.ToUInt32(data, offset + 40);
Attributes = ByteConverter.ToUInt32(data, offset + 48);
Name = ByteConverter.GetASCIIStringFromUTF16(data, offset + 56, 36).Trim();
#if GPT_TRACE
BasicConsole.WriteLine(((FOS_System.String)"First LBA : ") + FirstLBA);
BasicConsole.WriteLine(((FOS_System.String)"Last LBA : ") + LastLBA);
BasicConsole.WriteLine(((FOS_System.String)"Attributes : ") + Attributes);
BasicConsole.WriteLine(((FOS_System.String)"Name : ") + Name);
#endif
}
public BootRecord(Hardware.Devices.DiskDevice disk, uint startBlock, uint numBlocks, byte[] data)
: base(disk, startBlock, numBlocks, data)
{
BootSystemIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 7, 32);
BootSystem = ByteConverter.GetASCIIStringFromASCII(data, 39, 32);
}
public PrimaryVolumeDescriptor(Hardware.Devices.DiskDevice disk, uint startBlock, uint numBlocks, byte[] data)
: base(disk, startBlock, numBlocks, data)
{
SystemIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 8, 32);
VolumeIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 40, 32);
VolumeSpaceSize = ByteConverter.ToUInt32(data, 80);
VolumeSetSize = ByteConverter.ToUInt16(data, 120);
VolumeSequenceNumber = ByteConverter.ToUInt16(data, 124);
LogicalBlockSize = ByteConverter.ToUInt16(data, 128);
PathTableSize = ByteConverter.ToUInt32(data, 132);
Location_PathTable_TypeL = ByteConverter.ToUInt32(data, 140);
Location_PathTable_Optional_TypeL = ByteConverter.ToUInt32(data, 144);
RootDirectory = new DirectoryRecord(data, 156, true);
VolumeSetIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 190, 128);
PublisherIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 318, 128);
DataPreparerIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 446, 128);
ApplicationIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 574, 128);
CopyrightFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 702, 38);
AbstractFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 740, 36);
BibliographicFileIdentifier = ByteConverter.GetASCIIStringFromASCII(data, 776, 37);
VolumeCreationDateTime = new DateTime(data, 813);
VolumeModificationDateTime = new DateTime(data, 830);
VolumeExpirationDateTime = new DateTime(data, 847);
VolumeEffectiveDateTime = new DateTime(data, 864);
FileStructureVersion = data[881];
}
/// <summary>
/// Initializes a new file system mapping.
/// </summary>
/// <param name="aPrefix">The prefix to map.</param>
/// <param name="aFileSystem">The file system to map.</param>
public FileSystemMapping(FOS_System.String aPrefix, FileSystem aFileSystem)
{
prefix = aPrefix;
theFileSystem = aFileSystem;
}
/// <summary>
/// Attempts to initialise the ATA drive.
/// </summary>
protected void InitDrive()
{
// At this point, DiscoverDrive has been called, but the additional identification data
// has not been read
// If it's a PATAPI drive, we need to send the IDENTIFY_PACKET command
if (mDriveType == SpecLevel.PATAPI)
{
Reset();
SendCmd(Cmd.IdentifyPacket);
}
// Read Identification Space of the Device
var deviceInfoBuffer = new UInt16[256];
IO.Data.Read_UInt16s(deviceInfoBuffer);
mSerialNo = GetString(deviceInfoBuffer, 10, 20).Trim();
mFirmwareRev = GetString(deviceInfoBuffer, 23, 8).Trim();
mModelNo = GetString(deviceInfoBuffer, 27, 40).Trim();
// Hitachi hardrives found in real-world hardware failed in that:
// They only work with one-sector writes at a time
// This may be due to the fact that I'm working with old laptops and a sample size of one
// Hitachi drive. Newer drives may work properly. All drives will work with a max size of
// one though.
//
// Fujitsu drives suffer a similar fault.
if (mModelNo.StartsWith("Hitachi") || mModelNo.StartsWith("FUJITSU"))
{
maxWritePioBlocks = 1;
}
//Words (61:60) shall contain the value one greater than the total number of user-addressable
//sectors in 28-bit addressing and shall not exceed 0x0FFFFFFF.
// We need 28 bit addressing - small drives on VMWare and possibly other cases are 28 bit
blockCount = ((UInt32)deviceInfoBuffer[61] << 16 | deviceInfoBuffer[60]) - 1;
//Words (103:100) shall contain the value one greater than the total number of user-addressable
//sectors in 48-bit addressing and shall not exceed 0x0000FFFFFFFFFFFF.
//The contents of words (61:60) and (103:100) shall not be used to determine if 48-bit addressing is
//supported. IDENTIFY DEVICE bit 10 word 83 indicates support for 48-bit addressing.
bool xLba48Capable = (deviceInfoBuffer[83] & 0x400) != 0;
if (xLba48Capable)
{
blockCount = ((UInt64)deviceInfoBuffer[103] << 48 | (UInt64)deviceInfoBuffer[102] << 32 | (UInt64)deviceInfoBuffer[101] << 16 | (UInt64)deviceInfoBuffer[100]) - 1;
mLBA48Mode = true;
}
}
public DirectoryRecord(byte[] data, uint offset, bool isRootDirectory = false)
{
IsRootDirectory = isRootDirectory;
RecordLength = data[offset + 0];
ExtAttrRecordLength = data[offset + 1];
LBALocation = ByteConverter.ToUInt32(data, offset + 2);
DataLength = ByteConverter.ToUInt32(data, offset + 10);
RecordingDateTime = new DateTime(data, offset + 18);
TheFileFlags = (FileFlags)data[offset + 25];
FileUnitSize = data[offset + 26];
FileInterleaveGapSize = data[offset + 27];
VolumeSequenceNumber = ByteConverter.ToUInt16(data, offset + 28);
FileIdentifierLength = data[offset + 32];
FileIdentifier = IsRootDirectory ? "ROOT_DIRECTORY" : ByteConverter.GetASCIIStringFromASCII(data, offset + 33, FileIdentifierLength);
}
public static void Disable(FOS_System.String caller)
{
//BasicConsole.Write(caller);
//BasicConsole.WriteLine(" disabling GC.");
//BasicConsole.DelayOutput(2);
lastDisabler = caller;
GC.Enabled = false;
}
