feature(install): add system installer and FAT32 formatting utility

src/userland/cli/boredos_install.c

@@ -0,0 +1,459 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include <stdarg.h>
+#include "../libc/syscall.h"
+#include "../libc/stdlib.h"
+#include "../libc/string.h"
+#include "../libc/stdio.h"
+
+static int sc_strcmp(const char *a, const char *b) {
+    while (*a && *a == *b) { a++; b++; }
+    return (unsigned char)*a - (unsigned char)*b;
+}
+
+static int sc_strncpy(char *dst, const char *src, int n) {
+    int i = 0;
+    while (i < n - 1 && src[i]) { dst[i] = src[i]; i++; }
+    dst[i] = 0;
+    return i;
+}
+
+static void read_line_blocking(char *buf, int max_len) {
+    int len = 0;
+    while (1) {
+        char ch;
+        if (sys_tty_read_in(&ch, 1) <= 0) {
+            sleep(10);
+            continue;
+        }
+        if (ch == '\r' || ch == '\n') {
+            sys_write(1, "\n", 1);
+            break;
+        }
+        if (ch == '\b' || ch == 127) {
+            if (len > 0) {
+                len--;
+                sys_write(1, "\b \b", 3);
+            }
+            continue;
+        }
+        if (len < max_len - 1) {
+            buf[len++] = ch;
+            sys_write(1, &ch, 1);
+        }
+    }
+    buf[len] = '\0';
+}
+
+static int copy_file(const char *src, const char *dst) {
+    printf("  [FILE] %s\n", dst);
+    int sfd = sys_open(src, "r");
+    if (sfd < 0) { printf("[ERROR] Cannot open: %s\n", src); return -1; }
+    sys_delete(dst);
+    int dfd = sys_open(dst, "w");
+    if (dfd < 0) { sys_close(sfd); printf("[ERROR] Cannot create: %s\n", dst); return -1; }
+
+    char *buf = (char*)malloc(65536);
+    if (!buf) { sys_close(sfd); sys_close(dfd); printf("[ERROR] Out of memory copying: %s\n", dst); return -1; }
+    int n;
+    while ((n = sys_read(sfd, buf, 65536)) > 0) {
+        if (sys_write_fs(dfd, buf, n) != (uint32_t)n) {
+            sys_close(sfd); sys_close(dfd);
+            free(buf);
+            printf("[ERROR] Write error: %s\n", dst);
+            return -1;
+        }
+    }
+    free(buf);
+    sys_close(sfd);
+    sys_close(dfd);
+    return 0;
+}
+
+static int copy_file_optional(const char *src, const char *dst) {
+    if (!sys_exists(src)) return 0;
+    return copy_file(src, dst);
+}
+
+static int copy_tree(const char *src_dir, const char *dst_dir) {
+    printf("  [DIR ] %s\n", dst_dir);
+    if (sys_mkdir(dst_dir) != 0) {
+    }
+    FAT32_FileInfo entries[64];
+    int n = sys_list(src_dir, entries, 64);
+    for (int i = 0; i < n; i++) {
+        if (entries[i].name[0] == '.' && entries[i].name[1] == '_') continue;
+
+        char src_path[512], dst_path[512];
+        int sl = 0, dl = 0;
+        for (; src_dir[sl]; sl++) src_path[sl] = src_dir[sl];
+        src_path[sl++] = '/';
+        for (int j = 0; entries[i].name[j]; j++) src_path[sl++] = entries[i].name[j];
+        src_path[sl] = 0;
+
+        for (; dst_dir[dl]; dl++) dst_path[dl] = dst_dir[dl];
+        dst_path[dl++] = '/';
+        for (int j = 0; entries[i].name[j]; j++) dst_path[dl++] = entries[i].name[j];
+        dst_path[dl] = 0;
+
+        if (entries[i].is_directory) {
+            if (copy_tree(src_path, dst_path) != 0) return -1;
+        } else {
+            if (copy_file(src_path, dst_path) != 0) return -1;
+        }
+    }
+    return 0;
+}
+
+static void print_usage(void) {
+    printf("boredos_install [OPTIONS] /dev/DEVICE\n");
+    printf("  --uefi              UEFI (GPT + ESP) [default]\n");
+    printf("  --bios              BIOS/MBR\n");
+    printf("  --no-partition      Skip fdisk\n");
+    printf("  --no-format         Skip mkfs\n");
+    printf("  --no-files          Skip file copy\n");
+    printf("  --no-bootloader     Skip bootloader files\n");
+    printf("  --esp-size N        ESP MB (default: 512)\n");
+    printf("  --esp-dev DEV       Explicit ESP device\n");
+    printf("  --root-dev DEV      Explicit root device\n");
+    printf("  -y, --yes           Auto-accept warning\n");
+    printf("  -v, --verbose\n");
+    printf("  -h, --help\n");
+}
+
+static uint64_t get_ticks(void) {
+    return (uint64_t)sys_system(16 /* SYSTEM_CMD_GET_TICKS */, 0, 0, 0, 0);
+}
+
+#define SYS_SERIAL_WRITE 8
+
+static void serial_write_user(const char *str) {
+    __asm__ volatile("mov $8, %%rax; mov %0, %%rdi; syscall" : : "r"(str) : "rax", "rdi");
+}
+
+static void serial_printf(const char *fmt, ...) {
+    char buf[512];
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, args);
+    va_end(args);
+    serial_write_user(buf);
+}
+
+int main(int argc, char **argv) {
+    int is_uefi       = 1;
+    int do_partition  = 1;
+    int do_format     = 1;
+    int do_files      = 1;
+    int do_bootloader = 1;
+    int opt_yes       = 0;
+    int esp_size_mb   = 512;
+    const char *devname      = NULL;
+    const char *esp_dev_arg  = NULL;
+    const char *root_dev_arg = NULL;
+
+    for (int i = 1; i < argc; i++) {
+        if      (sc_strcmp(argv[i], "--uefi") == 0)         is_uefi = 1;
+        else if (sc_strcmp(argv[i], "--bios") == 0)         is_uefi = 0;
+        else if (sc_strcmp(argv[i], "--no-partition") == 0) do_partition = 0;
+        else if (sc_strcmp(argv[i], "--no-format") == 0)    do_format = 0;
+        else if (sc_strcmp(argv[i], "--no-files") == 0)     do_files = 0;
+        else if (sc_strcmp(argv[i], "--no-bootloader") == 0) do_bootloader = 0;
+        else if ((sc_strcmp(argv[i], "-y") == 0 || sc_strcmp(argv[i], "--yes") == 0)) opt_yes = 1;
+        else if (sc_strcmp(argv[i], "--esp-size") == 0 && i + 1 < argc) {
+            esp_size_mb = 0;
+            const char *s = argv[++i];
+            while (*s >= '0' && *s <= '9') esp_size_mb = esp_size_mb * 10 + (*s++ - '0');
+        } else if (sc_strcmp(argv[i], "--esp-dev") == 0 && i + 1 < argc) {
+            esp_dev_arg = argv[++i];
+            if (esp_dev_arg[0]=='/' && esp_dev_arg[1]=='d' && esp_dev_arg[2]=='e' && esp_dev_arg[3]=='v' && esp_dev_arg[4]=='/')
+                esp_dev_arg += 5;
+        } else if (sc_strcmp(argv[i], "--root-dev") == 0 && i + 1 < argc) {
+            root_dev_arg = argv[++i];
+            if (root_dev_arg[0]=='/' && root_dev_arg[1]=='d' && root_dev_arg[2]=='e' && root_dev_arg[3]=='v' && root_dev_arg[4]=='/')
+                root_dev_arg += 5;
+        } else if (sc_strcmp(argv[i], "-h") == 0 || sc_strcmp(argv[i], "--help") == 0) {
+            print_usage(); return 0;
+        } else if (argv[i][0] != '-') {
+            devname = argv[i];
+            if (devname[0]=='/' && devname[1]=='d' && devname[2]=='e' && devname[3]=='v' && devname[4]=='/')
+                devname += 5;
+        }
+    }
+
+    if (!devname) { print_usage(); return 1; }
+
+    /* --- Step 0: Prerequisites --- */
+    if (!sys_exists("/boot/boredos.elf")) {
+        printf("[ERROR] /boot/boredos.elf not found. Cannot install.\n");
+        return 1;
+    }
+    if (is_uefi && !sys_exists("/boot/BOOTX64.EFI")) {
+        printf("[ERROR] /boot/BOOTX64.EFI not found. Cannot install UEFI.\n");
+        return 1;
+    }
+
+    disk_info_t disk_info;
+    {
+        int found = 0;
+        int n = sys_disk_get_count();
+        for (int i = 0; i < n; i++) {
+            if (sys_disk_get_info(i, &disk_info) != 0) continue;
+            if (!disk_info.is_partition && sc_strcmp(disk_info.devname, devname) == 0) { found = 1; break; }
+        }
+        if (!found) { printf("[ERROR] Device not found: /dev/%s\n", devname); return 1; }
+    }
+
+    if (disk_info.total_sectors < MIN_INSTALL_SECTORS) {
+        printf("[ERROR] Disk too small: %u sectors. Minimum is 1 GB (%u sectors).\n",
+               disk_info.total_sectors, MIN_INSTALL_SECTORS);
+        return 1;
+    }
+
+    if (do_partition || do_format) {
+        uint32_t mb = disk_info.total_sectors / 2048;
+        printf("╔══════════════════════════════════════════════════════╗\n");
+        printf("║  WARNING: ALL DATA on /dev/%s will be ERASED.      ║\n", devname);
+        printf("║  Disk: %u sectors (%u MB)                           ║\n", disk_info.total_sectors, mb);
+        printf("║  This is IRREVERSIBLE.                               ║\n");
+        printf("╚══════════════════════════════════════════════════════╝\n");
+        if (opt_yes) {
+            printf("Auto-accepted (--yes).\n");
+        } else {
+            printf("Proceed with installation? (y/n): ");
+            char resp[8];
+            read_line_blocking(resp, 8);
+            if (resp[0] != 'y' && resp[0] != 'Y') {
+                printf("Aborted.\n");
+                return 0;
+            }
+        }
+    }
+
+    sys_mkdir("/mnt");
+    sys_mkdir("/mnt/boot");
+    sys_mkdir("/mnt/esp");
+
+    if (do_partition) {
+        char fdisk_args[128];
+        int ai = 0;
+        const char *cmd = "--script ";
+        for (; *cmd; cmd++) fdisk_args[ai++] = *cmd;
+        if (is_uefi) {
+            const char *u = "--uefi --esp-size ";
+            for (; *u; u++) fdisk_args[ai++] = *u;
+            char num[16]; int ni = 0;
+            int v = esp_size_mb;
+            if (v == 0) { num[ni++] = '0'; } else {
+                char tmp[16]; int ti = 0;
+                while (v > 0) { tmp[ti++] = '0' + (v % 10); v /= 10; }
+                for (int j = ti - 1; j >= 0; j--) num[ni++] = tmp[j];
+            }
+            for (int j = 0; j < ni; j++) fdisk_args[ai++] = num[j];
+            fdisk_args[ai++] = ' ';
+        } else {
+            const char *b = "--mbr "; for (; *b; b++) fdisk_args[ai++] = *b;
+        }
+        fdisk_args[ai++] = '/'; fdisk_args[ai++] = 'd'; fdisk_args[ai++] = 'e';
+        fdisk_args[ai++] = 'v'; fdisk_args[ai++] = '/';
+        for (int j = 0; devname[j]; j++) fdisk_args[ai++] = devname[j];
+        fdisk_args[ai] = 0;
+
+        int pid = sys_spawn("/bin/fdisk.elf", fdisk_args, SPAWN_FLAG_INHERIT_TTY, 0);
+        if (pid < 0) { printf("[ERROR] Failed to run fdisk.\n"); return 1; }
+        int status = 0;
+        sys_waitpid(pid, &status, 0);
+        if (status != 0) { printf("[ERROR] fdisk failed.\n"); return 1; }
+
+        sys_disk_rescan(devname);
+    }
+
+    char esp_dev[16]  = {0};
+    char root_dev[16] = {0};
+
+    if (esp_dev_arg)  sc_strncpy(esp_dev,  esp_dev_arg,  16);
+    if (root_dev_arg) sc_strncpy(root_dev, root_dev_arg, 16);
+
+    if (!esp_dev[0] || !root_dev[0]) {
+        int n = sys_disk_get_count();
+        for (int i = 0; i < n; i++) {
+            disk_info_t d;
+            if (sys_disk_get_info(i, &d) != 0) continue;
+            if (!d.is_partition) continue;
+            int match = 1;
+            for (int j = 0; devname[j]; j++) {
+                if (d.devname[j] != devname[j]) { match = 0; break; }
+            }
+            if (!match) continue;
+            if (is_uefi && d.is_esp && !esp_dev[0])
+                sc_strncpy(esp_dev, d.devname, 16);
+            else if (!d.is_esp && !root_dev[0]) {
+                if (d.is_fat32 || do_format)
+                    sc_strncpy(root_dev, d.devname, 16);
+            }
+        }
+    }
+
+    if (!root_dev[0]) { printf("[ERROR] Could not find root partition.\n"); return 1; }
+    if (is_uefi && !esp_dev[0]) { printf("[ERROR] Could not find ESP.\n"); return 1; }
+
+    if (do_format) {
+        if (is_uefi) {
+            if (sys_disk_mkfs_fat32(esp_dev, "EFI") != 0) {
+                printf("[ERROR] Failed to format ESP.\n"); return 1;
+            }
+        }
+        if (sys_disk_mkfs_fat32(root_dev, "BOREDOS") != 0) {
+            printf("[ERROR] Failed to format root partition.\n"); return 1;
+        }
+    }
+
+    if (sys_disk_mount(root_dev, "/mnt") != 0) {
+        printf("[ERROR] Cannot mount /dev/%s to /mnt\n", root_dev);
+        return -1;
+    }
+
+    if (is_uefi) {
+        sys_mkdir("/mnt/boot");
+        if (sys_disk_mount(esp_dev, "/mnt/boot") != 0) {
+            printf("[ERROR] Cannot mount /dev/%s to /mnt/boot\n", esp_dev);
+            return -1;
+        }
+    } else {
+        // In BIOS mode, /boot is just a directory on the root partition
+        sys_mkdir("/mnt/boot");
+    }
+
+    if (sys_mkdir("/mnt/Library") == 0 || sys_exists("/mnt/Library")) {
+        int mfd = sys_open("/mnt/Library/.boredos_root", "w");
+        if (mfd >= 0) sys_close(mfd);
+    }
+
+    if (do_files) {
+        serial_printf("Copying system files...\n");
+        uint64_t t0 = get_ticks();
+        if (copy_tree("/bin", "/mnt/bin") != 0)          { serial_printf("[ERROR] copy /bin failed\n"); return 1; }
+        if (copy_tree("/Library", "/mnt/Library") != 0)  { serial_printf("[ERROR] copy /Library failed\n"); return 1; }
+        if (copy_tree("/docs", "/mnt/docs") != 0)        { serial_printf("[ERROR] copy /docs failed\n"); return 1; }
+        if (copy_tree("/root", "/mnt/root") != 0)        { serial_printf("[ERROR] copy /root failed\n"); return 1; }
+        
+        serial_printf("Copying kernel and initrd...\n");
+        if (copy_file("/boot/boredos.elf", "/mnt/boot/boredos.elf") != 0) {
+            serial_printf("[ERROR] Failed to copy kernel to ESP\n");
+            return 1;
+        }
+        if (sys_exists("/boot/initrd.tar")) {
+            if (copy_file("/boot/initrd.tar", "/mnt/boot/initrd.tar") != 0) {
+                printf("[ERROR] Failed to copy /boot/initrd.tar to ESP\n");
+                return 1;
+            }
+        } else if (sys_exists("/initrd.tar")) {
+            if (copy_file("/initrd.tar", "/mnt/boot/initrd.tar") != 0) {
+                serial_printf("[ERROR] Failed to copy /initrd.tar to ESP\n");
+                return 1;
+            }
+        } else {
+            serial_printf("[WARNING] initrd.tar not found in live system (checked /boot/ and /)!\n");
+        }
+        
+        copy_file_optional("README.md", "/mnt/README.md");
+        copy_file_optional("LICENSE", "/mnt/LICENSE");
+        uint64_t t1 = get_ticks();
+        serial_printf("Files copied (%llu ticks).\n", (unsigned long long)(t1 - t0));
+    }
+
+
+    if (do_bootloader) {
+        if (is_uefi) {
+            if (sys_mkdir("/mnt/boot/EFI") != 0 && !sys_exists("/mnt/boot/EFI")) {
+                printf("[ERROR] Failed to create /mnt/boot/EFI\n");
+                return 1;
+            }
+            if (sys_mkdir("/mnt/boot/EFI/BOOT") != 0 && !sys_exists("/mnt/boot/EFI/BOOT")) {
+                printf("[ERROR] Failed to create /mnt/boot/EFI/BOOT\n");
+                return 1;
+            }
+            if (copy_file("/boot/BOOTX64.EFI", "/mnt/boot/EFI/BOOT/BOOTX64.EFI") != 0) {
+                printf("[ERROR] Failed to copy BOOTX64.EFI\n");
+                return 1;
+            }
+            copy_file_optional("/boot/BOOTIA32.EFI", "/mnt/boot/EFI/BOOT/BOOTIA32.EFI");
+
+            int fd = sys_open("/mnt/boot/limine.conf", "w");
+            if (fd >= 0) {
+                char cfg[512];
+                int len = snprintf(cfg, sizeof(cfg),
+                    "timeout: 3\n"
+                    "verbose: yes\n"
+                    "\n"
+                    "/BoredOS\n"
+                    "    protocol: limine\n"
+                    "    path: boot():/boredos.elf\n"
+                    "    cmdline: -v root=/dev/%s --disk --accept-tos\n"
+                    "    module_path: boot():/initrd.tar\n",
+                    root_dev);
+                if (len > 0) sys_write_fs(fd, cfg, len);
+                sys_close(fd);
+            }
+        } else {
+            copy_file_optional("/boot/limine-bios.sys", "/mnt/limine-bios.sys");
+
+            int fd = sys_open("/mnt/limine.conf", "w");
+            if (fd >= 0) {
+                char cfg[512];
+                int len = snprintf(cfg, sizeof(cfg),
+                    "timeout: 3\n"
+                    "verbose: yes\n"
+                    "\n"
+                    "/BoredOS\n"
+                    "    protocol: limine\n"
+                    "    root: boot()\n"
+                    "    path: /boredos.elf\n"
+                    "    cmdline: -v root=/dev/%s --disk --accept-tos\n"
+                    "    module_path: /initrd.tar\n",
+                    root_dev);
+                if (len > 0) sys_write_fs(fd, cfg, len);
+                sys_close(fd);
+            }
+
+            printf("[NOTICE] BIOS bootstrap requires host-side:  limine bios-install /dev/%s\n", devname);
+            printf("         limine-bios.sys has been copied to the root of the target partition.\n");
+        }
+    }
+
+    if (is_uefi) {
+        printf("Verifying BOOTX64.EFI...\n");
+        int vfd = sys_open("/mnt/boot/EFI/BOOT/BOOTX64.EFI", "r");
+        if (vfd >= 0) {
+            char magic[2];
+            if (sys_read(vfd, magic, 2) == 2) {
+                if (magic[0] == 'M' && magic[1] == 'Z') {
+                    printf("[OK] BOOTX64.EFI verification successful (MZ found)\n");
+                } else {
+                    printf("[ERROR] BOOTX64.EFI verification failed: Invalid magic bytes %02x %02x\n", magic[0], magic[1]);
+                }
+            } else {
+                printf("[ERROR] BOOTX64.EFI verification failed: Could not read 2 bytes\n");
+            }
+            sys_close(vfd);
+        } else {
+            printf("[ERROR] BOOTX64.EFI verification failed: Could not open file for verification\n");
+        }
+        sys_disk_sync("/mnt/boot");
+        sys_disk_umount("/mnt/boot");
+    }
+    sys_disk_sync("/mnt");
+    sys_disk_umount("/mnt");
+    
+    // Sync physical disk
+    sys_disk_sync(devname);
+
+
+    printf("\nInstallation complete.\n");
+    printf("  Root partition:  /dev/%s\n", root_dev);
+    if (is_uefi) printf("  ESP:             /dev/%s\n", esp_dev);
+    printf("  Mode:            %s\n", is_uefi ? "UEFI" : "BIOS");
+    printf("Reboot and select the target disk to boot BoredOS.\n");
+    return 0;
+}

src/userland/cli/fdisk.c

@@ -0,0 +1,366 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include "../libc/syscall.h"
+#include "../libc/stdlib.h"
+#include "../libc/string.h"
+#include "../libc/stdio.h"
+
+#define MAX_PARTS 4
+#define SECTOR_SIZE_BYTES 512ULL
+#define ONE_MB (1024ULL * 1024ULL)
+#define ONE_GB (1024ULL * 1024ULL * 1024ULL)
+
+static void print_usage(void) {
+    printf("fdisk [OPTIONS] /dev/DEVICE\n");
+    printf("  -p, --print     Print partition table and exit\n");
+    printf("  -s, --script    Non-interactive auto-partition\n");
+    printf("      --mbr       Use MBR instead of GPT\n");
+    printf("      --uefi      Include ESP (default with GPT)\n");
+    printf("      --esp-size N  ESP size (b/mb/gb, default: 512mb)\n");
+    printf("  -h, --help\n");
+}
+
+static int sc_strcmp(const char *a, const char *b) {
+    while (*a && *a == *b) { a++; b++; }
+    return (unsigned char)*a - (unsigned char)*b;
+}
+
+static int sc_atoi(const char *s) {
+    int n = 0;
+    while (*s >= '0' && *s <= '9') n = n * 10 + (*s++ - '0');
+    return n;
+}
+
+static char sc_tolower(char ch) {
+    if (ch >= 'A' && ch <= 'Z') return (char)(ch + 32);
+    return ch;
+}
+
+static uint64_t sc_parse_size_bytes(const char *s) {
+    uint64_t n = 0;
+    int has_digit = 0;
+
+    while (*s == ' ' || *s == '\t') s++;
+    if (*s == '+') s++;
+
+    while (*s >= '0' && *s <= '9') {
+        has_digit = 1;
+        n = n * 10ULL + (uint64_t)(*s - '0');
+        s++;
+    }
+
+    if (!has_digit) return 0;
+
+    while (*s == ' ' || *s == '\t') s++;
+
+    if (*s == '\0') return n * ONE_MB;
+
+    {
+        char c1 = sc_tolower(*s);
+        char c2 = sc_tolower(*(s + 1));
+
+        if (c1 == 'g' && c2 == 'b') return n * ONE_GB;
+        if (c1 == 'm' && c2 == 'b') return n * ONE_MB;
+        if (c1 == 'b') return n;
+        if (c1 == 'g' && c2 == '\0') return n * ONE_GB;
+        if (c1 == 'm' && c2 == '\0') return n * ONE_MB;
+    }
+
+    return n * ONE_MB;
+}
+
+static uint32_t sc_bytes_to_sectors_ceil(uint64_t bytes) {
+    if (bytes == 0) return 0;
+    return (uint32_t)((bytes + SECTOR_SIZE_BYTES - 1ULL) / SECTOR_SIZE_BYTES);
+}
+
+static void sc_format_size(uint64_t bytes, char *out, size_t out_len) {
+    if (bytes >= ONE_GB) {
+        unsigned long long whole = (unsigned long long)(bytes / ONE_GB);
+        uint64_t rem = bytes % ONE_GB;
+        unsigned long long frac = (unsigned long long)((rem * 100ULL + (ONE_GB / 2)) / ONE_GB);
+        if (frac >= 100ULL) { whole++; frac = 0; }
+        snprintf(out, out_len, "%llu.%02llugb", whole, frac);
+    } else if (bytes >= ONE_MB) {
+        unsigned long long whole = (unsigned long long)(bytes / ONE_MB);
+        uint64_t rem = bytes % ONE_MB;
+        unsigned long long frac = (unsigned long long)((rem * 100ULL + (ONE_MB / 2)) / ONE_MB);
+        if (frac >= 100ULL) { whole++; frac = 0; }
+        snprintf(out, out_len, "%llu.%02llumb", whole, frac);
+    } else {
+        snprintf(out, out_len, "%llub", (unsigned long long)bytes);
+    }
+}
+
+static void read_line_blocking(char *buf, int max_len) {
+    int len = 0;
+    while (1) {
+        char ch;
+        if (sys_tty_read_in(&ch, 1) <= 0) {
+            sleep(10);
+            continue;
+        }
+        if (ch == '\r' || ch == '\n') {
+            sys_write(1, "\n", 1);
+            break;
+        }
+        if (ch == '\b' || ch == 127) {
+            if (len > 0) {
+                len--;
+                sys_write(1, "\b \b", 3);
+            }
+            continue;
+        }
+        if (len < max_len - 1) {
+            buf[len++] = ch;
+            sys_write(1, &ch, 1);
+        }
+    }
+    buf[len] = '\0';
+}
+
+static void print_partition_table(const char *devname) {
+    int n = sys_disk_get_count();
+    int found = 0;
+    printf("Partition table for /dev/%s:\n", devname);
+    printf("%-10s %-12s %-12s %-10s %-6s %s\n",
+           "Device", "Start", "End", "Size", "ESP", "FAT32");
+    for (int i = 0; i < n; i++) {
+        disk_info_t d;
+        if (sys_disk_get_info(i, &d) != 0) continue;
+        if (!d.is_partition) continue;
+        char parent[16];
+        int len = 0;
+        while (devname[len]) len++;
+        int match = 1;
+        for (int j = 0; j < len; j++) {
+            if (d.devname[j] != devname[j]) { match = 0; break; }
+        }
+        if (!match) continue;
+        {
+            char start_buf[24];
+            char end_buf[24];
+            char size_buf[24];
+            uint64_t start_bytes = (uint64_t)d.lba_offset * SECTOR_SIZE_BYTES;
+            uint64_t end_bytes = (uint64_t)(d.lba_offset + d.total_sectors - 1) * SECTOR_SIZE_BYTES;
+            uint64_t size_bytes = (uint64_t)d.total_sectors * SECTOR_SIZE_BYTES;
+            sc_format_size(start_bytes, start_buf, sizeof(start_buf));
+            sc_format_size(end_bytes, end_buf, sizeof(end_buf));
+            sc_format_size(size_bytes, size_buf, sizeof(size_buf));
+            printf("/dev/%-5s %-12s %-12s %-10s %-6s %s\n",
+                   d.devname,
+                   start_buf,
+                   end_buf,
+                   size_buf,
+                   d.is_esp ? "yes" : "no",
+                   d.is_fat32 ? "yes" : "no");
+        }
+        found++;
+    }
+    if (!found) printf("  (no partitions)\n");
+}
+
+int main(int argc, char **argv) {
+    int opt_print   = 0;
+    int opt_script  = 0;
+    int opt_mbr     = 0;
+    int opt_uefi    = 1;
+    uint64_t esp_size_bytes = 512ULL * ONE_MB;
+    const char *devname = NULL;
+
+    for (int i = 1; i < argc; i++) {
+        if (sc_strcmp(argv[i], "-p") == 0 || sc_strcmp(argv[i], "--print") == 0)
+            opt_print = 1;
+        else if (sc_strcmp(argv[i], "-s") == 0 || sc_strcmp(argv[i], "--script") == 0)
+            opt_script = 1;
+        else if (sc_strcmp(argv[i], "--mbr") == 0) { opt_mbr = 1; opt_uefi = 0; }
+        else if (sc_strcmp(argv[i], "--uefi") == 0) opt_uefi = 1;
+        else if (sc_strcmp(argv[i], "--esp-size") == 0 && i + 1 < argc) {
+            uint64_t parsed = sc_parse_size_bytes(argv[++i]);
+            if (parsed > 0) esp_size_bytes = parsed;
+        }
+        else if (sc_strcmp(argv[i], "-h") == 0 || sc_strcmp(argv[i], "--help") == 0) {
+            print_usage();
+            return 0;
+        } else if (argv[i][0] != '-') {
+            devname = argv[i];
+            if (devname[0]=='/' && devname[1]=='d' && devname[2]=='e' && devname[3]=='v' && devname[4]=='/')
+                devname += 5;
+        }
+    }
+
+    if (!devname) { print_usage(); return 1; }
+
+    if (opt_print) {
+        print_partition_table(devname);
+        return 0;
+    }
+
+    if (!opt_script) {
+        disk_info_t disk;
+        int found = -1;
+        int n = sys_disk_get_count();
+        for (int i = 0; i < n; i++) {
+            disk_info_t d;
+            if (sys_disk_get_info(i, &d) != 0) continue;
+            if (!d.is_partition && sc_strcmp(d.devname, devname) == 0) {
+                disk = d;
+                found = i;
+                break;
+            }
+        }
+        if (found < 0) { printf("[ERROR] Device not found: /dev/%s\n", devname); return 1; }
+
+        {
+            char disk_size[24];
+            sc_format_size((uint64_t)disk.total_sectors * SECTOR_SIZE_BYTES, disk_size, sizeof(disk_size));
+            printf("fdisk /dev/%s  (%s)\n", devname, disk_size);
+        }
+        printf("Commands: p (print), n (new), d NUM (delete), w (write), q (quit)\n");
+        printf("Sizes accept b/mb/gb (default unit: mb).\n");
+
+        partition_spec_t parts[MAX_PARTS];
+        int part_count = 0;
+        char line[128];
+
+        while (1) {
+            printf("fdisk> ");
+            read_line_blocking(line, 128);
+            int len = 0;
+            while(line[len]) len++;
+            if (len == 0) continue;
+
+            if (line[0] == 'q') break;
+            if (line[0] == 'p') {
+                for (int i = 0; i < part_count; i++) {
+                    char start_buf[24];
+                    char size_buf[24];
+                    sc_format_size((uint64_t)parts[i].lba_start * SECTOR_SIZE_BYTES,
+                                   start_buf, sizeof(start_buf));
+                    sc_format_size((uint64_t)parts[i].sector_count * SECTOR_SIZE_BYTES,
+                                   size_buf, sizeof(size_buf));
+                    printf("  %d: start=%s size=%s esp=%s\n", i + 1,
+                           start_buf, size_buf,
+                           (parts[i].flags & PART_FLAG_ESP) ? "yes" : "no");
+                }
+                continue;
+            }
+            if (line[0] == 'n') {
+                if (part_count >= MAX_PARTS) { printf("Max partitions reached\n"); continue; }
+                uint32_t start = 2048;
+                if (part_count > 0)
+                    start = parts[part_count-1].lba_start + parts[part_count-1].sector_count;
+                if (start % 2048) start = ((start + 2047) / 2048) * 2048;
+                {
+                    char start_buf[24];
+                    sc_format_size((uint64_t)start * SECTOR_SIZE_BYTES, start_buf, sizeof(start_buf));
+                    printf("First offset [%s]: ", start_buf);
+                }
+                read_line_blocking(line, 64);
+                len = 0; while(line[len]) len++;
+                if (len > 0) start = sc_bytes_to_sectors_ceil(sc_parse_size_bytes(line));
+                if (start % 2048) start = ((start + 2047) / 2048) * 2048;
+
+                uint32_t last_usable = opt_mbr ? (disk.total_sectors - 1) : (disk.total_sectors - 34);
+                uint32_t remaining = (last_usable >= start) ? (last_usable - start + 1) : 0;
+                {
+                    char rem_buf[24];
+                    sc_format_size((uint64_t)remaining * SECTOR_SIZE_BYTES, rem_buf, sizeof(rem_buf));
+                    printf("Size [%s]: ", rem_buf);
+                }
+                read_line_blocking(line, 64);
+                len = 0; while(line[len]) len++;
+                uint32_t size = remaining;
+                if (len > 0) size = sc_bytes_to_sectors_ceil(sc_parse_size_bytes(line));
+
+                parts[part_count].lba_start    = start;
+                parts[part_count].sector_count = size;
+                parts[part_count].part_type    = 0;
+                parts[part_count].flags        = 0;
+                parts[part_count].label[0]     = 0;
+                part_count++;
+                printf("Partition %d added\n", part_count);
+                continue;
+            }
+            if (line[0] == 'd') {
+                int idx = sc_atoi(line + 1) - 1;
+                if (idx < 0 || idx >= part_count) { printf("Invalid partition\n"); continue; }
+                for (int i = idx; i < part_count - 1; i++) parts[i] = parts[i+1];
+                part_count--;
+                printf("Partition %d deleted\n", idx + 1);
+                continue;
+            }
+            if (line[0] == 'w') {
+                int ret;
+                if (opt_mbr)
+                    ret = sys_disk_write_mbr(devname, parts, part_count);
+                else
+                    ret = sys_disk_write_gpt(devname, parts, part_count);
+                if (ret == 0) printf("Partition table written.\n");
+                else printf("[ERROR] Failed to write partition table.\n");
+                break;
+            }
+        }
+        return 0;
+    }
+
+    disk_info_t disk;
+    int found = 0;
+    {
+        int n = sys_disk_get_count();
+        for (int i = 0; i < n; i++) {
+            disk_info_t d;
+            if (sys_disk_get_info(i, &d) != 0) continue;
+            if (!d.is_partition && sc_strcmp(d.devname, devname) == 0) {
+                disk = d;
+                found = 1;
+                break;
+            }
+        }
+    }
+    if (!found) { printf("[ERROR] Device not found: /dev/%s\n", devname); return 1; }
+
+    partition_spec_t parts[2];
+    int count = 0;
+    int ret;
+
+    if (!opt_mbr && opt_uefi) {
+        uint32_t esp_sectors = sc_bytes_to_sectors_ceil(esp_size_bytes);
+        if (esp_sectors % 2048) esp_sectors = ((esp_sectors + 2047) / 2048) * 2048;
+        parts[0].lba_start    = 2048;
+        parts[0].sector_count = esp_sectors;
+        parts[0].part_type    = 0;
+        parts[0].flags        = PART_FLAG_ESP;
+        parts[0].label[0]='E'; parts[0].label[1]='F'; parts[0].label[2]='I';
+        parts[0].label[3]=' '; parts[0].label[4]='S'; parts[0].label[5]='y';
+        parts[0].label[6]='s'; parts[0].label[7]='t'; parts[0].label[8]='e';
+        parts[0].label[9]='m'; parts[0].label[10]=0;
+
+        uint32_t root_start = 2048 + esp_sectors;
+        if (root_start % 2048) root_start = ((root_start + 2047) / 2048) * 2048;
+        parts[1].lba_start    = root_start;
+        parts[1].sector_count = disk.total_sectors - root_start - 34;
+        parts[1].part_type    = 0;
+        parts[1].flags        = 0;
+        parts[1].label[0]='B'; parts[1].label[1]='o'; parts[1].label[2]='r';
+        parts[1].label[3]='e'; parts[1].label[4]='d'; parts[1].label[5]='O';
+        parts[1].label[6]='S'; parts[1].label[7]=0;
+        count = 2;
+        ret = sys_disk_write_gpt(devname, parts, count);
+    } else {
+        parts[0].lba_start    = 2048;
+        parts[0].sector_count = disk.total_sectors - 2048;
+        parts[0].part_type    = 0;
+        parts[0].flags        = 0;
+        parts[0].label[0]='B'; parts[0].label[1]='o'; parts[0].label[2]='r';
+        parts[0].label[3]='e'; parts[0].label[4]='d'; parts[0].label[5]='O';
+        parts[0].label[6]='S'; parts[0].label[7]=0;
+        count = 1;
+        ret = sys_disk_write_mbr(devname, parts, count);
+    }
+
+    if (ret != 0) { printf("[ERROR] Partition write failed.\n"); return 1; }
+    printf("Partition table written to /dev/%s.\n", devname);
+    return 0;
+}

src/userland/cli/mkfs_fat.c

@@ -0,0 +1,66 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include "../libc/syscall.h"
+#include "../libc/stdlib.h"
+#include "../libc/string.h"
+#include "../libc/stdio.h"
+
+static int sc_strcmp(const char *a, const char *b) {
+    while (*a && *a == *b) { a++; b++; }
+    return (unsigned char)*a - (unsigned char)*b;
+}
+
+int main(int argc, char **argv) {
+    const char *devname = NULL;
+    const char *label   = "BOREDOS";
+    int fat_type = 32;
+
+    for (int i = 1; i < argc; i++) {
+        if (sc_strcmp(argv[i], "-F") == 0 && i + 1 < argc) {
+            fat_type = 0;
+            const char *s = argv[++i];
+            while (*s >= '0' && *s <= '9') fat_type = fat_type * 10 + (*s++ - '0');
+        } else if (sc_strcmp(argv[i], "-n") == 0 && i + 1 < argc) {
+            label = argv[++i];
+        } else if (sc_strcmp(argv[i], "-h") == 0 || sc_strcmp(argv[i], "--help") == 0) {
+            printf("mkfs.fat [OPTIONS] /dev/DEVICE\n");
+            printf("  -F 32       FAT type (32 only)\n");
+            printf("  -n LABEL    Volume label (max 11 chars, default: BOREDOS)\n");
+            return 0;
+        } else if (argv[i][0] != '-') {
+            devname = argv[i];
+            if (devname[0]=='/' && devname[1]=='d' && devname[2]=='e' && devname[3]=='v' && devname[4]=='/')
+                devname += 5;
+        }
+    }
+
+    if (!devname) {
+        printf("Usage: mkfs.fat -F 32 [-n LABEL] /dev/DEVICE\n");
+        return 1;
+    }
+    if (fat_type != 32) {
+        printf("[ERROR] Only FAT32 (-F 32) is supported.\n");
+        return 1;
+    }
+
+    disk_info_t d;
+    int found = 0;
+    int n = sys_disk_get_count();
+    for (int i = 0; i < n; i++) {
+        if (sys_disk_get_info(i, &d) != 0) continue;
+        if (sc_strcmp(d.devname, devname) == 0) { found = 1; break; }
+    }
+    if (!found) { printf("[ERROR] Device not found: /dev/%s\n", devname); return 1; }
+    if (!d.is_partition) { printf("[ERROR] /dev/%s is a whole disk, not a partition.\n", devname); return 1; }
+    if (d.total_sectors < 65536) {
+        printf("[ERROR] Partition too small (< 32 MB) for FAT32.\n");
+        return 1;
+    }
+
+    printf("Formatting /dev/%s as FAT32 (label: %s)...\n", devname, label);
+    int ret = sys_disk_mkfs_fat32(devname, label);
+    if (ret != 0) { printf("[ERROR] Format failed.\n"); return 1; }
+    printf("Done.\n");
+    return 0;
+}