drivers: add ramdisk storage driver

Author: losfair

platform/pc/Makefile

@@ -22,6 +22,7 @@ SRCS-kernel.elf= \
 	$(SRCDIR)/drivers/gve.c \
 	$(SRCDIR)/drivers/nvme.c \
 	$(SRCDIR)/drivers/netconsole.c \
+	$(SRCDIR)/drivers/ramdisk.c \
 	$(SRCDIR)/drivers/vga.c \
 	$(SRCDIR)/gdb/gdbstub.c \
 	$(SRCDIR)/gdb/gdbtcp.c \

platform/pc/service.c

@@ -18,12 +18,15 @@
 #include <pci.h>
 #include <xen_platform.h>
 #include <virtio/virtio.h>
+#include <drivers/ramdisk.h>
 #include <vmware/vmware.h>
 #include "serial.h"
 
 #define BOOT_PARAM_OFFSET_E820_ENTRIES  0x01E8
 #define BOOT_PARAM_OFFSET_BOOT_FLAG     0x01FE
 #define BOOT_PARAM_OFFSET_HEADER        0x0202
+#define BOOT_PARAM_OFFSET_RAMDISK_IMAGE 0x0218
+#define BOOT_PARAM_OFFSET_RAMDISK_SIZE  0x021C
 #define BOOT_PARAM_OFFSET_CMD_LINE_PTR  0x0228
 #define BOOT_PARAM_OFFSET_CMDLINE_SIZE  0x0238
 #define BOOT_PARAM_OFFSET_E820_TABLE    0x02D0
@@ -64,6 +67,13 @@ typedef struct hvm_memmap_entry {
     u32 reserved;
 } *hvm_memmap_entry;
 
+typedef struct hvm_modlist_entry {
+    u64 paddr;
+    u64 size;
+    u64 cmdline_paddr;
+    u64 reserved;
+} *hvm_modlist_entry;
+
 extern u8 START, END;
 
 range kern_get_elf(void)
@@ -75,6 +85,15 @@ range kern_get_elf(void)
     return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
 }
 
+range kern_get_ramdisk(void)
+{
+    for_regions(e) {
+        if (e->type == REGION_RAMDISK)
+            return irangel(e->base, e->length);
+    }
+    return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
+}
+
 BSS_RO_AFTER_INIT static boolean have_rdseed;
 BSS_RO_AFTER_INIT static boolean have_rdrand;
 
@@ -366,11 +385,13 @@ static void setup_initmap(void)
 }
 
 // init linker set
-void init_service(u64 rdi, u64 rsi)
+void init_service(u64 rdi, u64 rsi, hvm_start_info start_info)
 {
     u8 *params = pointer_from_u64(rsi);
     const char *cmdline = 0;
     u32 cmdline_size;
+    void *ramdisk = 0;
+    u32 ramdisk_size;
 
     if (params && (*(u16 *)(params + BOOT_PARAM_OFFSET_BOOT_FLAG) == 0xAA55) &&
             (*(u32 *)(params + BOOT_PARAM_OFFSET_HEADER) == 0x53726448)) {
@@ -389,7 +410,28 @@ void init_service(u64 rdi, u64 rsi)
                 BOOT_PARAM_OFFSET_CMD_LINE_PTR)));
         cmdline_size = *((u32 *)(params + BOOT_PARAM_OFFSET_CMDLINE_SIZE));
 
+        ramdisk = pointer_from_u64((u64)*((u32 *)(params +
+                BOOT_PARAM_OFFSET_RAMDISK_IMAGE)));
+        ramdisk_size = *((u32 *)(params + BOOT_PARAM_OFFSET_RAMDISK_SIZE));
+
         setup_initmap();
+    } else if (start_info)
+    {
+        cmdline = pointer_from_u64(start_info->cmdline_paddr);
+        cmdline_size = 0;
+        const char *cmdline_p = cmdline;
+        while (*cmdline_p)
+        {
+            cmdline_size++;
+            cmdline_p++;
+        }
+
+        if (start_info->nr_modules)
+        {
+            hvm_modlist_entry ramdisk_entry = pointer_from_u64(start_info->modlist_paddr);
+            ramdisk = pointer_from_u64(ramdisk_entry->paddr); 
+            ramdisk_size = ramdisk_entry->size;
+        }
     }
 
     serial_init();
@@ -404,6 +446,8 @@ void init_service(u64 rdi, u64 rsi)
     init_kernel_heaps();
     if (cmdline)
         create_region(u64_from_pointer(cmdline), cmdline_size, REGION_CMDLINE);
+    if (ramdisk)
+        create_region(u64_from_pointer(ramdisk), ramdisk_size, REGION_RAMDISK);
     u64 stack_size = 32*PAGESIZE;
     u64 stack_location = allocate_u64((heap)heap_page_backed(get_kernel_heaps()), stack_size);
     stack_location += stack_size - STACK_ALIGNMENT;
@@ -422,7 +466,7 @@ void pvh_start(hvm_start_info start_info)
             create_region(mem_table[i].addr, mem_table[i].size, REGION_PHYSICAL);
     }
     setup_initmap();
-    init_service(0, 0);
+    init_service(0, 0, start_info);
 }
 
 RO_AFTER_INIT static struct console_driver serial_console_driver = {
@@ -499,6 +543,7 @@ void detect_devices(kernel_heaps kh, storage_attach sa)
         init_pvscsi(kh, sa);
         init_nvme(kh, sa);
         init_ata_pci(kh, sa);
+        init_ramdisk(kh, sa);
 
         init_virtio_9p(kh);
         init_virtio_socket(kh);

platform/riscv-virt/service.c

@@ -63,6 +63,11 @@ range kern_get_elf(void)
     return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
 }
 
+range kern_get_ramdisk(void)
+{
+    return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
+}
+
 void reclaim_regions(void)
 {
     /* mmu init complete; unmap temporary identity map */

platform/virt/service.c

@@ -194,6 +194,11 @@ range kern_get_elf(void)
     return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
 }
 
+range kern_get_ramdisk(void)
+{
+    return irange(INVALID_PHYSICAL, INVALID_PHYSICAL);
+}
+
 void reclaim_regions(void)
 {
 }

src/drivers/ramdisk.c

@@ -0,0 +1,68 @@
+#include <kernel.h>
+#include <storage.h>
+
+#include "ramdisk.h"
+
+typedef struct storage *storage;
+
+declare_closure_struct(2, 3, void, ramdisk_io,
+                       storage, st, boolean, write,
+                       void *buf, range blocks, status_handler sh);
+
+typedef struct storage
+{
+    closure_struct(storage_simple_req_handler, req_handler);
+    closure_struct(ramdisk_io, read);
+    closure_struct(ramdisk_io, write);
+    void *ramdisk;
+    u64 ramdisk_size;
+} *storage;
+
+define_closure_function(2, 3, void, ramdisk_io,
+                        storage, st, boolean, write,
+                        void *buf, range blocks, status_handler sh)
+{
+    storage st = bound(st);
+    boolean write = bound(write);
+
+    if (write)
+    {
+        apply(sh, timm("result", "read-only device"));
+        return;
+    }
+
+    u64 start_byte_offset = blocks.start * SECTOR_SIZE;
+    u64 end_byte_offset = blocks.end * SECTOR_SIZE;
+    if (start_byte_offset > end_byte_offset || end_byte_offset > st->ramdisk_size)
+    {
+        apply(sh, timm("result", "read out of bounds"));
+        return;
+    }
+
+    runtime_memcpy(buf, st->ramdisk + start_byte_offset, end_byte_offset - start_byte_offset);
+    apply(sh, STATUS_OK);
+}
+
+void init_ramdisk(kernel_heaps kh, storage_attach a)
+{
+    range ramdisk_phys = kern_get_ramdisk();
+    if (ramdisk_phys.start == INVALID_PHYSICAL)
+    {
+        msg_print("RAMDISK: not detected");
+        return;
+    }
+    u64 ramdisk_size = range_span(ramdisk_phys);
+    u64 v = allocate_u64((heap)heap_virtual_huge(kh), ramdisk_size);
+    map(v, ramdisk_phys.start, ramdisk_size, pageflags_memory());
+
+    heap h = heap_locked(kh);
+    storage st = allocate(h, sizeof(struct storage));
+    st->ramdisk = pointer_from_u64(v);
+    st->ramdisk_size = ramdisk_size;
+    apply(a,
+          storage_init_req_handler(&st->req_handler,
+                                   init_closure(&st->read, ramdisk_io, st, false),
+                                   init_closure(&st->write, ramdisk_io, st, true)),
+          ramdisk_size, -1);
+    msg_print("RAMDISK: %u bytes at %p", st->ramdisk_size, st->ramdisk);
+}

src/drivers/ramdisk.h

@@ -0,0 +1 @@
+void init_ramdisk(kernel_heaps kh, storage_attach a);

src/kernel/kernel.h

@@ -602,6 +602,7 @@ void init_platform_devices(kernel_heaps kh);
 void init_cpuinfo_machine(cpuinfo ci, heap backed);
 void kernel_runtime_init(kernel_heaps kh);
 range kern_get_elf(void);
+range kern_get_ramdisk(void);
 void reclaim_regions(void);
 
 extern u64 kernel_phys_offset;

src/kernel/region.h

@@ -19,6 +19,7 @@ typedef struct region *region;
 #define REGION_RECLAIM           14 /* areas to be unmapped and reclaimed in stage3 (only stage2 stack presently) */
 #define REGION_SMBIOS            15 /* SMBIOS entry point */
 #define REGION_RSDP              16 /* location of the ACPI RSDP */
+#define REGION_RAMDISK           17 /* kernel ramdisk */
 
 
 static inline region create_region(u64 base, u64 length, int type)

src/x86_64/crt0.s

@@ -396,6 +396,7 @@ write_xmsr:
 .end:
 
 _start:
+        xor edx, edx
         call init_service
         hlt
 .end: