Add UEFI boot support with GRUB bootloader

Co-authored-by: johndoe6345789 <224850594+johndoe6345789@users.noreply.github.com>

Dockerfile.image

@@ -1,5 +1,5 @@
-# Dockerfile for building SparkOS bootable image
-# This creates a .img file that can be written to USB drives
+# Dockerfile for building UEFI-bootable SparkOS image
+# Creates a .img file with GPT partition table, ESP, and GRUB
 
 FROM ubuntu:22.04 AS image-builder
 
@@ -10,13 +10,14 @@ RUN apt-get update && \
     make \
     dosfstools \
     mtools \
-    xorriso \
-    isolinux \
-    syslinux \
-    syslinux-common \
     e2fsprogs \
     parted \
-    kpartx \
+    gdisk \
+    grub-efi-amd64-bin \
+    grub-common \
+    wget \
+    busybox-static \
+    kmod \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /build
@@ -31,58 +32,149 @@ COPY rootfs/ ./rootfs/
 # Build the init binary
 RUN make init
 
-# Create the bootable image
-# We'll use a simpler approach that works in Docker
-RUN mkdir -p /output && \
-    echo "Building minimal bootable image..." && \
-    # Create a minimal image with just the init system for now
-    # This is a placeholder - the actual bootloader requires a kernel
-    dd if=/dev/zero of=/output/sparkos.img bs=1M count=512 && \
-    mkfs.ext4 -L SparkOS /output/sparkos.img && \
-    mkdir -p /mnt/img && \
-    mount -o loop /output/sparkos.img /mnt/img && \
-    mkdir -p /mnt/img/{bin,sbin,etc,proc,sys,dev,tmp,usr/{bin,sbin,lib},var/{log,run},root,home/spark,boot} && \
-    cp init /mnt/img/sbin/init && \
-    chmod 755 /mnt/img/sbin/init && \
-    # Create basic config files
-    echo "sparkos" > /mnt/img/etc/hostname && \
-    echo "127.0.0.1   localhost" > /mnt/img/etc/hosts && \
-    echo "127.0.1.1   sparkos" >> /mnt/img/etc/hosts && \
-    echo "root:x:0:0:root:/root:/bin/sh" > /mnt/img/etc/passwd && \
-    echo "spark:x:1000:1000:SparkOS User:/home/spark:/bin/sh" >> /mnt/img/etc/passwd && \
-    echo "root:x:0:" > /mnt/img/etc/group && \
-    echo "spark:x:1000:" >> /mnt/img/etc/group && \
+# Download a minimal Linux kernel (using Ubuntu's kernel for now)
+RUN mkdir -p /kernel && \
+    apt-get update && \
+    apt-get download linux-image-generic && \
+    dpkg -x linux-image-*.deb /kernel && \
+    rm -rf /var/lib/apt/lists/* linux-image-*.deb
+
+# Create UEFI-bootable image with GPT partition table
+RUN mkdir -p /output /mnt/esp /mnt/root && \
+    echo "=== Creating UEFI-bootable SparkOS image with GRUB ===" && \
+    # Create 1GB disk image (larger for kernel + bootloader)
+    dd if=/dev/zero of=/output/sparkos.img bs=1M count=1024 && \
+    \
+    # Create GPT partition table
+    echo "Creating GPT partition table..." && \
+    parted -s /output/sparkos.img mklabel gpt && \
+    \
+    # Create EFI System Partition (ESP) - 200MB, FAT32
+    echo "Creating EFI System Partition..." && \
+    parted -s /output/sparkos.img mkpart ESP fat32 1MiB 201MiB && \
+    parted -s /output/sparkos.img set 1 esp on && \
+    \
+    # Create root partition - remaining space, ext4
+    echo "Creating root partition..." && \
+    parted -s /output/sparkos.img mkpart primary ext4 201MiB 100% && \
+    \
+    # Set up loop device for the image
+    LOOP_DEV=$(losetup -f) && \
+    losetup -P $LOOP_DEV /output/sparkos.img && \
+    \
+    # Wait for partition devices
+    sleep 1 && \
+    \
+    # Format partitions
+    echo "Formatting EFI System Partition (FAT32)..." && \
+    mkfs.vfat -F 32 -n "SPARKOSEFI" ${LOOP_DEV}p1 && \
+    \
+    echo "Formatting root partition (ext4)..." && \
+    mkfs.ext4 -L "SparkOS" ${LOOP_DEV}p2 && \
+    \
+    # Mount ESP
+    echo "Mounting partitions..." && \
+    mount ${LOOP_DEV}p1 /mnt/esp && \
+    mount ${LOOP_DEV}p2 /mnt/root && \
+    \
+    # Install GRUB to ESP
+    echo "Installing GRUB bootloader..." && \
+    mkdir -p /mnt/esp/EFI/BOOT && \
+    \
+    # Copy GRUB EFI binary
+    cp /usr/lib/grub/x86_64-efi/monolithic/grubx64.efi /mnt/esp/EFI/BOOT/BOOTX64.EFI 2>/dev/null || \
+    grub-mkstandalone \
+        --format=x86_64-efi \
+        --output=/mnt/esp/EFI/BOOT/BOOTX64.EFI \
+        --locales="" \
+        --fonts="" \
+        "boot/grub/grub.cfg=/tmp/grub-early.cfg" && \
+    \
+    # Find the kernel
+    KERNEL_PATH=$(find /kernel/boot -name "vmlinuz-*" | head -1) && \
+    KERNEL_VERSION=$(basename $KERNEL_PATH | sed 's/vmlinuz-//') && \
+    INITRD_PATH=$(find /kernel/boot -name "initrd.img-*" | head -1) && \
+    \
+    # Copy kernel and initrd to ESP
+    echo "Installing kernel..." && \
+    mkdir -p /mnt/esp/boot && \
+    cp $KERNEL_PATH /mnt/esp/boot/vmlinuz && \
+    if [ -f "$INITRD_PATH" ]; then cp $INITRD_PATH /mnt/esp/boot/initrd.img; fi && \
+    \
+    # Create GRUB configuration
+    mkdir -p /mnt/esp/boot/grub && \
+    cat > /mnt/esp/boot/grub/grub.cfg << 'GRUB_EOF' && \
+set timeout=3
+set default=0
+
+menuentry "SparkOS" {
+    linux /boot/vmlinuz root=LABEL=SparkOS rw init=/sbin/init console=tty1 quiet
+}
+GRUB_EOF
+    \
+    # Set up root filesystem
+    echo "Setting up root filesystem..." && \
+    mkdir -p /mnt/root/{bin,sbin,etc,proc,sys,dev,tmp,usr/{bin,sbin,lib,lib64},var/{log,run},root,home/spark,boot} && \
+    \
+    # Install SparkOS init
+    cp /build/init /mnt/root/sbin/init && \
+    chmod 755 /mnt/root/sbin/init && \
+    \
+    # Install busybox
+    echo "Installing busybox..." && \
+    cp /bin/busybox /mnt/root/bin/busybox && \
+    chmod 755 /mnt/root/bin/busybox && \
+    \
+    # Create busybox symlinks for essential commands
+    for cmd in sh ls cat echo mount umount mkdir rm cp mv chmod chown ln ps kill; do \
+        ln -sf busybox /mnt/root/bin/$cmd; \
+    done && \
+    \
+    # Create system configuration files
+    echo "sparkos" > /mnt/root/etc/hostname && \
+    echo "127.0.0.1   localhost" > /mnt/root/etc/hosts && \
+    echo "127.0.1.1   sparkos" >> /mnt/root/etc/hosts && \
+    echo "root:x:0:0:root:/root:/bin/sh" > /mnt/root/etc/passwd && \
+    echo "spark:x:1000:1000:SparkOS User:/home/spark:/bin/sh" >> /mnt/root/etc/passwd && \
+    echo "root:x:0:" > /mnt/root/etc/group && \
+    echo "spark:x:1000:" >> /mnt/root/etc/group && \
+    \
     # Create README
-    cat > /mnt/img/README.txt << 'EOF' && \
-SparkOS Minimal Filesystem Image
+    cat > /mnt/root/README.txt << 'README_EOF' && \
+SparkOS UEFI-Bootable Image
 
-This is a minimal ext4 filesystem image containing the SparkOS init system.
-This is NOT a fully bootable image - it requires additional components.
+This is a UEFI-bootable disk image with:
+- GPT partition table
+- EFI System Partition (ESP) with FAT32 filesystem
+- GRUB UEFI bootloader
+- Linux kernel
+- SparkOS init system
+- Busybox utilities
 
-What's included:
-- SparkOS init binary (/sbin/init)
-- Basic FHS-compliant directory structure
-- Basic configuration files
+The image can be written to a USB drive and booted on UEFI systems:
+  sudo dd if=sparkos.img of=/dev/sdX bs=4M status=progress
+  sudo sync
 
-To make this fully bootable, you need to add:
-1. Linux kernel (install to /boot/vmlinuz)
-2. Busybox (install to /bin/busybox and create symlinks)
-3. Bootloader (GRUB or syslinux)
-4. Required libraries (if using dynamically linked binaries)
-
-This image can be mounted to extract the init binary or inspect the structure:
-  sudo mount -o loop sparkos.img /mnt
-  cp /mnt/sbin/init ./
-  sudo umount /mnt
+Boot options:
+- UEFI boot support (tested on x86_64 systems)
+- Automatic boot after 3 seconds
+- Console on tty1
 
 For more information, see: https://github.com/johndoe6345789/SparkOS
-EOF
+README_EOF
+    \
+    # Sync and unmount
+    echo "Finalizing image..." && \
     sync && \
-    umount /mnt/img && \
+    umount /mnt/esp && \
+    umount /mnt/root && \
+    losetup -d $LOOP_DEV && \
+    \
     # Compress the image
+    echo "Compressing image..." && \
     gzip -9 /output/sparkos.img && \
-    echo "Image created: /output/sparkos.img.gz"
+    echo "UEFI-bootable image created: /output/sparkos.img.gz"
 
-# Final stage - just export the image
+# Final stage - export the image
 FROM scratch AS export
 COPY --from=image-builder /output/sparkos.img.gz /sparkos.img.gz