Add ExitApp() function for exiting multitasking apps with the exit() system call. Soon ExitApp() will also be the way that apps returning from main() will exit.

Add some code to timer_interrupt_handler() to check if a task has quit, and delete a ready queue entry if so.

Add stack trace to invalid opcode handler.

Expand simple debugger to check the module name to see which map file to load (only the kernel map file is implementing at the moment) and not lookup mappings in unknown modules. However, check the address and if the mapping is in kernel space, then look up the address from the kernel map. Also, reload map files when the kernel has been relaunched.

Add a temporary fix to TFTP to keep track of which task requested the file. If the TFTP receive packet handler is called when another task is running, switch to the page table of the task that requested the file, then switch back when we're done. This is only a hack and doesn't work in all cases. The next step is probably to implement kmalloc() so networking functions and drivers can allocate memory in kernel space without fear of causing a page fault later - this should be a permanent fix when it's implemented.

Remove GUI.map from repo (.map files change too much with each commit and it throws off my line count).

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 6401
+BUILD_NUMBER 6438

MyOS_1/Debugging/Debug.c

@@ -15,6 +15,8 @@ void DebugStackTrace(unsigned int MaxFrames)
     {
         // Unwind to previous stack frame
         serial_printf("0x%X\n", pStackFrame->eip);
+        if (pStackFrame->eip == 0)
+            break;
         pStackFrame = pStackFrame->ebp;
     }
 }

MyOS_1/Interrupts/Interrupts.c

@@ -183,7 +183,8 @@ void _declspec(naked) exit_interrupt_handler(int eflags, int cs)
     // supress warning about unused parameters
     (void)eflags, (void)cs;
 
-    longjmp(peReturnBuf, 42);
+    //longjmp(peReturnBuf, 42); // Not only do I not like this way of exitting, it doesn't work right now
+    ExitApp();
 
     // No need for iretd because we'll never return here
 }
@@ -637,10 +638,13 @@ void _declspec(naked) invalid_opcode_handler(void)
     {
         pop [address]
     }
-    
+
     terminal_fill(' ', VGA_COLOR_WHITE, VGA_COLOR_BLUE);
     terminal_writestring("Invalid opcode handler fired.\nEncountered invalid opcode at ");
     terminal_print_ulong_hex(address);
+    
+    DebugStackTrace(10);
+
     terminal_writestring(".\nMemory looks like:\n");
     terminal_dumpHexAround((uint8_t *)address, 128, 128);
     terminal_writestring("System halted.\n");
@@ -787,7 +791,6 @@ void _declspec(naked) printf_interrupt_handler(int eflags, int cs, const char *f
         GUI_printf(fmt, va);
     else
         vprintf_(fmt, va);
-
 
     _asm
     {

MyOS_1/Interrupts/System_Calls.c

@@ -9,8 +9,11 @@
 #include "../Drivers/Keyboard.h"
 
 
-void SystemCallExit()
+void SystemCallExit(int returnCode)
 {
+    // returnCode is ignored for now
+    (void)returnCode;
+
     //printf("exit called\n");
 
     __asm

MyOS_1/Interrupts/System_Calls.h

@@ -32,7 +32,7 @@ extern "C" {
 #define SYSCALL_REGISTER_GUI_CALLBACK   238
 #define SYSCALL_LAUNCH_APP          237
 
-void SystemCallExit();
+void SystemCallExit(int returnCode);
 #define exit SystemCallExit
 
 int SystemCallFClose(FILE *fp);

MyOS_1/Networking/TFTP.c

@@ -3,6 +3,7 @@
 #include "../Terminal.h"
 #include "Ethernet.h"
 #include "../Drivers/Virtio_Net.h"
+#include "../Tasks/Context.h"
 
 // TODO: Support multiple transactions
 uint16_t transactionID;
@@ -16,6 +17,7 @@ uint8_t *nextFilePointer;
 uint16_t currentBlockNumber;
 uint16_t virtualBoxBlockNumber; // workaround for VirtualBox's bullshit
 uint32_t tftpFileSize;
+uint32_t tftpTaskIndex; // TEMPTEMP HACKHACK
 
 uint32_t tftpServerIP; // TODO, maybe, support more than one server
 
@@ -30,9 +32,16 @@ bool TFTP_TransactionComplete()
 // will block until the file is transacted
 // TODO: Implement timeout, error-checking
 // TODO: Fix hanging if an invalid serverIP is given
+// TODO: We'll need mutexes or some other sync method to support multiple tasks
+// And / Or we'll need to replace globals with per-task variables
 // actualFileSize can be NULL if the caller doesn't care about the size
 bool TFTP_GetFile(uint32_t serverIP, const char *filename, uint8_t *destinationBuffer, uint32_t maxFileSize, uint32_t *actualFileSize)
 {
+    // TEMPTEMP HACKHACK block until any existing transfers have completed
+    while (transferInProgress)
+    {
+    }
+
     if(actualFileSize)
         *actualFileSize = 0;
 
@@ -41,6 +50,7 @@ bool TFTP_GetFile(uint32_t serverIP, const char *filename, uint8_t *destinationB
 
     tftpFileBuffer = destinationBuffer;
     tftpFileBufferSize = maxFileSize;
+    tftpTaskIndex = currentTask;
 
     if (debugLevel)
     {
@@ -79,6 +89,11 @@ bool TFTP_GetFile(uint32_t serverIP, const char *filename, uint8_t *destinationB
 // Retrieves the size of a file. This can take a while for large files, because we actually have to retrieve the entire file to know its size.
 bool TFTP_GetFileSize(uint32_t serverIP, const char *filename, uint32_t *pActualFileSize)
 {
+    // TEMPTEMP HACKHACK block until any existing transfers have completed
+    while (transferInProgress)
+    {
+    }
+
     // Ensure pActualFileSize is a valid pointer
     if (!pActualFileSize)
         return false;
@@ -88,6 +103,7 @@ bool TFTP_GetFileSize(uint32_t serverIP, const char *filename, uint32_t *pActual
 
     // TFTP doesn't support retreiving a file's size, so we request the file from the server, but don't store the file returned
     determiningFileSize = true;
+    tftpTaskIndex = currentTask;
 
     // Request the file from the server
     TFTP_RequestFile(serverIP, filename, TFTP_TYPE_BINARY, NIC_MAC);
@@ -247,9 +263,44 @@ void TFTP_ProcessDataPacket(TFTP_DataHeader *dataPacket, uint16_t sourcePort, ui
 
     if (!determiningFileSize)
     {
-        // copy received data to the file buffer
-        memcpy(nextFilePointer, dataPacket->data, dataSize);
-        nextFilePointer += dataSize;
+		// TEMPTEMP HACKHACK
+        // Now we've received some data, but we have to be careful because the task that's currently active
+        // may not have the same virtual memory space as the task that gave us the destination buffer.
+        // We need to ensure interrupts are disabled because we can't allow a context switch while we play with page tables.
+        __asm
+        {
+            // TODO: Are interrupts already disabled when we reach this code? Need to check on that.
+            pushf
+            cli
+        }
+
+        // Ensure we have the proper page directory loaded for nextFilePointer for the task which requested the file
+        if (currentTask == tftpTaskIndex || tasks[currentTask].cr3 == tasks[tftpTaskIndex].cr3)
+        {
+            // We don't need to do anything with paging
+
+            // copy received data to the file buffer
+            memcpy(nextFilePointer, dataPacket->data, dataSize);
+            nextFilePointer += dataSize;
+        }
+        else
+        {
+            // We need to swap out the page directory with the one for the task that requested the file
+            __writecr3(tasks[tftpTaskIndex].cr3);
+
+            // copy received data to the file buffer
+            memcpy(nextFilePointer, dataPacket->data, dataSize);
+            nextFilePointer += dataSize;
+
+            // restore the page directory of the current task
+            __writecr3(tasks[currentTask].cr3);
+        }
+
+        // Restore interrupt state
+        __asm
+        {
+            popf
+        }
     }
 
     tftpFileSize += dataSize;

MyOS_1/Tasks/Context.h

@@ -61,6 +61,8 @@ extern bool multiEnable; // TEMPTEMP
 
 void DispatchNewTask(uint32_t programStart, PAGE_DIRECTORY_ENTRY *newPageDirectory, uint32_t stackSize, const char *imageName, bool exclusive);
 
+void ExitApp();
+
 bool LaunchApp(const char *appName, int exclusive, uint32_t exeLocation);
 
 void SwitchTask(uint32_t taskIndex);

MyOS_1/Tasks/Dispatcher.c

@@ -69,7 +69,7 @@ void DispatchNewTask(uint32_t programStart, PAGE_DIRECTORY_ENTRY *newPageDirecto
 
     // Create ready queue entry
     READY_QUEUE_ENTRY *queueEntry;
-    queueEntry = malloc(sizeof(READY_QUEUE_ENTRY));
+    queueEntry = dbg_alloc(sizeof(READY_QUEUE_ENTRY));
     // TODO: Exitting programs will need to be cleaned up somehow
     if (!queueEntry)
     {
@@ -193,4 +193,43 @@ bool LaunchApp(const char *appName, int exclusive, uint32_t exeLocation)
     dbg_release(peBuffer);
 
     return succeeded;    
+}
+
+// This is where a running program will "return" to. We can also call it with the exit system call
+void ExitApp()
+{
+    // Make sure interrupts are disabled
+    _disable();
+
+    // TODO: handle multiEnable = false
+    // If the ready-queue is empty or contains only this task, 
+    // or if we're not running in multitasking mode, there's nothing we can do here
+    if (!readyQueueHead || (!readyQueueHead->nextEntry && readyQueueHead->taskIndex == currentTask))
+    {
+        kprintf("ExitApp called on only running app. System halted");
+        for (;;)
+            __halt();
+    }
+        
+    // Allow the task index to be reused
+    tasks[currentTask].inUse = false;
+    
+    // TODO: Free all memory associated with this task
+    // TODO: Free the stack or mark it as reusable (not sure how to do this right now)
+    
+    // Make sure this task can be swapped out ASAP
+    tasks[currentTask].exclusive = false;
+    ticksLeftInTask = 0;
+
+    printf("\n%s has exited.\n", tasks[currentTask].imageName);
+
+    // TODO: Tell the GUI the program has quit
+
+    // Enable interrupts
+    _enable();
+
+    // TODO: Is there a better way to switch contexts from here?
+    // Now we'll just wait for the timer interrupt to fire and this task will never be revisitted
+    for (;;)
+        __halt();
 }

MyOS_1/Timers/PIT.c

@@ -102,31 +102,53 @@ void _declspec(naked) timer_interrupt_handler(void)
             // Pull info from the front of the ready queue
             currentTask = readyQueueHead->taskIndex;
 
-            // Move the current task to the end of the ready queue
-            // Are there more than two ready queue entries?
-            if (readyQueueHead != finalReadyQueueEntry)
+            // Is the old task still running?
+            if (tasks[oldTaskIndex].inUse)
             {
-                readyQueueHead->taskIndex = oldTaskIndex;
-                finalReadyQueueEntry->nextEntry = readyQueueHead;
-                oldHead = readyQueueHead;
-                readyQueueHead = readyQueueHead->nextEntry;
-                oldHead->nextEntry = NULL;
+                // Move the current task to the end of the ready queue
+                // Are there more than two ready queue entries?
+                if (readyQueueHead != finalReadyQueueEntry)
+                {
+                    readyQueueHead->taskIndex = oldTaskIndex;
+                    finalReadyQueueEntry->nextEntry = readyQueueHead;
+                    oldHead = readyQueueHead;
+                    readyQueueHead = readyQueueHead->nextEntry;
+                    oldHead->nextEntry = NULL;
+                }
+                else
+                {
+                    readyQueueHead->taskIndex = oldTaskIndex;
+                }
             }
             else
             {
-                readyQueueHead->taskIndex = oldTaskIndex;
+                // The old task has quit, so we shouldn't add it to the ready queue and we have to
+                // free a ready queue entry or else we'll have one too many
+
+                // Is there more than one ready queue entry?
+                if (readyQueueHead->nextEntry)
+                {
+                    oldHead = readyQueueHead;
+                    readyQueueHead = readyQueueHead->nextEntry;
+                    dbg_release(oldHead);
+                }
+                else
+                {
+                    dbg_release(readyQueueHead);
+                    readyQueueHead = NULL;
+                }
             }
 
             if(debugLevel)
                 kprintf(" Switching to %s\n", tasks[currentTask].imageName);
 
             ticksLeftInTask = TICKS_PER_TASK;
 
-            // switch to the new task's page tables
+            // Switch to the new task's page tables
             if(tasks[currentTask].cr3 != __readcr3())
                 __writecr3(tasks[currentTask].cr3);
 
-            // Get the stack pointer of the next waiting task and make that the stack
+            // Set the stack pointer to the stack pointer of the new task
             espVal = tasks[currentTask].ESP;
 
             if(debugLevel)

MyOS_1/myos_io.c

@@ -5,6 +5,8 @@
 
 OPEN_FILES openFiles = { 0 };
 
+extern uint32_t currentTask;
+
 int file_close(int fp)
 {
     if (fp >= MAX_FILES || fp < 0)
@@ -58,18 +60,22 @@ int file_open(const char * filename, const char * mode)
         return -1;
     }
 
+    openFiles.buffer[index] = buffer;
+    openFiles.taskIndex[index] = currentTask;
+    openFiles.isOpen[index] = true;
+
     if (!TFTP_GetFile(tftpServerIP, (char *)filename, buffer, fileSize, NULL))
     {
         kprintf("Not able to open %s", filename);
+        openFiles.isOpen[index] = false;
         return -1;
     }
 
     strncpy(openFiles.filename[index], filename, MAX_PATH);
     openFiles.filePos[index] = 0;
     openFiles.fileSize[index] = fileSize;
     openFiles.readOnly[index] = true;
-    openFiles.isOpen[index] = true;
-    openFiles.buffer[index] = buffer;
+    
 
     kprintf("opened %s in slot %d\n", filename, index);