Add CloseApp() function and system call for closing one app from another.

Support closing an application from the GUI. Closing an application's window closes the app.

Author: tthomps

MyOS_1/Build_Number.h

@@ -3,4 +3,4 @@
 // Define a build number. This number will be incremented by a simple console program called by a post-build event
 // It's put here in its own file to keep the other program from messing up the source
 #define \
-BUILD_NUMBER 6438
+BUILD_NUMBER 6456

MyOS_1/Interrupts/IDT.c

@@ -100,6 +100,9 @@ void IDT_Init(void)
     // Set handler for launching an app
     Set_IDT_Entry((unsigned long)launch_app_interrupt_handler, SYSCALL_LAUNCH_APP);
 
+    // Set handler for closing an app
+    Set_IDT_Entry((unsigned long)close_app_interrupt_handler, SYSCALL_CLOSE_APP);
+
     /* fill the IDT descriptor */
     IDT_ptr.base = (uint32_t)IDT;
     IDT_ptr.size = (sizeof(IDT_ENTRY) * 256);

MyOS_1/Interrupts/Interrupts.c

@@ -97,6 +97,33 @@ void _declspec(naked) irq9_shared_interrupt_handler(void)
     }
 }
 
+void _declspec(naked) close_app_interrupt_handler(int eflags, int cs, uint32_t PID)
+{
+    (void)eflags, (void)cs;
+
+    __asm
+    {
+        // prologue
+        push ebp
+        mov ebp, esp
+
+        // disable interrupts
+        cli
+    }
+
+    ++interrupts_fired;
+
+    CloseApp(PID);
+
+    __asm
+    {
+        // epilogue
+        pop ebp
+
+        iretd
+    }
+}
+
 void _declspec(naked) default_exception_handler(void)
 {
     //_asm pushad;

MyOS_1/Interrupts/Interrupts.h

@@ -13,6 +13,8 @@
 
 extern unsigned long interrupts_fired;
 
+void close_app_interrupt_handler(int eflags, int cs, uint32_t PID);
+
 void default_exception_handler(void);
 
 void exit_interrupt_handler(int eflags, int cs);

MyOS_1/Interrupts/System_Calls.c

@@ -9,6 +9,18 @@
 #include "../Drivers/Keyboard.h"
 
 
+void SystemCallCloseApp(uint32_t PID)
+{
+    const int pointerSize = sizeof(uint32_t);
+
+    __asm
+    {
+        push[PID]               // push arguments onto stack
+        int SYSCALL_CLOSE_APP   // call close_app_interrupt_handler(PID)
+        add esp, pointerSize    // restore value of stack pointer
+    }
+}
+
 void SystemCallExit(int returnCode)
 {
     // returnCode is ignored for now

MyOS_1/Interrupts/System_Calls.h

@@ -31,6 +31,10 @@ extern "C" {
 #define SYSCALL_HIDE_SHELL_DISPLAY  239
 #define SYSCALL_REGISTER_GUI_CALLBACK   238
 #define SYSCALL_LAUNCH_APP          237
+#define SYSCALL_CLOSE_APP           236
+
+void SystemCallCloseApp(uint32_t PID);
+#define closeApp SystemCallCloseApp
 
 void SystemCallExit(int returnCode);
 #define exit SystemCallExit

MyOS_1/Tasks/Context.h

@@ -59,6 +59,8 @@ extern uint32_t nextPID;
 
 extern bool multiEnable; // TEMPTEMP
 
+void CloseApp(uint32_t PID);
+
 void DispatchNewTask(uint32_t programStart, PAGE_DIRECTORY_ENTRY *newPageDirectory, uint32_t stackSize, const char *imageName, bool exclusive);
 
 void ExitApp();

MyOS_1/Tasks/Dispatcher.c

@@ -4,6 +4,7 @@
 #include "../paging.h"
 #include "../Networking/TFTP.h"
 #include "../Executables/PE32.h"
+#include "../Console_Serial.h"
 
 PROCESS_CONTROL_BLOCK tasks[64] = { 0 };
 READY_QUEUE_ENTRY *readyQueueHead = NULL;
@@ -15,6 +16,78 @@ uint32_t nextPID = 1000;
 // This must be global so we can access it while playing with the stack in ways the compiler can't predict
 uint32_t stackPtr;
 
+// TODO: rewrite when we have waiting queues
+// Interrupts are disabled by interrupt handler for system call.
+void CloseApp(uint32_t PID)
+{
+    // If this task is running, let ExitApp() close it
+    if (tasks[currentTask].PID == PID)
+        ExitApp();
+
+    serial_printf("closing %d", PID);
+
+    // Find the index of the app that will be closed
+    int taskIndex;
+    for (taskIndex = 0; taskIndex < MAX_TASKS; ++taskIndex)
+    {
+        if (tasks[taskIndex].PID == PID)
+            break;
+    }
+    if (taskIndex >= MAX_TASKS)
+    {
+        kprintf("ERROR! CloseApp() called with invalid PID, %d!", PID);
+        return;
+    }
+
+    serial_printf(" - %s\n", tasks[taskIndex].imageName);
+
+    // Has the task been closed already?
+    if (!tasks[taskIndex].inUse)
+        return;
+
+    if (!readyQueueHead)
+    {
+        kprintf("Attempted to close a task with an empty ready queue!\n");
+        return;
+    }
+
+    // Find the ready queue entry associated with the task (and the one that preceeds it)
+    READY_QUEUE_ENTRY *pPreviousEntry = NULL;
+    READY_QUEUE_ENTRY *pCurrent = readyQueueHead;
+
+    while (pCurrent && pCurrent->taskIndex != taskIndex)
+    {
+        pPreviousEntry = pCurrent;
+        pCurrent = pCurrent->nextEntry;
+    }
+    
+    if (!pCurrent)
+    {
+        kprintf("ERROR! CloseApp() called with PID %d, but couldn't find it in the queue!\n", PID);
+        serial_printf("ERROR! CloseApp() called with PID %d, but couldn't find it in the queue\n", PID);
+        return;
+    }
+
+    // Was the app to close listed in the first entry?
+    if (!pPreviousEntry)
+    {
+        dbg_release(readyQueueHead);
+        readyQueueHead = pCurrent;
+    }
+    else
+    {
+        // Remove the ready queue entry and delete it
+        pPreviousEntry->nextEntry = pCurrent->nextEntry;
+        dbg_release(pCurrent);
+    }
+
+
+    // TODO: Free all memory associated with the app, including its stack
+    
+    // Mark the index as being free to use
+    tasks[taskIndex].inUse = false;
+}
+
 void DispatchNewTask(uint32_t programStart, PAGE_DIRECTORY_ENTRY *newPageDirectory, uint32_t stackSize, const char *imageName, bool exclusive)
 {
     // disable interrupts

MyOS_GUI_Shell/GUI_Kernel_Shell.h

@@ -11,6 +11,8 @@ extern "C" {
 #define \
 GUI_BASE_ADDRESS 0xC00000
 
+#define WINDOW_ID_IS_NOT_PID    0x80000000 /* Window ID's with this bit set aren't associated with an application */
+
 // Called by the kernel to send messages to the GUI
 void GUI_Kernel_Callback(uint32_t PID, uint32_t messageType, void *pData);
 

MyOS_GUI_Shell/GUI_Window.h

@@ -79,7 +79,6 @@ class GUI_Window : public GUI_Object
 
     void UpdateCursor();
 
-
     SDL_Surface *pSurface;
     GUI_Control *pClickedControl;
     char windowName[MAX_WINDOW_NAME_LENGTH];