/// <summary>
/// Waits for a pipe to connect to the outpoint.
/// </summary>
/// <returns>The Id of the newly connected pipe.</returns>
public int WaitForConnect()
{
int aPipeId;
SystemCallResults SysCallResult = SystemCalls.WaitOnPipeCreate(Class, Subclass, out aPipeId);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicOutPipe > WaitOnPipeCreate: Unhandled!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Wait On Pipe Create unhandled!"));
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicOutPipe > WaitOnPipeCreate: Failed!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Wait On Pipe Create failed!"));
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicOutPipe > WaitOnPipeCreate: Succeeded.");
//BasicConsole.Write("BasicOutPipe > New pipe id: ");
//BasicConsole.WriteLine(aPipeId);
break;
default:
//BasicConsole.WriteLine("BasicOutPipe > WaitOnPipeCreate: Unexpected system call result!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Wait On Pipe Create unexpected result!"));
break;
}
return(aPipeId);
}
/// <summary>
/// Gets the number of available outpoints of the specified class and subclass.
/// </summary>
/// <param name="numOutpoints">Out : The number of outpoints (correct iff SysCallResult is OK).</param>
/// <param name="SysCallResult">Out : The result of the system call. Check this is set to OK.</param>
/// <param name="Class">The class of pipe to search for.</param>
/// <param name="Subclass">The subclass of pipe to search for.</param>
public static void GetNumPipeOutpoints(out int numOutpoints, out SystemCallResults SysCallResult, Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass)
{
SysCallResult = SystemCalls.GetNumPipeOutpoints(Class, Subclass, out numOutpoints);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Unhandled!");
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Failed!");
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Succeeded.");
//BasicConsole.Write("BasicServerHelpers > Num pipe outpoints: ");
//BasicConsole.WriteLine(numOutpoints);
break;
default:
//BasicConsole.WriteLine("BasicServerHelpers > GetNumPipeOutpoints: Unexpected system call result!");
break;
}
}
/// <summary>
/// Reads up to the specified length of data into the specified buffer at the specified offset in the buffer.
/// </summary>
/// <param name="Data">The buffer to read into.</param>
/// <param name="Offset">The offset in the buffer to write data to.</param>
/// <param name="Length">The maximum length of data to read.</param>
/// <param name="Blocking">Whether the read should be blocking or non-blocking.</param>
/// <returns>The actual number of bytes read.</returns>
public int Read(byte[] Data, int Offset, int Length, bool Blocking)
{
int BytesRead = 0;
Pipes.ReadPipeRequest *ReadPipeRequestPtr = (Pipes.ReadPipeRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.ReadPipeRequest), "BasicInPipe : Alloc ReadPipeRequest");
try
{
if (ReadPipeRequestPtr != null)
{
ReadPipeRequestPtr->PipeId = PipeId;
ReadPipeRequestPtr->Offset = Offset;
ReadPipeRequestPtr->Length = FOS_System.Math.Min(Data.Length - Offset, Length);
ReadPipeRequestPtr->OutBuffer = (byte *)Utilities.ObjectUtilities.GetHandle(Data) + FOS_System.Array.FieldsBytesSize;
ReadPipeRequestPtr->Blocking = Blocking;
SystemCallResults SysCallResult = SystemCalls.ReadPipe(ReadPipeRequestPtr, out BytesRead);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Unhandled!");
ExceptionMethods.Throw(new Exceptions.RWUnhandledException("BasicInPipe : Read Pipe unexpected unhandled!"));
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Failed!");
if (Blocking)
{
ExceptionMethods.Throw(new Exceptions.RWFailedException("BasicInPipe : Write Pipe unexpected failed! (Blocking call)"));
}
else
{
ExceptionMethods.Throw(new Exceptions.RWFailedException("BasicInPipe : Write Pipe failed. (Non-blocking call)"));
}
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Succeeded.");
break;
default:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Unexpected system call result!");
ExceptionMethods.Throw(new Exceptions.RWUnhandledException("BasicInPipe : Read Pipe unexpected result!"));
break;
}
}
else
{
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicInPipe : Couldn't allocate memory to read from pipe!"));
}
}
finally
{
if (ReadPipeRequestPtr != null)
{
Heap.Free(ReadPipeRequestPtr);
}
}
return(BytesRead);
}
public static int SyscallHandler(uint syscallNumber, uint param1, uint param2, uint param3,
ref uint Return2, ref uint Return3, ref uint Return4,
uint callerProcessId, uint callerThreadId)
{
SystemCallResults result = SystemCalls.HandleSystemCallForKernel(syscallNumber,
param1, param2, param3,
ref Return2, ref Return3, ref Return4,
callerProcessId, callerThreadId);
if (result == SystemCallResults.Deferred || result == SystemCallResults.Deferred_PermitActions)
{
//BasicConsole.WriteLine("Deferring syscall...");
//BasicConsole.WriteLine("Popping unqueued info object...");
DeferredSyscallInfo info = (DeferredSyscallInfo)DeferredSyscallsInfo_Unqueued.Pop();
//BasicConsole.WriteLine("Setting info...");
info.ProcessId = callerProcessId;
info.ThreadId = callerThreadId;
//BasicConsole.WriteLine("Queuing info object...");
DeferredSyscallsInfo_Queued.Push(info);
//BasicConsole.WriteLine("Waking deferred syscalls thread...");
DeferredSyscallsThread._Wake();
}
return((int)result);
}
/// <summary>
/// System ring init method - ran once at boot
/// </summary>
public static void Init()
{
HW.Init();
//Thread.Sleep(500);
Console.WriteLine("FileSystem service...");
FSService.Init();
Console.WriteLine("Filesystem: " + FSService.Active);
if (FSService.Active == true)
{
for (int i = 1; i < SystemFunctions.IDEs.Length; i++)
{
new DiskListing(i, SystemFunctions.IDEs[i]);
}
InstallService.Init();
}
SystemCalls MEFAPI = new SystemCalls();
for (int i = 0; i < Kernel.Drivers.Count; i++)
{
if (Kernel.Drivers[i].Init())
{
Console.WriteLine(Kernel.Drivers[i].Name + "' loaded sucessfully");
}
else
{
Console.WriteLine("Failure loading module '" + Kernel.Drivers[i].Name + "'");
Console.ReadKey();
}
}
}
/// <summary>
/// Creates and registers a new outpoint of the specified class and subclass.
/// </summary>
/// <param name="aClass">The class of pipe allowed to connect to the outpoint.</param>
/// <param name="aSubclass">The subclass of pipe allowed to connect to the outpoint.</param>
/// <param name="MaxConnections">
/// The maximum number of connections allowed. Use <see cref="PipeConstants.UnlimitedConnections"/> for unlimited connections.
/// </param>
public BasicOutpoint(PipeClasses aClass, PipeSubclasses aSubclass, int MaxConnections)
{
Class = aClass;
Subclass = aSubclass;
SystemCallResults SysCallResult = SystemCalls.RegisterPipeOutpoint(Class, Subclass, MaxConnections);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicOutPipe > RegisterPipeOutpoint: Unhandled!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Register Pipe Outpoint system call unhandled!"));
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicOutPipe > RegisterPipeOutpoint: Failed!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Register Pipe Outpoint system call failed!"));
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicOutPipe > RegisterPipeOutpoint: Succeeded.");
break;
default:
//BasicConsole.WriteLine("BasicOutPipe > RegisterPipeOutpoint: Unexpected system call result!");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicOutPipe : Register Pipe Outpoint system call unexpected result!"));
break;
}
}
public static CastMessage ReceiverStatusMessage(int requestId)
{
var receiverStatusMessage = new MessageReceiverStatus
{
type = "RECEIVER_STATUS",
requestId = requestId,
status = new ReceiverStatus
{
volume = new Volume
{
controlType = "master",
level = SystemCalls.GetVolume(),
muted = SystemCalls.IsMuted(),
stepInterval = .01f
},
applications = new List <Application> {
new Application {
appId = "CC1AD845",
sessionId = Guid.NewGuid().ToString(),
transportId = Guid.NewGuid().ToString()
}
}
}
};
return(GetCastMessage(receiverStatusMessage, namespaceMedia));
}
//private static Pipes.Standard.StandardInpoint StdIn;
public static void Main()
{
BasicConsole.WriteLine("Device Manager started.");
Hardware.Processes.ProcessManager.CurrentProcess.InitHeap();
SystemCallResults SysCallResult = SystemCalls.StartThread(GCCleanupTask.Main, out GCThreadId);
if (SysCallResult != SystemCallResults.OK)
{
BasicConsole.WriteLine("Device Manager: GC thread failed to create!");
}
try
{
StdOut = new Pipes.Standard.StandardOutpoint(true);
int StdOutPipeId = StdOut.WaitForConnect();
//int numOutpoints;
//Pipes.BasicOutpoint.GetNumPipeOutpoints(out numOutpoints, out SysCallResult, Pipes.PipeClasses.Standard, Pipes.PipeSubclasses.Standard_In);
//if (SysCallResult == SystemCallResults.OK && numOutpoints > 0)
//{
// Pipes.PipeOutpointDescriptor[] OutpointDescriptors;
// Pipes.BasicOutpoint.GetOutpointDescriptors(numOutpoints, out SysCallResult, out OutpointDescriptors, Pipes.PipeClasses.Standard, Pipes.PipeSubclasses.Standard_In);
//
// if (SysCallResult == SystemCallResults.OK)
// {
// for (int i = 0; i < OutpointDescriptors.Length; i++)
// {
// Pipes.PipeOutpointDescriptor Descriptor = OutpointDescriptors[i];
// //TODO: Filter to target
// StdIn = new Pipes.Standard.StandardInpoint(Descriptor.ProcessId, false);
// }
// }
//}
uint loops = 0;
while (!Terminating)
{
try
{
//StdOut.Write(StdOutPipeId, "Hello, world! (" + (FOS_System.String)loops++ + ")\n", true);
SystemCalls.SleepThread(-1);
}
catch
{
BasicConsole.WriteLine("DM > Error writing to StdOut!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
SystemCalls.SleepThread(1000);
}
}
catch
{
BasicConsole.WriteLine("DM > Error initialising!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
public static int HandleISR(uint ISRNum)
{
if (ISRNum == 48)
{
SystemCalls.InterruptHandler();
return(0);
}
return(-1);
}
public static int RingBuzzer(int param1, int param2)
{
try
{
return(SystemCalls.System_Call_3(392, 0x1004, param1, param2));
}
catch
{
return(-1);
}
}
public static void DeferredSyscallsThread_Main()
{
while (!Terminating)
{
if (DeferredSyscallsInfo_Queued.Count == 0)
{
SystemCalls.SleepThread(SystemCalls.IndefiniteSleepThread);
}
while (DeferredSyscallsInfo_Queued.Count > 0)
{
// Scheduler must be disabled during pop/push from circular buffer or we can
// end up in an infinite lock. Consider what happens if a process invokes
// a deferred system call during the pop/push here and at the end of this loop.
//BasicConsole.WriteLine("DSC: Pausing scheduler...");
Scheduler.Disable(/*"DSC 1"*/);
//BasicConsole.WriteLine("DSC: Popping queued info object...");
DeferredSyscallInfo info = (DeferredSyscallInfo)DeferredSyscallsInfo_Queued.Pop();
//BasicConsole.WriteLine("DSC: Resuming scheduler...");
Scheduler.Enable();
//BasicConsole.WriteLine("DSC: Getting process & thread...");
Process CallerProcess = ProcessManager.GetProcessById(info.ProcessId);
Thread CallerThread = ProcessManager.GetThreadById(info.ThreadId, CallerProcess);
//BasicConsole.WriteLine("DSC: Getting data & calling...");
uint Return2 = CallerThread.Return2;
uint Return3 = CallerThread.Return3;
uint Return4 = CallerThread.Return4;
SystemCallResults result = HandleDeferredSystemCall(
CallerProcess, CallerThread,
(SystemCallNumbers)CallerThread.SysCallNumber, CallerThread.Param1, CallerThread.Param2, CallerThread.Param3,
ref Return2, ref Return3, ref Return4);
//BasicConsole.WriteLine("DSC: Ending call...");
if (result != SystemCallResults.Deferred)
{
EndDeferredSystemCall(CallerThread, result, Return2, Return3, Return4);
}
//BasicConsole.WriteLine("DSC: Resetting info object...");
info.ProcessId = 0;
info.ThreadId = 0;
// See comment at top of loop for why this is necessary
//BasicConsole.WriteLine("DSC: Pausing scheduler...");
Scheduler.Disable(/*"DSC 2"*/);
//BasicConsole.WriteLine("DSC: Queuing info object...");
DeferredSyscallsInfo_Unqueued.Push(info);
//BasicConsole.WriteLine("DSC: Resuming scheduler...");
Scheduler.Enable();
}
}
}
/// <summary>
/// Gets the outpoint desciptors of the available outpoints of the specified class and subclass.
/// </summary>
/// <param name="numOutpoints">The known number of available outpoints. Use GetNumPipeOutpoints to obtain this number.</param>
/// <param name="SysCallResult">Out : The result of the system call. Check this is set to OK.</param>
/// <param name="OutpointDescriptors">Out : The array of outpoint descriptors.</param>
/// <param name="Class">The class of pipe to search for.</param>
/// <param name="Subclass">The subclass of pipe to search for.</param>
public static void GetOutpointDescriptors(int numOutpoints, out SystemCallResults SysCallResult, out Pipes.PipeOutpointDescriptor[] OutpointDescriptors, Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass)
{
OutpointDescriptors = new Pipes.PipeOutpointDescriptor[numOutpoints];
Pipes.PipeOutpointsRequest *RequestPtr = (Pipes.PipeOutpointsRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.PipeOutpointsRequest), "BasicServerHelpers : Alloc PipeOutpointsRequest");
if (RequestPtr != null)
{
try
{
RequestPtr->MaxDescriptors = numOutpoints;
RequestPtr->Outpoints = (Pipes.PipeOutpointDescriptor *)((byte *)Utilities.ObjectUtilities.GetHandle(OutpointDescriptors) + FOS_System.Array.FieldsBytesSize);
if (RequestPtr->Outpoints != null)
{
SysCallResult = SystemCalls.GetPipeOutpoints(Class, Subclass, RequestPtr);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unhandled!");
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Failed!");
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Succeeded.");
break;
default:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unexpected system call result!");
break;
}
}
else
{
SysCallResult = SystemCallResults.Fail;
//BasicConsole.WriteLine("BasicServerHelpers > RequestPtr->Outpoints null! No memory allocated.");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory outpoints list in outpoints request!"));
}
}
finally
{
Heap.Free(RequestPtr);
}
}
else
{
SysCallResult = SystemCallResults.Fail;
//BasicConsole.WriteLine("BasicServerHelpers > RequestPtr null! No memory allocated.");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory get outpoints request!"));
}
}
/// <summary>
/// Creates and connects a new pipe to the specified target process.
/// </summary>
/// <param name="anOutProcessId">The target process to connect to.</param>
/// <param name="aClass">The class of pipe to create.</param>
/// <param name="aSubclass">The subclass of pipe to create.</param>
/// <param name="aBufferSize">The size of buffer to use within the core OS.</param>
public BasicInpoint(uint anOutProcessId, PipeClasses aClass, PipeSubclasses aSubclass, int aBufferSize)
{
OutProcessId = anOutProcessId;
Class = aClass;
Subclass = aSubclass;
BufferSize = aBufferSize;
Pipes.CreatePipeRequest *RequestPtr = (Pipes.CreatePipeRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.CreatePipeRequest), "BasicInPipe : Alloc CreatePipeRequest");
if (RequestPtr != null)
{
try
{
RequestPtr->BufferSize = aBufferSize;
RequestPtr->Class = aClass;
RequestPtr->Subclass = aSubclass;
SystemCallResults SysCallResult = SystemCalls.CreatePipe(anOutProcessId, RequestPtr);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Unhandled!");
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Failed!");
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Succeeded.");
PipeId = RequestPtr->Result.Id;
//BasicConsole.Write("BasicInPipe > CreatePipe: New pipe id = ");
//BasicConsole.WriteLine(PipeId);
break;
default:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Unexpected system call result!");
break;
}
}
finally
{
Heap.Free(RequestPtr);
}
}
else
{
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicInPipe : Couldn't allocate memory to create pipe!"));
//BasicConsole.WriteLine("BasicInPipe > RequestPtr null! No memory allocated.");
}
}
public void Start(Device Device)
{
Level = SystemCalls.GetVolume();
while (true)
{
var newLevel = SystemCalls.GetVolume();
if (newLevel != Level)
{
Level = newLevel;
Device.SendNewVolume(Level);
}
Thread.Sleep(1000);
}
}
public static void OutputProcessing()
{
ready_count++;
// Wait for pipe to be created
SystemCalls.SleepThread(SystemCalls.IndefiniteSleepThread);
PipeInfo CurrentPipeInfo = ((PipeInfo)ConnectedPipes[CurrentPipeIdx]);
while (!Terminating)
{
try
{
bool AltPressed = Keyboard.Default.AltPressed;
uint Scancode;
bool GotScancode = Keyboard.Default.GetScancode(out Scancode);
if (GotScancode)
{
KeyboardKey Key;
if (Keyboard.Default.GetKeyValue(Scancode, out Key))
{
if (AltPressed && Key == KeyboardKey.Tab)
{
CurrentPipeIdx++;
if (CurrentPipeIdx >= ConnectedPipes.Count)
{
CurrentPipeIdx = 0;
}
CurrentPipeInfo = ((PipeInfo)ConnectedPipes[CurrentPipeIdx]);
CurrentPipeIndex_Changed = true;
}
else
{
SystemCalls.SendMessage(((PipeInfo)ConnectedPipes[CurrentPipeIdx]).StdOut.OutProcessId, Scancode, 0);
}
}
}
}
catch
{
BasicConsole.WriteLine("WM > Error during output processing!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
}
private void SendAnswer(IEnumerable <IPAddress> addresses, Message msg, string service)
{
var instanceName = SystemCalls.SystemGuid();
var res = msg.CreateResponse();
foreach (var address in addresses)
{
res.Answers.Add(new ARecord
{
Name = $"{service}.local",
Address = address
});
}
res.Answers.Add(new TXTRecord
{
Name = $"SamDel-{instanceName.Replace("-", "")}.{service}.local",
Strings = new List <string>()
{
$"id={instanceName.Replace("-", "")}",
$"cd={Guid.Empty.ToString().Replace("-", "").ToUpper()}",
$"rm=",
$"ve=05",
$"md=SamDel",
$"ic=/setup/icon.png",
$"fn={deviceName}",
$"ca=2052",
$"st=0",
$"bs=0009B0700387",
$"nf=2",
$"rs="
}
});
res.Answers.Add(new SRVRecord
{
Name = $"SamDel-{instanceName.Replace("-", "")}.{service}.local",
Port = port,
Target = $"{serviceType}.local"
});
mdns.SendAnswer(res);
}
public static CastMessage MediaStatusMessage(int requestId, DeviceState state, float secondsPlaying)
{
var mediaStatusMessage = new MessageMediaStatus
{
type = "MEDIA_STATUS",
requestId = requestId,
status = new List <MediaStatus>()
{
new MediaStatus {
currentTime = secondsPlaying,
playerState = state.ToString().ToUpper(),
volume = new Volume
{
controlType = "master",
level = SystemCalls.GetVolume(),
muted = SystemCalls.IsMuted(),
stepInterval = .01f
}
}
},
};
return(GetCastMessage(mediaStatusMessage, namespaceReceiver));
}
public static int SetConsoleLed(LedColor color, LedMode mode)
{
return(SystemCalls.System_Call_2(386, (int)color, (int)mode));
}
public void LoadSegments(ELFFile fileToLoadFrom, ref bool OK, ref bool DynamicLinkingRequired, uint memBaseAddress)
{
uint fileBaseAddress = fileToLoadFrom.BaseAddress;
List Segments = fileToLoadFrom.Segments;
for (int i = 0; i < Segments.Count; i++)
{
ELFSegment segment = (ELFSegment)Segments[i];
if (segment.Header.Type == ELFSegmentType.Interp ||
segment.Header.Type == ELFSegmentType.Dynamic)
{
DynamicLinkingRequired = true;
}
else if (segment.Header.Type == ELFSegmentType.Load)
{
int bytesRead = segment.Read(fileToLoadFrom.TheStream);
if (bytesRead != segment.Header.FileSize)
{
OK = false;
ExceptionMethods.Throw(new FOS_System.Exception("Error loading ELF segments! Failed to load correct segment bytes from file."));
}
byte *destMemPtr = (segment.Header.VAddr - fileBaseAddress) + memBaseAddress;
byte *pageAlignedDestMemPtr = (byte *)((uint)destMemPtr & 0xFFFFF000);
Console.Default.Write(" Loading segment from ");
Console.Default.Write_AsDecimal((uint)segment.Header.VAddr);
Console.Default.Write(" to ");
Console.Default.WriteLine_AsDecimal((uint)destMemPtr);
BasicConsole.Write(" Loading segment from ");
BasicConsole.Write((uint)segment.Header.VAddr);
BasicConsole.Write(" to ");
BasicConsole.WriteLine((uint)destMemPtr);
SystemCalls.SleepThread(1000);
uint copyOffset = (uint)(destMemPtr - pageAlignedDestMemPtr);
uint copyFromOffset = 0;
bool executable = (segment.Header.Flags & ELFFlags.Executable) != 0;
for (uint pageOffset = 0; pageOffset < segment.Header.MemSize; pageOffset += 4096)
{
uint physPageAddr = Hardware.VirtMemManager.FindFreePhysPage();
uint virtPageAddr = (uint)pageAlignedDestMemPtr + pageOffset;
Hardware.VirtMemManager.Map(
physPageAddr,
virtPageAddr,
4096,
theProcess.UserMode ? Hardware.VirtMem.VirtMemImpl.PageFlags.None : Hardware.VirtMem.VirtMemImpl.PageFlags.KernelOnly);
ProcessManager.CurrentProcess.TheMemoryLayout.AddDataPage(physPageAddr, virtPageAddr);
if (executable)
{
theProcess.TheMemoryLayout.AddCodePage(physPageAddr, virtPageAddr);
}
else
{
theProcess.TheMemoryLayout.AddDataPage(physPageAddr, virtPageAddr);
}
uint copySize = FOS_System.Math.Min((uint)bytesRead, 4096 - copyOffset);
if (copySize > 0)
{
Utilities.MemoryUtils.MemCpy_32(
(byte *)(virtPageAddr + copyOffset),
((byte *)Utilities.ObjectUtilities.GetHandle(segment.Data)) + FOS_System.Array.FieldsBytesSize + pageOffset - copyFromOffset,
copySize);
bytesRead -= (int)copySize;
}
for (uint j = copySize + copyOffset; j < 4096; j++)
{
*(byte *)(virtPageAddr + j) = 0;
}
if (copyOffset > 0)
{
copyFromOffset += copyOffset;
copyOffset = 0;
}
}
}
}
}
public static void Main()
{
BasicConsole.WriteLine("Kernel task! ");
BasicConsole.WriteLine(" > Executing normally...");
#region Dictionary Test
/*try
* {
* UInt32Dictionary dic = new UInt32Dictionary();
*
* for (uint i = 0; i < 9; i += 3)
* {
* BasicConsole.WriteLine("Dictionary test loop");
* BasicConsole.WriteLine("--------------------");
*
* uint key1 = 0xC0DEC0DEu + (0x100u * i);
* uint key2 = 0xC0DEC0DEu + (0x100u * (i+1));
* uint key3 = 0xC0DEC0DEu + (0x100u * (i+2));
*
* uint value1 = 0xDEADBEE0u + (0x1u * i);
* uint value2 = 0xDEADBEE0u + (0x1u * (i+1));
* uint value3 = 0xDEADBEE0u + (0x1u * (i+2));
*
* dic.Add(key1, value1);
* dic.Add(key2, value2);
* dic.Add(key3, value3);
*
* for(uint j = 50 * i; j < (50 * (i+1))-20; j++)
* {
* dic.Add(j, j);
* }
*
* if (!dic.Contains(key1))
* {
* BasicConsole.WriteLine("Dictionary doesn't contain key 1.");
* }
* else if (dic[key1] != value1)
* {
* BasicConsole.WriteLine("Dictionary value for key 1 wrong.");
* }
* else
* {
* BasicConsole.WriteLine("Okay (1)");
* }
* if (!dic.Contains(key2))
* {
* BasicConsole.WriteLine("Dictionary doesn't contain key1");
* }
* else if (dic[key2] != value2)
* {
* BasicConsole.WriteLine("Dictionary value for key1 wrong.");
* }
* else
* {
* BasicConsole.WriteLine("Okay (2)");
* }
* if (!dic.Contains(key3))
* {
* BasicConsole.WriteLine("Dictionary doesn't contain key1");
* }
* else if (dic[key3] != value3)
* {
* BasicConsole.WriteLine("Dictionary value for key1 wrong.");
* }
* else
* {
* BasicConsole.WriteLine("Okay (3)");
* }
*
* dic.Remove(key1);
*
* if (dic.Contains(key1))
* {
* BasicConsole.WriteLine("Dictionary contains key1!");
* }
* else
* {
* BasicConsole.WriteLine("Okay (4)");
* }
*
* BasicConsole.WriteLine("Iterating");
* UInt32Dictionary.Iterator itr = dic.GetIterator();
* while (itr.HasNext())
* {
* UInt32Dictionary.KeyValuePair pair = itr.Next();
* BasicConsole.WriteLine("Pair: key=" + (FOS_System.String)pair.Key + ", value=" + pair.Value);
* }
*
* dic.Remove(key2);
*
* for (uint j = (50 * i)+30; j < (50 * (i + 1)); j++)
* {
* dic.Add(j, j);
* }
*
* if (dic.Contains(key2))
* {
* BasicConsole.WriteLine("Dictionary contains key2!");
* }
* else
* {
* BasicConsole.WriteLine("Okay (5)");
* }
*
*
* dic.Remove(key3);
*
* if (dic.Contains(key3))
* {
* BasicConsole.WriteLine("Dictionary contains key3!");
* }
* else
* {
* BasicConsole.WriteLine("Okay (6)");
* }
*
* itr = dic.GetIterator();
* while (itr.HasNext())
* {
* UInt32Dictionary.KeyValuePair pair = itr.Next();
* BasicConsole.WriteLine("Pair: key=" + (FOS_System.String)pair.Key + ", value=" + pair.Value);
* }
* }
* }
* catch
* {
* BasicConsole.WriteLine("Error testing UInt32Dictionary.");
* BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
* }
* BasicConsole.DelayOutput(5);
*/
#endregion
DeferredSyscallsInfo_Unqueued = new Queue(256, false);
DeferredSyscallsInfo_Queued = new Queue(DeferredSyscallsInfo_Unqueued.Capacity, false);
for (int i = 0; i < DeferredSyscallsInfo_Unqueued.Capacity; i++)
{
DeferredSyscallsInfo_Unqueued.Push(new DeferredSyscallInfo());
}
try
{
BasicConsole.WriteLine(" > Initialising system calls...");
ProcessManager.CurrentProcess.SyscallHandler = SyscallHandler;
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterSyscallHandler);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.DeregisterSyscallHandler);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.StartThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SleepThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WakeThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterPipeOutpoint);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetNumPipeOutpoints);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetPipeOutpoints);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WaitOnPipeCreate);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReadPipe);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WritePipe);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SendMessage);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReceiveMessage);
//ProcessManager.CurrentProcess.OutputMemTrace = true;
BasicConsole.WriteLine(" > Starting Idle process...");
Process IdleProcess = ProcessManager.CreateProcess(Tasks.IdleTask.Main, "Idle", false, true);
ProcessManager.RegisterProcess(IdleProcess, Scheduler.Priority.ZeroTimed);
BasicConsole.WriteLine(" > Starting deferred syscalls thread...");
DeferredSyscallsThread = ProcessManager.CurrentProcess.CreateThread(DeferredSyscallsThread_Main, "Deferred Sys Calls");
#if DEBUG
BasicConsole.WriteLine(" > Starting Debugger thread...");
Debug.Debugger.MainThread = ProcessManager.CurrentProcess.CreateThread(Debug.Debugger.Main, "Debugger");
#endif
BasicConsole.WriteLine(" > Starting GC Cleanup thread...");
ProcessManager.CurrentProcess.CreateThread(Tasks.GCCleanupTask.Main, "GC Cleanup");
BasicConsole.WriteLine(" > Starting Window Manager...");
Process WindowManagerProcess = ProcessManager.CreateProcess(WindowManagerTask.Main, "Window Manager", false, true);
WindowManagerTask_ProcessId = WindowManagerProcess.Id;
//WindowManagerProcess.OutputMemTrace = true;
ProcessManager.RegisterProcess(WindowManagerProcess, Scheduler.Priority.Normal);
BasicConsole.WriteLine(" > Waiting for Window Manager to be ready...");
while (!WindowManagerTask.Ready)
{
BasicConsole.WriteLine(" > [Wait pause]");
SystemCalls.SleepThread(1000);
}
BasicConsole.WriteLine(" > Window Manager reported ready.");
BasicConsole.WriteLine(" > Starting Device Manager...");
Process DeviceManagerProcess = ProcessManager.CreateProcess(DeviceManagerTask.Main, "Device Manager", false, true);
//DeviceManagerProcess.OutputMemTrace = true;
ProcessManager.RegisterProcess(DeviceManagerProcess, Scheduler.Priority.Normal);
//TODO: Main task for commands etc
BasicConsole.WriteLine("Started.");
BasicConsole.PrimaryOutputEnabled = false;
//BasicConsole.SecondaryOutputEnabled = false;
try
{
BasicConsole.WriteLine("KT > Creating virtual keyboard...");
keyboard = new Hardware.Keyboards.VirtualKeyboard();
BasicConsole.WriteLine("KT > Creating virtual console...");
console = new Consoles.VirtualConsole();
BasicConsole.WriteLine("KT > Connecting virtual console...");
console.Connect();
BasicConsole.WriteLine("KT > Creating main shell...");
Shells.MainShell shell = new Shells.MainShell(console, keyboard);
BasicConsole.WriteLine("KT > Running...");
uint loops = 0;
while (!Terminating)
{
try
{
//FOS_System.String msg = "KT > Hello, world! (" + (FOS_System.String)loops++ + ")";
//console.WriteLine(msg);
//BasicConsole.WriteLine(msg);
//SystemCalls.SleepThread(1000);
shell.Execute();
}
catch
{
BasicConsole.WriteLine("KT > Error executing MainShell!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
}
catch
{
BasicConsole.WriteLine("KT > Error initialising!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
//BasicConsole.WriteLine(" > Starting Play Notes task...");
//ProcessManager.CurrentProcess.CreateThread(Hardware.Tasks.PlayNotesTask.Main);
//Console.InitDefault();
//Shell.InitDefault();
//BasicConsole.PrimaryOutputEnabled = false;
//Shell.Default.Execute();
//BasicConsole.PrimaryOutputEnabled = true;
//if (!Shell.Default.Terminating)
//{
// Console.Default.WarningColour();
// Console.Default.WriteLine("Abnormal shell shutdown!");
// Console.Default.DefaultColour();
//}
//else
//{
// Console.Default.Clear();
//}
}
catch
{
BasicConsole.PrimaryOutputEnabled = true;
BasicConsole.SetTextColour(BasicConsole.warning_colour);
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
BasicConsole.SetTextColour(BasicConsole.default_colour);
}
BasicConsole.WriteLine();
BasicConsole.WriteLine("---------------------");
BasicConsole.WriteLine();
BasicConsole.WriteLine("End of kernel task.");
ExceptionMethods.HaltReason = "Managed main thread ended.";
//TODO: Exit syscall
}
public void ProcessMessage(DeviceListener deviceListener, CastMessage castMessage)
{
var options = new JsonSerializerOptions {
IncludeFields = true
};
var message = JsonSerializer.Deserialize <PayloadMessageBase>(castMessage.PayloadUtf8, options);
switch (message.type)
{
case "SET_VOLUME":
if (castMessage.PayloadUtf8.Contains("muted", System.StringComparison.CurrentCulture))
{
var volumeMuteMessage = JsonSerializer.Deserialize <MessageVolumeMute>(castMessage.PayloadUtf8, options);
SystemCalls.SetMute(volumeMuteMessage.volume.muted);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(volumeMuteMessage.requestId, state, SecondsPlaying()), state);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(volumeMuteMessage.requestId), state);
}
else
{
var volumeMessage = JsonSerializer.Deserialize <MessageVolume>(castMessage.PayloadUtf8, options);
SystemCalls.SetVolume(volumeMessage.volume.level);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(volumeMessage.requestId, state, SecondsPlaying()), state);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(volumeMessage.requestId), state);
}
break;
case "CONNECT":
state = DeviceState.Connected;
break;
case "CLOSE":
state = DeviceState.Closed;
var closeMessage = JsonSerializer.Deserialize <MessageStop>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(closeMessage.requestId, state, 0), state);
break;
case "LAUNCH":
state = DeviceState.Launching;
var launchMessage = JsonSerializer.Deserialize <MessageLaunch>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(launchMessage.requestId), state);
break;
case "LOAD":
state = DeviceState.Loading;
var loadMessage = JsonSerializer.Deserialize <MessageLoad>(castMessage.PayloadUtf8, options);
logger.Log($"[{state}] Start playing: {loadMessage?.media?.contentId}");
SystemCalls.StartPlaying(loadMessage.media.contentId);
playerPlayTime = DateTime.Now;
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(loadMessage.requestId, state, SecondsPlaying()), state);
state = DeviceState.Buffering;
Task.Delay(2000).Wait();
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(loadMessage.requestId, state, SecondsPlaying()), state);
break;
case "PAUSE":
state = DeviceState.Paused;
var pauseMessage = JsonSerializer.Deserialize <MessagePause>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(pauseMessage.requestId, state, SecondsPlaying()), state);
break;
case "PLAY":
break;
case "STOP":
state = DeviceState.Idle;
var stopMessage = JsonSerializer.Deserialize <MessageStop>(castMessage.PayloadUtf8, options);
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(stopMessage.requestId, state, 0), state);
SystemCalls.StopPlaying();
break;
case "PING":
break;
case "PONG":
break;
case "GET_STATUS":
var getstatusMessage = JsonSerializer.Deserialize <MessageStatus>(castMessage.PayloadUtf8, options);
if (state == DeviceState.Buffering)
{
state = DeviceState.Playing;
}
switch (state)
{
case DeviceState.Idle:
case DeviceState.Closed:
case DeviceState.Connected:
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(getstatusMessage.requestId), state);
break;
case DeviceState.Playing:
deviceListener.Write(ChromeCastMessages.MediaStatusMessage(getstatusMessage.requestId, state, SecondsPlaying()), state);
break;
default:
deviceListener.Write(ChromeCastMessages.ReceiverStatusMessage(getstatusMessage.requestId), state);
break;
}
break;
default:
logger.Log($"in default [{DateTime.Now.ToLongTimeString()}] {message.type} {castMessage.PayloadUtf8}");
break;
}
}
public static void Main()
{
BasicConsole.WriteLine("Kernel task! ");
BasicConsole.WriteLine(" > Executing normally...");
DeferredSyscallsInfo_Unqueued = new Queue(256, false);
DeferredSyscallsInfo_Queued = new Queue(DeferredSyscallsInfo_Unqueued.Capacity, false);
for (int i = 0; i < DeferredSyscallsInfo_Unqueued.Capacity; i++)
{
DeferredSyscallsInfo_Unqueued.Push(new DeferredSyscallInfo());
}
try
{
BasicConsole.WriteLine(" > Initialising system calls...");
ProcessManager.CurrentProcess.SyscallHandler = SyscallHandler;
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterSyscallHandler);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.DeregisterSyscallHandler);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.StartThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SleepThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WakeThread);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterPipeOutpoint);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetNumPipeOutpoints);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetPipeOutpoints);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WaitOnPipeCreate);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReadPipe);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WritePipe);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SendMessage);
ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReceiveMessage);
//ProcessManager.CurrentProcess.OutputMemTrace = true;
BasicConsole.WriteLine(" > Starting Idle process...");
Process IdleProcess = ProcessManager.CreateProcess(Tasks.IdleTask.Main, "Idle", false, true);
ProcessManager.RegisterProcess(IdleProcess, Scheduler.Priority.ZeroTimed);
BasicConsole.WriteLine(" > Starting deferred syscalls thread...");
DeferredSyscallsThread = ProcessManager.CurrentProcess.CreateThread(DeferredSyscallsThread_Main, "Deferred Sys Calls");
#if DEBUG
BasicConsole.WriteLine(" > Starting Debugger thread...");
Debug.Debugger.MainThread = ProcessManager.CurrentProcess.CreateThread(Debug.Debugger.Main, "Debugger");
#endif
BasicConsole.WriteLine(" > Starting GC Cleanup thread...");
ProcessManager.CurrentProcess.CreateThread(Tasks.GCCleanupTask.Main, "GC Cleanup");
BasicConsole.WriteLine(" > Starting Window Manager...");
Process WindowManagerProcess = ProcessManager.CreateProcess(WindowManagerTask.Main, "Window Manager", false, true);
WindowManagerTask_ProcessId = WindowManagerProcess.Id;
//WindowManagerProcess.OutputMemTrace = true;
ProcessManager.RegisterProcess(WindowManagerProcess, Scheduler.Priority.Normal);
BasicConsole.WriteLine(" > Waiting for Window Manager to be ready...");
while (!WindowManagerTask.Ready)
{
BasicConsole.WriteLine(" > [Wait pause]");
SystemCalls.SleepThread(1000);
}
BasicConsole.WriteLine(" > Window Manager reported ready.");
BasicConsole.WriteLine(" > Starting Device Manager...");
Process DeviceManagerProcess = ProcessManager.CreateProcess(DeviceManagerTask.Main, "Device Manager", false, true);
//DeviceManagerProcess.OutputMemTrace = true;
ProcessManager.RegisterProcess(DeviceManagerProcess, Scheduler.Priority.Normal);
//TODO: Main task for commands etc
BasicConsole.WriteLine("Started.");
BasicConsole.PrimaryOutputEnabled = false;
//BasicConsole.SecondaryOutputEnabled = false;
try
{
BasicConsole.WriteLine("KT > Creating virtual keyboard...");
keyboard = new Hardware.Keyboards.VirtualKeyboard();
BasicConsole.WriteLine("KT > Creating virtual console...");
console = new Consoles.VirtualConsole();
BasicConsole.WriteLine("KT > Connecting virtual console...");
console.Connect();
BasicConsole.WriteLine("KT > Creating main shell...");
Shells.MainShell shell = new Shells.MainShell(console, keyboard);
BasicConsole.WriteLine("KT > Running...");
uint loops = 0;
while (!Terminating)
{
try
{
//FOS_System.String msg = "KT > Hello, world! (" + (FOS_System.String)loops++ + ")";
//console.WriteLine(msg);
//BasicConsole.WriteLine(msg);
//SystemCalls.SleepThread(1000);
shell.Execute();
}
catch
{
BasicConsole.WriteLine("KT > Error executing MainShell!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
}
catch
{
BasicConsole.WriteLine("KT > Error initialising!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
//BasicConsole.WriteLine(" > Starting Play Notes task...");
//ProcessManager.CurrentProcess.CreateThread(Hardware.Tasks.PlayNotesTask.Main);
//Console.InitDefault();
//Shell.InitDefault();
//BasicConsole.PrimaryOutputEnabled = false;
//Shell.Default.Execute();
//BasicConsole.PrimaryOutputEnabled = true;
//if (!Shell.Default.Terminating)
//{
// Console.Default.WarningColour();
// Console.Default.WriteLine("Abnormal shell shutdown!");
// Console.Default.DefaultColour();
//}
//else
//{
// Console.Default.Clear();
//}
}
catch
{
BasicConsole.PrimaryOutputEnabled = true;
BasicConsole.SetTextColour(BasicConsole.warning_colour);
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
BasicConsole.SetTextColour(BasicConsole.default_colour);
}
BasicConsole.WriteLine();
BasicConsole.WriteLine("---------------------");
BasicConsole.WriteLine();
BasicConsole.WriteLine("End of kernel task.");
ExceptionMethods.HaltReason = "Managed main thread ended.";
//TODO: Exit syscall
}
public static void Main()
{
BasicConsole.WriteLine("Window Manager: Started.");
// Initialise heap & GC
Hardware.Processes.ProcessManager.CurrentProcess.InitHeap();
// Start thread for calling GC Cleanup method
if (SystemCalls.StartThread(GCCleanupTask.Main, out GCThreadId) != SystemCallResults.OK)
{
BasicConsole.WriteLine("Window Manager: GC thread failed to create!");
}
// Initialise connected pipes list
ConnectedPipes = new List();
// Start thread for handling background input processing
if (SystemCalls.StartThread(InputProcessing, out InputProcessingThreadId) != SystemCallResults.OK)
{
BasicConsole.WriteLine("Window Manager: InputProcessing thread failed to create!");
}
BasicConsole.Write("WM > InputProcessing thread id: ");
BasicConsole.WriteLine(InputProcessingThreadId);
BasicConsole.Write("WM > Register RegisterPipeOutpoint syscall handler");
SystemCalls.RegisterSyscallHandler(SystemCallNumbers.RegisterPipeOutpoint, SyscallHandler);
// Start thread for handling background output processing
if (SystemCalls.StartThread(OutputProcessing, out OutputProcessingThreadId) != SystemCallResults.OK)
{
BasicConsole.WriteLine("Window Manager: OutputProcessing thread failed to create!");
}
BasicConsole.WriteLine("WM > Init keyboard");
Keyboard.InitDefault();
BasicConsole.WriteLine("WM > Register IRQ 1 handler");
SystemCalls.RegisterIRQHandler(1, HandleIRQ);
BasicConsole.WriteLine("WM > Wait for pipe to be created");
// Wait for pipe to be created
ready_count++;
SystemCalls.SleepThread(SystemCalls.IndefiniteSleepThread);
PipeInfo CurrentPipeInfo = null;
while (!Terminating)
{
try
{
if (CurrentPipeIdx > -1)
{
if (CurrentPipeIndex_Changed)
{
CurrentPipeInfo = ((PipeInfo)ConnectedPipes[CurrentPipeIdx]);
CurrentPipeIndex_Changed = false;
CurrentPipeInfo.TheConsole.Update();
}
CurrentPipeInfo.TheConsole.Write(CurrentPipeInfo.StdOut.Read(false));
}
}
catch
{
if (ExceptionMethods.CurrentException is Pipes.Exceptions.RWFailedException)
{
SystemCalls.SleepThread(50);
}
else
{
BasicConsole.WriteLine("WM > Exception running window manager.");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
}
}
public static void InputProcessing()
{
ready_count++;
while (!Terminating)
{
//BasicConsole.WriteLine("WM > IP : (0)");
if (!InputProcessingThreadAwake)
{
SystemCalls.SleepThread(SystemCalls.IndefiniteSleepThread);
}
InputProcessingThreadAwake = false;
BasicConsole.WriteLine("WM > InputProcessing thread running...");
int numOutpoints;
SystemCallResults SysCallResult;
Pipes.BasicOutpoint.GetNumPipeOutpoints(out numOutpoints, out SysCallResult, Pipes.PipeClasses.Standard, Pipes.PipeSubclasses.Standard_Out);
//BasicConsole.WriteLine("WM > IP : (1)");
if (SysCallResult == SystemCallResults.OK && numOutpoints > 0)
{
//BasicConsole.WriteLine("WM > IP : (2)");
Pipes.PipeOutpointDescriptor[] OutpointDescriptors;
Pipes.BasicOutpoint.GetOutpointDescriptors(numOutpoints, out SysCallResult, out OutpointDescriptors, Pipes.PipeClasses.Standard, Pipes.PipeSubclasses.Standard_Out);
//BasicConsole.WriteLine("WM > IP : (3)");
if (SysCallResult == SystemCallResults.OK)
{
//BasicConsole.WriteLine("WM > IP : (4)");
for (int i = 0; i < OutpointDescriptors.Length; i++)
{
//BasicConsole.WriteLine("WM > IP : (5)");
Pipes.PipeOutpointDescriptor Descriptor = OutpointDescriptors[i];
bool PipeExists = false;
for (int j = 0; j < ConnectedPipes.Count; j++)
{
PipeInfo ExistingPipeInfo = (PipeInfo)ConnectedPipes[j];
if (ExistingPipeInfo.StdOut.OutProcessId == Descriptor.ProcessId)
{
PipeExists = true;
break;
}
}
if (!PipeExists)
{
try
{
//BasicConsole.WriteLine("WM > IP : (6)");
PipeInfo NewPipeInfo = new PipeInfo();
NewPipeInfo.StdOut = new Pipes.Standard.StandardInpoint(Descriptor.ProcessId, true); // 2000 ASCII characters = 2000 bytes
//BasicConsole.WriteLine("WM > IP : (7)");
ConnectedPipes.Add(NewPipeInfo);
if (CurrentPipeIdx == -1)
{
CurrentPipeIdx = 0;
CurrentPipeIndex_Changed = true;
SystemCalls.WakeThread(MainThreadId);
SystemCalls.WakeThread(OutputProcessingThreadId);
}
//BasicConsole.WriteLine("WM > IP : (8)");
}
catch
{
BasicConsole.WriteLine("WM > Error creating new pipe!");
BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message);
}
}
}
}
else
{
BasicConsole.WriteLine("WM > Couldn't get outpoint descriptors!");
}
}
else
{
BasicConsole.WriteLine("WM > Cannot get outpoints!");
}
}
}
