feat: Implement system power management with Ctrl+Alt+Del and Ctrl+Alt+Esc

createfs

@@ -9,7 +9,7 @@ if ! command -v "mcopy" >/dev/null 2>&1; then
     exit 1
 fi
 
-if ! command -v "mkfs.fat" >/dev/null 2>&1; then
+if ! command -v "/usr/sbin/mkfs.fat" >/dev/null 2>&1; then
     echo "Error: this script depends on dosfstools. Please install it" >&2
     exit 1
 fi
@@ -40,6 +40,6 @@ fi
 
 dd if=/dev/zero of=$IMAGE bs=1M count=$SIZE_MB
 
-mkfs.fat -F 32 -n "$VOLUME_LABEL" $IMAGE
+/usr/sbin/mkfs.fat -F 32 -n "$VOLUME_LABEL" $IMAGE
 
-mcopy -i $IMAGE -s "$FOLDER"/* ::
+mcopy -i $IMAGE -s "$FOLDER"/* ::

kernel/filesystem/fat32.cpp

@@ -262,16 +262,21 @@ FS_RESULT FAT32FS::open_file(const char* path, file* descriptor){
     if (!buf) return FS_RESULT_NOTFOUND;
     descriptor->id = reserve_fd_id();
     descriptor->size = buf_ptr.size;
-    open_files.add(reserve_fd_id(), buf);
+    open_files.add(descriptor->id, buf);
     //TODO: go back to using a linked list, and a static id for the file, ideally global for system
     return FS_RESULT_SUCCESS;
 }
 
 size_t FAT32FS::read_file(file *descriptor, void* buf, size_t size){
     void* file = open_files[descriptor->id];
-    //TODO: keep track of file size and limit copy to only that or less
-    memcpy(buf, file, size);
-    return size;
+    if (!file) {
+        kprintf("[FAT32] File not found in open_files for id %x", descriptor->id);
+        return 0;
+    }
+    // Limit to actual file size
+    size_t read_size = size > descriptor->size ? descriptor->size : size;
+    memcpy(buf, file, read_size);
+    return read_size;
 }
 
 sizedptr FAT32FS::list_entries_handler(FAT32FS *instance, f32file_entry *entry, char *filename, const char *seek) {

kernel/filesystem/filesystem.cpp

@@ -78,7 +78,19 @@ FS_RESULT open_file(const char* path, file* descriptor){
     const char *search_path = path;
     driver_module *mod = get_module(&search_path);
     if (!mod) return FS_RESULT_NOTFOUND;
+
+    // Initialize descriptor fields to safe values before calling driver
+    descriptor->cursor = 0;
+    descriptor->size = 0;
+    descriptor->id = 0;
+
     FS_RESULT result = mod->open(search_path, descriptor);
+
+    // Ensure cursor is still 0 after driver call
+    if (descriptor->cursor != 0) {
+        descriptor->cursor = 0;
+    }
+
     if (!open_files)
         open_files = new LinkedList<open_file_descriptors>();
     open_files->push_front({
@@ -94,13 +106,45 @@ size_t read_file(file *descriptor, char* buf, size_t size){
         kprintf("[FS] No open files");
         return 0;
     }
-    open_file_descriptors file = open_files->find([descriptor](open_file_descriptors kvp){
+
+    // Find the file descriptor
+    auto found = open_files->find([descriptor](open_file_descriptors kvp){
         return descriptor->id == kvp.file_id;
-    })->data;
-    if (!file.mod) return 0;
-    size_t adj_size = min(size,file.file_size);
-    size_t amount_read = file.mod->read(descriptor, buf, adj_size, 0);
-    descriptor->cursor += amount_read;
+    });
+
+    if (!found) {
+        kprintf("[FS] File descriptor not found: %x", descriptor->id);
+        return 0;
+    }
+
+    open_file_descriptors file = found->data;
+    if (!file.mod) {
+        kprintf("[FS] No filesystem module for file");
+        return 0;
+    }
+
+    if (!file.mod->read) {
+        kprintf("[FS] No read function in filesystem module");
+        return 0;
+    }
+
+    // Fix corrupted cursor - reset to 0 for read from beginning
+    if (descriptor->cursor > file.file_size) {
+        kprintf("[FS] WARNING: Corrupted cursor %x, resetting to 0", descriptor->cursor);
+        descriptor->cursor = 0;
+    }
+
+    // Calculate how much we can actually read
+    size_t available = (descriptor->cursor >= file.file_size) ? 0 : (file.file_size - descriptor->cursor);
+    size_t read_size = min(size, available);
+
+    if (read_size == 0) {
+        return 0;
+    }
+
+    // Call the driver once for the entire read
+    size_t amount_read = file.mod->read(descriptor, buf, read_size, 0);
+
     return amount_read;
 }
 

kernel/kernel_processes/boot/login_screen.c

@@ -9,17 +9,66 @@
 #include "math/math.h"
 #include "std/string.h"
 #include "syscalls/syscalls.h"
+#include "process/syscall.h"  // For SYS_POWEROFF
+#include "power.h"  // For power_off()
+
+
+
+// Check if the keypress contains the Ctrl+Alt+Del combination
+bool is_ctrl_alt_del(keypress *kp) {
+    // Check for any CTRL modifier (left or right)
+    bool has_ctrl = (kp->modifier & (KEY_MOD_LCTRL | KEY_MOD_RCTRL)) != 0;
+    // Check for any ALT modifier (left or right) 
+    bool has_alt = (kp->modifier & (KEY_MOD_LALT | KEY_MOD_RALT)) != 0;
+
+    if (!has_ctrl || !has_alt) {
+        return false;
+    }
+
+    // Check for Delete key in any of the key slots
+    for (int i = 0; i < 6; i++) {
+        if (kp->keys[i] == KEY_DELETE) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Check if the keypress contains the Ctrl+Alt+ESC combination
+bool is_ctrl_alt_esc(keypress *kp) {
+    // Check for any CTRL modifier (left or right)
+    bool has_ctrl = (kp->modifier & (KEY_MOD_LCTRL | KEY_MOD_RCTRL)) != 0;
+    // Check for any ALT modifier (left or right)
+    bool has_alt = (kp->modifier & (KEY_MOD_LALT | KEY_MOD_RALT)) != 0;
+
+    if (!has_ctrl || !has_alt) {
+        return false;
+    }
+
+    // Check for ESC key in any of the key slots
+    for (int i = 0; i < 6; i++) {
+        if (kp->keys[i] == KEY_ESC) {
+            return true;
+        }
+    }
+    return false;
+}
 
 int login_screen(){
     sys_focus_current();
     sys_set_secure(true);
     char* buf = (char*)malloc(256);
     int len = 0;
     keypress old_kp;
+    bool ctrl_alt_del_pressed = false;
+    bool ctrl_alt_esc_pressed = false;
     const char* name = BOOTSCREEN_TEXT;
     string title = string_l(name);
     string subtitle = string_l("Login");
     gpu_clear(BG_COLOR);
+    // Shutdown hint position
+    int button_padding = 10;
+
     while (1)
     {
         gpu_size screen_size = gpu_get_screen_size();
@@ -31,13 +80,50 @@ int login_screen(){
         int yo = screen_middle.y;
         int height = char_size * 2;
 
+        // Draw title and subtitle
         gpu_draw_string(title, (gpu_point){screen_middle.x - ((title.length/2) * char_size), yo - char_size*9}, scale, 0xFFFFFFFF);
         gpu_draw_string(subtitle, (gpu_point){screen_middle.x - ((subtitle.length/2) * char_size), yo - char_size*6}, scale, 0xFFFFFFFF);
 
+        // Draw password input field
         gpu_fill_rect((gpu_rect){{xo,yo  - char_size/2}, {screen_size.width / 3, height}},BG_COLOR+0x111111);
         gpu_draw_string(s, (gpu_point){xo, yo}, scale, 0xFFFFFFFF);
+
+        // Draw shutdown hint
+        string shutdown_hint = string_l("Press Ctrl+Alt+Del to shutdown");
+        gpu_draw_string(shutdown_hint,
+                       (gpu_point){screen_size.width - (shutdown_hint.length * char_size) - button_padding,
+                                 screen_size.height - char_size - button_padding},
+                       1, 0x888888); // Gray text
+
         keypress kp;
         if (sys_read_input_current(&kp)){
+
+            // Check for Ctrl+Alt+Del to shutdown
+            if (is_ctrl_alt_del(&kp)) {
+                if (!ctrl_alt_del_pressed) {
+                    ctrl_alt_del_pressed = true;
+                    kprintf("\nShutting down system...\n");
+                    power_off();
+                    // If power_off() returns (which it shouldn't), just continue
+                    continue;
+                }
+            } else {
+                ctrl_alt_del_pressed = false;
+            }
+
+            // Check for Ctrl+Alt+ESC to reboot
+            if (is_ctrl_alt_esc(&kp)) {
+                if (!ctrl_alt_esc_pressed) {
+                    ctrl_alt_esc_pressed = true;
+                    kprintf("\nRebooting system...\n");
+                    reboot();
+                    // If reboot() returns (which it shouldn't), just continue
+                    continue;
+                }
+            } else {
+                ctrl_alt_esc_pressed = false;
+            }
+
             for (int i = 0; i < 6; i++){
                 char key = kp.keys[i];
                 if (hid_keycode_to_char[(uint8_t)key]){

kernel/kernel_processes/windows/desktop.cpp

@@ -121,17 +121,19 @@ void Desktop::activate_current(){
             kprintf("[LAUNCHER] Wrong executable format. Must be .elf");
             return;
         }
-        kprintf("[LAUNCHER] File path %s",(uintptr_t)entries[index].path);
         file fd;
         open_file(entries[index].path, &fd);
-        char *file = (char*)malloc(fd.size);
-        if (read_file(&fd, file, fd.size) != fd.size){
-            kprintf("[LAUNCHER] Failed to read full elf file");
-            return;
-        } 
-        active_proc = load_elf_file(entries[index].name, file);
+        char *file_data = (char*)malloc(fd.size);
+        size_t bytes_read = read_file(&fd, file_data, fd.size);
+        if (bytes_read != fd.size){
+            free(file_data, fd.size);
+
+            return; // Skip if read failed
+        } else {
+            active_proc = load_elf_file(entries[index].name, file_data);
+        }
+
         if (!active_proc){
-            kprintf("[LAUNCHER] Failed to read ELF file");
             return;
         }
         process_active = true;