summaryrefslogtreecommitdiffhomepage
path: root/src/loader/protocols
diff options
context:
space:
mode:
Diffstat (limited to 'src/loader/protocols')
-rw-r--r--src/loader/protocols/all.c36
-rw-r--r--src/loader/protocols/mb1.c147
-rw-r--r--src/loader/protocols/mb2.c105
3 files changed, 288 insertions, 0 deletions
diff --git a/src/loader/protocols/all.c b/src/loader/protocols/all.c
new file mode 100644
index 0000000..8ea16dd
--- /dev/null
+++ b/src/loader/protocols/all.c
@@ -0,0 +1,36 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <protocols/all.h>
+#include <protocols/mb1.h>
+#include <protocols/mb2.h>
+#include <panic.h>
+
+u8 impl_detect(struct config_entry *cfg)
+{
+ if (mb1_detect(cfg))
+ return 1;
+
+ if (mb2_detect(cfg))
+ return 1;
+
+ return 0;
+}
+
+void impl_exec(struct config_entry *cfg)
+{
+ assert(cfg->dev->type == DEVICE_DISK);
+
+ switch (cfg->impl.type) {
+ case IMPL_MB1:
+ mb1_exec(cfg);
+ break;
+ case IMPL_MB2:
+ mb2_exec(cfg);
+ break;
+ case IMPL_NONE:
+ default:
+ panic("Invalid implementation\n");
+ }
+
+ panic("Couldn't execute implementation\n");
+}
diff --git a/src/loader/protocols/mb1.c b/src/loader/protocols/mb1.c
new file mode 100644
index 0000000..cd57fad
--- /dev/null
+++ b/src/loader/protocols/mb1.c
@@ -0,0 +1,147 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+// Everything according to spec
+
+#include <elf.h>
+#include <library.h>
+#include <memory.h>
+#include <panic.h>
+#include <protocols/mb1.h>
+
+// The address where data gets stored
+#define MB1_LOAD_ADDRESS 0x20000
+
+#define MB1_FLAG_PAGE_ALIGN (1 << 0) // Align modules with page boundaries (4K)
+#define MB1_FLAG_MEMORY_INFO (1 << 1) // Load/store all memory_* fields and mmap_* structs
+#define MB1_FLAG_VIDEO_MODE (1 << 2) // Load/store video mode table
+#define MB1_FLAG_MANUAL_ADDRESSES (1 << 16) // Use specified load addresses
+
+struct mb1_entry {
+ u32 magic;
+ u32 flags;
+ u32 checksum; // Everything after that is optional
+ u32 header_addr; // Unsupported
+ u32 load_addr; // Unsupported
+ u32 load_end_addr; // Unsupported
+ u32 bss_end_addr; // Unsupported
+ u32 entry_addr; // Unsupported
+ u32 mode_type;
+ u32 width;
+ u32 height;
+ u32 depth;
+};
+
+// The (really simple) multiboot checksum algorithm
+static u32 mb1_checksum(struct mb1_entry *entry)
+{
+ return -(entry->magic + entry->flags);
+}
+
+// Load data into memory and return address (not overlapping)
+static u32 mb1_store(void *data, u32 size)
+{
+ static u32 offset = 0;
+ memcpy((void *)(MB1_LOAD_ADDRESS + offset), data, size);
+ offset += size;
+ return MB1_LOAD_ADDRESS + (offset - size);
+}
+
+static void mb1_store_memory_info(struct mb1_info *info)
+{
+ // TODO: Store memory_lower and memory_upper
+ struct memory_map *memory_map = memory_map_get();
+ info->flags |= MB1_INFO_MEMORY_MAP;
+ info->mmap_length = memory_map->count * sizeof(struct mb1_mmap_entry);
+ info->mmap_addr = mb1_store(NULL, 0);
+ for (u32 i = 0; i < memory_map->count; i++) {
+ struct mb1_mmap_entry mmap_entry = { 0 };
+ mmap_entry.struct_size = sizeof(mmap_entry) - 4;
+ mmap_entry.addr_low = memory_map->entry[i].base;
+ mmap_entry.len_low = memory_map->entry[i].length;
+ mmap_entry.type = memory_map->entry[i].type;
+ mb1_store(&mmap_entry, sizeof(mmap_entry));
+ }
+}
+
+// Load the mb1 structs into memory
+static void mb1_load(struct mb1_entry *entry)
+{
+ struct mb1_info info_struct = { 0 };
+ struct mb1_info *info = (void *)mb1_store(&info_struct, sizeof(info_struct));
+
+ // Set boot device
+ info->flags |= MB1_INFO_BOOTDEV;
+ info->boot_device = boot_disk;
+
+ // Set bootloader name
+ info->flags |= MB1_INFO_BOOT_LOADER_NAME;
+ char loader_name[] = "SegelBoot";
+ info->boot_loader_name = mb1_store(loader_name, sizeof(loader_name));
+
+ // Store memory info
+ if (entry->flags & MB1_FLAG_MEMORY_INFO)
+ mb1_store_memory_info(info);
+}
+
+// Jump to kernel with correct info pointer in eax
+static void mb1_jump(u32 entry, u32 info)
+{
+ log("Jumping. So long and thanks for all the fish!\n");
+
+ // Move and jump!
+ __asm__ volatile("movl $" STRINGIFY(MB1_LOAD_MAGIC) ", %%eax\n\t"
+ "jmpl *%%edi\n\t"
+ :
+ : "D"(entry), "b"(info)
+ : "memory");
+
+ panic("Jumper returned\n");
+}
+
+// Detect and verify mb1
+u8 mb1_detect(struct config_entry *cfg)
+{
+ u8 header[8192] = { 0 };
+
+ s32 ret = cfg->dev->p.disk.fs.read(cfg->path, header, 0, sizeof(header), cfg->dev);
+ if (ret < 12)
+ return 0;
+
+ // Find start of multiboot entry by searching for magic
+ struct mb1_entry *entry = 0;
+ for (u32 i = 0; i < sizeof(header); i++) {
+ u32 *p = (u32 *)&header[i];
+ if (*p == MB1_MAGIC) {
+ entry = (void *)p;
+ break;
+ }
+ }
+
+ if (!entry)
+ return 0;
+
+ u32 checksum = mb1_checksum(entry);
+ if (checksum != entry->checksum)
+ return 0;
+
+ cfg->impl.type = IMPL_MB1;
+ cfg->impl.offset = (u32)entry - (u32)header;
+
+ return 1;
+}
+
+// Execute mb1 type kernel
+void mb1_exec(struct config_entry *cfg)
+{
+ struct mb1_entry mb1_entry = { 0 };
+ s32 ret = cfg->dev->p.disk.fs.read(cfg->path, &mb1_entry, cfg->impl.offset,
+ sizeof(mb1_entry), cfg->dev);
+ assert(ret == sizeof(mb1_entry));
+ mb1_load(&mb1_entry);
+
+ u32 entry = elf_load(cfg->dev, cfg->path);
+
+ // This is a kind of hacky parameter stack pushing thing, just disable warning :)
+#pragma GCC diagnostic ignored "-Wpedantic"
+ jmp_kernel((void *)mb1_jump, 2, entry, MB1_LOAD_ADDRESS);
+#pragma GCC diagnostic pop
+}
diff --git a/src/loader/protocols/mb2.c b/src/loader/protocols/mb2.c
new file mode 100644
index 0000000..8f0a660
--- /dev/null
+++ b/src/loader/protocols/mb2.c
@@ -0,0 +1,105 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+// Everything according to spec
+
+#include <elf.h>
+#include <protocols/mb2.h>
+#include <library.h>
+#include <panic.h>
+
+// The address where data gets stored
+#define MB2_LOAD_ADDRESS 0x10000
+
+struct mb2_entry {
+ u32 magic;
+ u32 flags;
+ u32 header_length;
+ u32 checksum; // Everything after that is optional
+ u8 *tags;
+};
+
+// The (really simple) multiboot checksum algorithm
+/* static u32 mb2_checksum(struct mb2_entry *entry) */
+/* { */
+/* return -(entry->magic + entry->flags); */
+/* } */
+
+// Load data into memory and return address (not overlapping
+static u32 mb2_store(void *data, u32 size)
+{
+ static u32 offset = 0;
+ memcpy((void *)MB2_LOAD_ADDRESS, data, size);
+ offset += size;
+ return MB2_LOAD_ADDRESS + (size - offset);
+}
+
+// Load the mb2 structs into memory
+static void mb2_load(struct mb2_entry *entry)
+{
+ (void)mb2_store;
+ (void)entry;
+}
+
+// Jump to kernel with correct info pointer in eax
+static void mb2_jump(u32 entry, u32 info)
+{
+ log("Jumping. So long and thanks for all the fish!\n");
+
+ // Move and jump!
+ __asm__ volatile("movl $" STRINGIFY(MB2_LOAD_MAGIC) ", %%eax\n\t"
+ "jmpl *%%edi\n\t"
+ :
+ : "D"(entry), "b"(info)
+ : "memory");
+
+ panic("Jumper returned\n");
+}
+
+// Detect and verify mb2
+u8 mb2_detect(struct config_entry *cfg)
+{
+ u8 header[8192] = { 0 };
+
+ s32 ret = cfg->dev->p.disk.fs.read(cfg->path, header, 0, sizeof(header), cfg->dev);
+ if (ret < 12)
+ return 0;
+
+ // Find start of multiboot entry by searching for magic
+ struct mb2_entry *entry = 0;
+ for (u32 i = 0; i < sizeof(header); i++) {
+ u32 *p = (u32 *)&header[i];
+ if (*p == MB2_MAGIC) {
+ entry = (void *)p;
+ break;
+ }
+ }
+
+ if (!entry)
+ return 0;
+
+ // TODO: mb2 checksum
+ /* u32 checksum = mb2_checksum(entry); */
+ /* if (checksum != entry->checksum) */
+ /* return 0; */
+
+ cfg->impl.type = IMPL_MB2;
+ cfg->impl.offset = (u32)entry - (u32)header;
+
+ return 1;
+}
+
+// Execute mb2 type kernel
+void mb2_exec(struct config_entry *cfg)
+{
+ struct mb2_entry mb2_entry = { 0 };
+ s32 ret = cfg->dev->p.disk.fs.read(cfg->path, &mb2_entry, cfg->impl.offset,
+ sizeof(mb2_entry), cfg->dev);
+ assert(ret == sizeof(mb2_entry));
+ mb2_load(&mb2_entry);
+
+ u32 entry = elf_load(cfg->dev, cfg->path);
+
+ // This is a kind of hacky parameter stack pushing thing, just disable warning :)
+#pragma GCC diagnostic ignored "-Wpedantic"
+ jmp_kernel((void *)mb2_jump, 2, entry, MB2_LOAD_ADDRESS);
+#pragma GCC diagnostic pop
+}