Move fdt handling logic out of main.c.
This is in preparation for having archs/platforms that don't use FDT.
diff --git a/inc/boot_params.h b/inc/boot_params.h
new file mode 100644
index 0000000..1b4fe06
--- /dev/null
+++ b/inc/boot_params.h
@@ -0,0 +1,26 @@
+#ifndef _BOOT_PARAMS_H
+#define _BOOT_PARAMS_H
+
+#include <stdbool.h>
+
+#include "mm.h"
+
+struct boot_params {
+ paddr_t mem_begin;
+ paddr_t mem_end;
+ paddr_t initrd_begin;
+ paddr_t initrd_end;
+ size_t kernel_arg;
+};
+
+struct boot_params_update {
+ paddr_t reserved_begin;
+ paddr_t reserved_end;
+ paddr_t initrd_begin;
+ paddr_t initrd_end;
+};
+
+bool plat_get_boot_params(struct boot_params *p);
+bool plat_update_boot_params(struct boot_params_update *p);
+
+#endif /* _BOOT_PARAMS_H */
diff --git a/inc/cpu.h b/inc/cpu.h
index 58df21d..30433ad 100644
--- a/inc/cpu.h
+++ b/inc/cpu.h
@@ -17,11 +17,11 @@
/* TODO: Update alignment such that cpus are in different cache lines. */
struct cpu {
- struct vcpu *current;
-
/* CPU identifier. Doesn't have to be contiguous. */
size_t id;
+ struct vcpu *current;
+
/* Pointer to bottom of the stack. */
void *stack_bottom;
diff --git a/inc/dlog.h b/inc/dlog.h
index fca8103..1d514a3 100644
--- a/inc/dlog.h
+++ b/inc/dlog.h
@@ -1,12 +1,14 @@
#ifndef _DLOG_H
#define _DLOG_H
+#include <stdarg.h>
+
#if DEBUG
void dlog(const char *fmt, ...);
+void vdlog(const char *fmt, va_list args);
#else
#define dlog(...)
+#define vdlog(fmt, args)
#endif
-void dlog_init(void (*pchar)(char));
-
#endif /* _DLOG_H */
diff --git a/inc/fdt.h b/inc/fdt.h
index 44d629e..147c0dc 100644
--- a/inc/fdt.h
+++ b/inc/fdt.h
@@ -6,7 +6,6 @@
#include <stdint.h>
struct fdt_node {
- /* TODO: What do we need here? */
const struct fdt_header *hdr;
const char *begin;
const char *end;
@@ -16,7 +15,7 @@
size_t fdt_header_size(void);
size_t fdt_total_size(struct fdt_header *hdr);
void fdt_dump(struct fdt_header *hdr);
-void fdt_root_node(struct fdt_node *node, const struct fdt_header *hdr);
+bool fdt_root_node(struct fdt_node *node, const struct fdt_header *hdr);
bool fdt_find_child(struct fdt_node *node, const char *child);
bool fdt_first_child(struct fdt_node *node, const char **child_name);
bool fdt_next_sibling(struct fdt_node *node, const char **sibling_name);
diff --git a/inc/fdt_handler.h b/inc/fdt_handler.h
new file mode 100644
index 0000000..9ac6853
--- /dev/null
+++ b/inc/fdt_handler.h
@@ -0,0 +1,10 @@
+#ifndef _FDT_HANDLER_H
+#define _FDT_HANDLER_H
+
+#include "boot_params.h"
+#include "fdt.h"
+
+bool fdt_get_boot_params(struct fdt_header *fdt, struct boot_params *p);
+bool fdt_patch(struct fdt_header *fdt, struct boot_params_update *p);
+
+#endif /* _FDT_HANDLER_H */
diff --git a/inc/load.h b/inc/load.h
new file mode 100644
index 0000000..93aa535
--- /dev/null
+++ b/inc/load.h
@@ -0,0 +1,13 @@
+#ifndef _LOAD_H
+#define _LOAD_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "cpio.h"
+#include "memiter.h"
+
+bool load_primary(struct cpio *c, size_t kernel_arg, struct memiter *initrd);
+bool load_secondary(struct cpio *c, uint64_t mem_begin, uint64_t *mem_end);
+
+#endif /* _LOAD_H */
diff --git a/inc/memiter.h b/inc/memiter.h
new file mode 100644
index 0000000..ffaa822
--- /dev/null
+++ b/inc/memiter.h
@@ -0,0 +1,18 @@
+#ifndef _MEMITER_H
+#define _MEMITER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct memiter {
+ const char *next;
+ const char *limit;
+};
+
+void memiter_init(struct memiter *it, const void *data, size_t size);
+bool memiter_parse_uint(struct memiter *it, uint64_t *value);
+bool memiter_parse_str(struct memiter *it, struct memiter *str);
+bool memiter_iseq(const struct memiter *it, const char *str);
+
+#endif /* _MEMITER_H */
diff --git a/inc/mm.h b/inc/mm.h
index 9c129d4..3a5c691 100644
--- a/inc/mm.h
+++ b/inc/mm.h
@@ -38,6 +38,11 @@
paddr_t paddr, int mode);
bool mm_ptable_map_page(struct mm_ptable *t, vaddr_t va, paddr_t pa, int mode);
bool mm_ptable_unmap(struct mm_ptable *t, vaddr_t begin, vaddr_t end, int mode);
-void mm_ptable_defrag(struct mm_ptable *t);
+void mm_ptable_defrag(struct mm_ptable *t, int mode);
+
+bool mm_init(void);
+bool mm_map(vaddr_t begin, vaddr_t end, paddr_t paddr, int mode);
+bool mm_unmap(vaddr_t begin, vaddr_t end, int mode);
+void mm_defrag(void);
#endif /* _MM_H */
diff --git a/src/arch/aarch64/hikey.mk b/src/arch/aarch64/hikey.mk
index 1bf62c1..ec9eff9 100644
--- a/src/arch/aarch64/hikey.mk
+++ b/src/arch/aarch64/hikey.mk
@@ -1,3 +1,5 @@
+USE_FDT := 1
+
LOAD_ADDRESS := 0x1000000
PL011_BASE := 0xf8015000
PL011 := 1
diff --git a/src/arch/aarch64/params.c b/src/arch/aarch64/params.c
new file mode 100644
index 0000000..d044d69
--- /dev/null
+++ b/src/arch/aarch64/params.c
@@ -0,0 +1,20 @@
+#include "boot_params.h"
+#include "fdt_handler.h"
+
+struct fdt_header *fdt;
+
+/*
+ * The following are declared weak so that they can overwritten by platform code
+ * if desired.
+ */
+#pragma weak plat_get_boot_params
+bool plat_get_boot_params(struct boot_params *p)
+{
+ return fdt_get_boot_params(fdt, p);
+}
+
+#pragma weak plat_update_boot_params
+bool plat_update_boot_params(struct boot_params_update *p)
+{
+ return fdt_patch(fdt, p);
+}
diff --git a/src/arch/aarch64/qemu.mk b/src/arch/aarch64/qemu.mk
index c137ca8..41bcd3c 100644
--- a/src/arch/aarch64/qemu.mk
+++ b/src/arch/aarch64/qemu.mk
@@ -1,3 +1,5 @@
+USE_FDT := 1
+
LOAD_ADDRESS := 0x40001000
PL011_BASE := 0x09000000
PL011 := 1
diff --git a/src/arch/aarch64/rules.mk b/src/arch/aarch64/rules.mk
index fd6b737..4abf817 100644
--- a/src/arch/aarch64/rules.mk
+++ b/src/arch/aarch64/rules.mk
@@ -2,6 +2,7 @@
SRCS += exceptions.S
SRCS += handler.c
SRCS += mm.c
+SRCS += params.c
OFFSET_SRCS += offsets.c
diff --git a/src/dlog.c b/src/dlog.c
index 5382096..db619ee 100644
--- a/src/dlog.c
+++ b/src/dlog.c
@@ -1,6 +1,5 @@
#include "dlog.h"
-#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
@@ -21,7 +20,7 @@
/* clang-format on */
-/*
+/**
* Prints a raw string to the debug log and returns its length.
*/
static size_t print_raw_string(const char *str)
@@ -33,7 +32,7 @@
return c - str;
}
-/*
+/**
* Prints a formatted string to the debug log. The format includes a minimum
* width, the fill character, and flags (whether to align to left or right).
*
@@ -73,7 +72,7 @@
print_raw_string(suffix);
}
-/*
+/**
* Prints a number to the debug log. The caller specifies the base, its minimum
* width and printf-style flags.
*/
@@ -126,7 +125,7 @@
}
}
-/*
+/**
* Parses the optional flags field of a printf-style format. It returns the spot
* on the string where a non-flag character was found.
*/
@@ -160,20 +159,17 @@
}
}
-/*
- * Prints the given format string to the debug log.
+/**
+ * Same as "dlog", except that arguments are passed as a va_list.
*/
-void dlog(const char *fmt, ...)
+void vdlog(const char *fmt, va_list args)
{
static struct spinlock sl = SPINLOCK_INIT;
const char *p;
- va_list args;
size_t w;
int flags;
char buf[2];
- va_start(args, fmt);
-
sl_lock(&sl);
for (p = fmt; *p; p++) {
@@ -271,6 +267,16 @@
}
sl_unlock(&sl);
+}
+/**
+ * Prints the given format string to the debug log.
+ */
+void dlog(const char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ vdlog(fmt, args);
va_end(args);
}
diff --git a/src/fdt.c b/src/fdt.c
index fbcf641..faf42b3 100644
--- a/src/fdt.c
+++ b/src/fdt.c
@@ -110,7 +110,7 @@
return false;
}
-void fdt_root_node(struct fdt_node *node, const struct fdt_header *hdr)
+bool fdt_root_node(struct fdt_node *node, const struct fdt_header *hdr)
{
uint32_t max_ver;
uint32_t min_ver;
@@ -121,14 +121,14 @@
/* Check the magic number before anything else. */
if (hdr->magic != be32toh(FDT_MAGIC)) {
- return;
+ return false;
}
/* Check the version. */
max_ver = be32toh(hdr->version);
min_ver = be32toh(hdr->last_comp_version);
if (FDT_VERSION < min_ver || FDT_VERSION > max_ver) {
- return;
+ return false;
}
/* TODO: Verify that it is all within the fdt. */
@@ -137,6 +137,8 @@
/* TODO: Verify strings as well. */
node->strs = (char *)hdr + be32toh(hdr->off_dt_strings);
+
+ return true;
}
static bool fdt_next_property(struct fdt_tokenizer *t, const char **name,
diff --git a/src/fdt_handler.c b/src/fdt_handler.c
new file mode 100644
index 0000000..fa2f9b6
--- /dev/null
+++ b/src/fdt_handler.c
@@ -0,0 +1,284 @@
+#include "fdt_handler.h"
+
+#include "boot_params.h"
+#include "dlog.h"
+#include "fdt.h"
+#include "mm.h"
+#include "std.h"
+
+static uint64_t convert_number(const char *data, uint32_t size)
+{
+ union {
+ volatile uint64_t v;
+ char a[8];
+ } t;
+
+ switch (size) {
+ case sizeof(uint32_t):
+ return be32toh(*(uint32_t *)data);
+ case sizeof(uint64_t):
+ memcpy(t.a, data, sizeof(uint64_t));
+ return be64toh(t.v);
+ default:
+ return 0;
+ }
+}
+
+static bool fdt_read_number(const struct fdt_node *node, const char *name,
+ uint64_t *value)
+{
+ const char *data;
+ uint32_t size;
+
+ if (!fdt_read_property(node, name, &data, &size)) {
+ return false;
+ }
+
+ switch (size) {
+ case sizeof(uint32_t):
+ case sizeof(uint64_t):
+ *value = convert_number(data, size);
+ break;
+
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+static bool fdt_write_number(struct fdt_node *node, const char *name,
+ uint64_t value)
+{
+ const char *data;
+ uint32_t size;
+ union {
+ volatile uint64_t v;
+ char a[8];
+ } t;
+
+ if (!fdt_read_property(node, name, &data, &size)) {
+ return false;
+ }
+
+ switch (size) {
+ case sizeof(uint32_t):
+ *(uint32_t *)data = be32toh(value);
+ break;
+
+ case sizeof(uint64_t):
+ t.v = be64toh(value);
+ memcpy((void *)data, t.a, sizeof(uint64_t));
+ break;
+
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * Finds the memory region where initrd is stored, and udpates the fdt node
+ * cursor to the node called "chosen".
+ */
+static bool find_initrd(struct fdt_node *n, struct boot_params *p)
+{
+ if (!fdt_find_child(n, "chosen")) {
+ dlog("Unable to find 'chosen'\n");
+ return false;
+ }
+
+ if (!fdt_read_number(n, "linux,initrd-start", &p->initrd_begin)) {
+ dlog("Unable to read linux,initrd-start\n");
+ return false;
+ }
+
+ if (!fdt_read_number(n, "linux,initrd-end", &p->initrd_end)) {
+ dlog("Unable to read linux,initrd-end\n");
+ return false;
+ }
+
+ return true;
+}
+
+static void find_memory_range(const struct fdt_node *root,
+ struct boot_params *p)
+{
+ struct fdt_node n = *root;
+ const char *name;
+ uint64_t address_size;
+ uint64_t size_size;
+ uint64_t entry_size;
+
+ /* Get the sizes of memory range addresses and sizes. */
+ if (fdt_read_number(&n, "#address-cells", &address_size)) {
+ address_size *= sizeof(uint32_t);
+ } else {
+ address_size = sizeof(uint32_t);
+ }
+
+ if (fdt_read_number(&n, "#size-cells", &size_size)) {
+ size_size *= sizeof(uint32_t);
+ } else {
+ size_size = sizeof(uint32_t);
+ }
+
+ entry_size = address_size + size_size;
+
+ /* Look for nodes with the device_type set to "memory". */
+ if (!fdt_first_child(&n, &name)) {
+ return;
+ }
+
+ do {
+ const char *data;
+ uint32_t size;
+ if (!fdt_read_property(&n, "device_type", &data, &size) ||
+ size != sizeof("memory") ||
+ memcmp(data, "memory", sizeof("memory")) != 0 ||
+ !fdt_read_property(&n, "reg", &data, &size)) {
+ continue;
+ }
+
+ /* Traverse all memory ranges within this node. */
+ while (size >= entry_size) {
+ uint64_t addr = convert_number(data, address_size);
+ uint64_t len =
+ convert_number(data + address_size, size_size);
+
+ if (len > p->mem_end - p->mem_begin) {
+ /* Remember the largest range we've found. */
+ p->mem_begin = addr;
+ p->mem_end = addr + len;
+ }
+
+ size -= entry_size;
+ data += entry_size;
+ }
+ } while (fdt_next_sibling(&n, &name));
+
+ /* TODO: Check for "reserved-memory" nodes. */
+}
+
+bool fdt_get_boot_params(struct fdt_header *fdt, struct boot_params *p)
+{
+ struct fdt_node n;
+ bool ret = false;
+
+ /* Map the fdt header in. */
+ if (!mm_map((vaddr_t)fdt, (vaddr_t)fdt + fdt_header_size(),
+ (paddr_t)fdt, MM_MODE_R)) {
+ dlog("Unable to map FDT header.\n");
+ goto err_unmap_fdt_header;
+ }
+
+ if (!fdt_root_node(&n, fdt)) {
+ dlog("FDT failed validation.\n");
+ goto err_unmap_fdt_header;
+ }
+
+ /* Map the rest of the fdt in. */
+ if (!mm_map((vaddr_t)fdt, (vaddr_t)fdt + fdt_total_size(fdt),
+ (paddr_t)fdt, MM_MODE_R)) {
+ dlog("Unable to map full FDT.\n");
+ goto err_unmap_fdt_header;
+ }
+
+ if (!fdt_find_child(&n, "")) {
+ dlog("Unable to find FDT root node.\n");
+ goto out_unmap_fdt;
+ }
+
+ p->mem_begin = 0;
+ p->mem_end = 0;
+ find_memory_range(&n, p);
+
+ if (!find_initrd(&n, p)) {
+ goto out_unmap_fdt;
+ }
+
+ p->kernel_arg = (size_t)fdt;
+ ret = true;
+
+out_unmap_fdt:
+ mm_unmap((vaddr_t)fdt, (vaddr_t)fdt + fdt_total_size(fdt), 0);
+ return ret;
+
+err_unmap_fdt_header:
+ mm_unmap((vaddr_t)fdt, (vaddr_t)fdt + fdt_header_size(), 0);
+ return false;
+}
+
+bool fdt_patch(struct fdt_header *fdt, struct boot_params_update *p)
+{
+ struct fdt_node n;
+ bool ret = false;
+
+ /* Map the fdt header in. */
+ if (!mm_map((vaddr_t)fdt, (vaddr_t)fdt + fdt_header_size(),
+ (paddr_t)fdt, MM_MODE_R)) {
+ dlog("Unable to map FDT header.\n");
+ return false;
+ }
+
+ if (!fdt_root_node(&n, fdt)) {
+ dlog("FDT failed validation.\n");
+ goto err_unmap_fdt_header;
+ }
+
+ /* Map the fdt (+ a page) in r/w mode in preparation for updating it. */
+ if (!mm_map((vaddr_t)fdt,
+ (vaddr_t)fdt + fdt_total_size(fdt) + PAGE_SIZE,
+ (paddr_t)fdt, MM_MODE_R | MM_MODE_W)) {
+ dlog("Unable to map FDT in r/w mode.\n");
+ goto err_unmap_fdt_header;
+ }
+
+ if (!fdt_find_child(&n, "")) {
+ dlog("Unable to find FDT root node.\n");
+ goto out_unmap_fdt;
+ }
+
+ if (!fdt_find_child(&n, "chosen")) {
+ dlog("Unable to find 'chosen'\n");
+ goto out_unmap_fdt;
+ }
+
+ /* Patch FDT to point to new ramdisk. */
+ if (!fdt_write_number(&n, "linux,initrd-start", p->initrd_begin)) {
+ dlog("Unable to write linux,initrd-start\n");
+ goto out_unmap_fdt;
+ }
+
+ if (!fdt_write_number(&n, "linux,initrd-end", p->initrd_end)) {
+ dlog("Unable to write linux,initrd-end\n");
+ goto out_unmap_fdt;
+ }
+
+ /* Patch fdt to reserve primary VM memory. */
+ {
+ size_t tmp = (size_t)&plat_update_boot_params;
+ tmp = (tmp + 0x80000 - 1) & ~(0x80000 - 1);
+ fdt_add_mem_reservation(fdt, tmp & ~0xfffff, 0x80000);
+ }
+
+ /* Patch fdt to reserve memory for secondary VMs. */
+ fdt_add_mem_reservation(fdt, p->reserved_begin,
+ p->reserved_end - p->reserved_begin);
+
+ ret = true;
+
+out_unmap_fdt:
+ /* Unmap FDT. */
+ if (!mm_unmap((vaddr_t)fdt,
+ (vaddr_t)fdt + fdt_total_size(fdt) + PAGE_SIZE, 0)) {
+ dlog("Unable to unmap writable FDT.\n");
+ return false;
+ }
+ return ret;
+
+err_unmap_fdt_header:
+ mm_unmap((vaddr_t)fdt, (vaddr_t)fdt + fdt_header_size(), 0);
+ return false;
+}
diff --git a/src/load.c b/src/load.c
new file mode 100644
index 0000000..e0949d6
--- /dev/null
+++ b/src/load.c
@@ -0,0 +1,184 @@
+#include "load.h"
+
+#include <stdbool.h>
+
+#include "api.h"
+#include "dlog.h"
+#include "memiter.h"
+#include "mm.h"
+#include "std.h"
+#include "vm.h"
+
+/**
+ * Copies data to an unmapped location by mapping it for write, copying the
+ * data, then unmapping it.
+ */
+static bool copy_to_unmaped(paddr_t to, const void *from, size_t size)
+{
+ if (!mm_map((vaddr_t)to, (vaddr_t)to + size, to, MM_MODE_W)) {
+ return false;
+ }
+
+ memcpy((void *)to, from, size);
+
+ mm_unmap(to, to + size, 0);
+
+ return true;
+}
+
+/**
+ * Moves the kernel of the primary VM to its final destination.
+ */
+static bool relocate(const char *from, size_t size)
+{
+ /* TODO: This is a hack. We must read the alignment from the binary. */
+ extern char bin_end[];
+ size_t tmp = (size_t)&bin_end[0];
+ paddr_t dest = (tmp + 0x80000 - 1) & ~(0x80000 - 1);
+ dlog("bin_end is at %p, copying to %p\n", &bin_end[0], dest);
+ return copy_to_unmaped(dest, from, size);
+}
+
+/**
+ * Looks for a file in the given cpio archive. The filename is not
+ * null-terminated, so we use a memory iterator to represent it. The file, if
+ * found, is returned in the "it" argument.
+ */
+static bool memiter_find_file(struct cpio *c, const struct memiter *filename,
+ struct memiter *it)
+{
+ const char *fname;
+ const void *fcontents;
+ size_t fsize;
+ struct cpio_iter iter;
+
+ cpio_init_iter(c, &iter);
+
+ while (cpio_next(&iter, &fname, &fcontents, &fsize)) {
+ if (memiter_iseq(filename, fname)) {
+ memiter_init(it, fcontents, fsize);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**
+ * Looks for a file in the given cpio archive. The file, if found, is returned
+ * in the "it" argument.
+ */
+static bool find_file(struct cpio *c, const char *name, struct memiter *it)
+{
+ const char *fname;
+ const void *fcontents;
+ size_t fsize;
+ struct cpio_iter iter;
+
+ cpio_init_iter(c, &iter);
+
+ while (cpio_next(&iter, &fname, &fcontents, &fsize)) {
+ if (!strcmp(fname, name)) {
+ memiter_init(it, fcontents, fsize);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+/**
+ * Loads the primary VM.
+ */
+bool load_primary(struct cpio *c, size_t kernel_arg, struct memiter *initrd)
+{
+ struct memiter it;
+
+ if (!find_file(c, "vmlinuz", &it)) {
+ dlog("Unable to find vmlinuz\n");
+ return false;
+ }
+
+ if (!relocate(it.next, it.limit - it.next)) {
+ dlog("Unable to relocate kernel for primary vm.\n");
+ return false;
+ }
+
+ if (!find_file(c, "initrd.img", initrd)) {
+ dlog("Unable to find initrd.img\n");
+ return false;
+ }
+
+ {
+ size_t tmp = (size_t)&load_primary;
+ tmp = (tmp + 0x80000 - 1) & ~(0x80000 - 1);
+ vm_init(&primary_vm, MAX_CPUS);
+ vm_start_vcpu(&primary_vm, 0, tmp, kernel_arg, true);
+ }
+
+ arch_set_vm_mm(&primary_vm.page_table);
+
+ return true;
+}
+
+/**
+ * Loads all secondary VMs in the given memory range. "mem_end" is updated to
+ * reflect the fact that some of the memory isn't available to the primary VM
+ * anymore.
+ */
+bool load_secondary(struct cpio *c, uint64_t mem_begin, uint64_t *mem_end)
+{
+ struct memiter it;
+ struct memiter str;
+ uint64_t mem;
+ uint64_t cpu;
+ uint32_t count;
+
+ if (!find_file(c, "vms.txt", &it)) {
+ dlog("vms.txt is missing\n");
+ return true;
+ }
+
+ for (count = 0;
+ memiter_parse_uint(&it, &mem) && memiter_parse_uint(&it, &cpu) &&
+ memiter_parse_str(&it, &str) && count < MAX_VMS;
+ count++) {
+ struct memiter kernel;
+
+ if (!memiter_find_file(c, &str, &kernel)) {
+ dlog("Unable to load kernel for vm %u\n", count);
+ continue;
+ }
+
+ if (mem > *mem_end - mem_begin) {
+ dlog("Not enough memory for vm %u (%u bytes)\n", count,
+ mem);
+ continue;
+ }
+
+ if (mem < kernel.limit - kernel.next) {
+ dlog("Kernel is larger than available memory for vm "
+ "%u\n",
+ count);
+ continue;
+ }
+
+ *mem_end -= mem;
+ if (!copy_to_unmaped(*mem_end, kernel.next,
+ kernel.limit - kernel.next)) {
+ dlog("Unable to copy kernel for vm %u\n", count);
+ continue;
+ }
+
+ dlog("Loaded VM%u with %u vcpus, entry at 0x%x\n", count, cpu,
+ *mem_end);
+
+ /* TODO: Update page table to reflect the memory range. */
+ vm_init(secondary_vm + count, cpu);
+ vm_start_vcpu(secondary_vm + count, 0, *mem_end, 0, false);
+ }
+
+ secondary_vm_count = count;
+
+ return true;
+}
diff --git a/src/main.c b/src/main.c
index e4957fd..7792c8a 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,438 +1,41 @@
#include <stdalign.h>
#include <stddef.h>
+#include <stdnoreturn.h>
#include "alloc.h"
#include "api.h"
+#include "boot_params.h"
#include "cpio.h"
#include "cpu.h"
#include "dlog.h"
-#include "fdt.h"
+#include "load.h"
#include "mm.h"
#include "std.h"
#include "vm.h"
-void *fdt;
char ptable_buf[PAGE_SIZE * 20];
-struct mm_ptable ptable;
-
-bool fdt_find_node(struct fdt_node *node, const char *path)
-{
- while (*path) {
- if (!fdt_find_child(node, path)) {
- return false;
- }
- path += strlen(path);
- }
-
- return true;
-}
-
-static uint64_t convert_number(const char *data, uint32_t size)
-{
- union {
- volatile uint64_t v;
- char a[8];
- } t;
-
- switch (size) {
- case sizeof(uint32_t):
- return be32toh(*(uint32_t *)data);
- case sizeof(uint64_t):
- memcpy(t.a, data, sizeof(uint64_t));
- return be64toh(t.v);
- default:
- return 0;
- }
-}
-
-static bool fdt_read_number(const struct fdt_node *node, const char *name,
- uint64_t *value)
-{
- const char *data;
- uint32_t size;
-
- if (!fdt_read_property(node, name, &data, &size)) {
- return false;
- }
-
- switch (size) {
- case sizeof(uint32_t):
- case sizeof(uint64_t):
- *value = convert_number(data, size);
- break;
-
- default:
- return false;
- }
-
- return true;
-}
-
-bool fdt_write_number(struct fdt_node *node, const char *name, uint64_t value)
-{
- const char *data;
- uint32_t size;
- union {
- volatile uint64_t v;
- char a[8];
- } t;
-
- if (!fdt_read_property(node, name, &data, &size)) {
- return false;
- }
-
- switch (size) {
- case sizeof(uint32_t):
- *(uint32_t *)data = be32toh(value);
- break;
-
- case sizeof(uint64_t):
- t.v = be64toh(value);
- memcpy((void *)data, t.a, sizeof(uint64_t));
- break;
-
- default:
- return false;
- }
-
- return true;
-}
/**
- * Copies data to an unmapped location by mapping it for write, copying the
- * data, then unmapping it.
+ * Blocks the hypervisor.
+ *
+ * TODO: Determine if we want to omit strings on non-debug builds.
*/
-static bool copy_to_unmaped(paddr_t to, const void *from, size_t size)
+noreturn void panic(const char *fmt, ...)
{
- if (!mm_ptable_map(&ptable, (vaddr_t)to, (vaddr_t)to + size, to,
- MM_MODE_W | MM_MODE_STAGE1)) {
- return false;
+ va_list args;
+
+ /* TODO: Block all CPUs. */
+
+ dlog("Panic: ");
+
+ va_start(args, fmt);
+ vdlog(fmt, args);
+ va_end(args);
+
+ dlog("\n");
+
+ for (;;) {
}
-
- memcpy((void *)to, from, size);
-
- mm_ptable_unmap(&ptable, to, to + size, MM_MODE_STAGE1);
-
- return true;
-}
-
-static bool relocate(const char *from, size_t size)
-{
- /* TODO: This is a hack. We must read the alignment from the binary. */
- extern char bin_end[];
- size_t tmp = (size_t)&bin_end[0];
- paddr_t dest = (tmp + 0x80000 - 1) & ~(0x80000 - 1);
- dlog("bin_end is at %p, copying to %p\n", &bin_end[0], dest);
- return copy_to_unmaped(dest, from, size);
-}
-
-static void find_memory_range(const struct fdt_node *root,
- uint64_t *block_start, uint64_t *block_size)
-{
- struct fdt_node n = *root;
- const char *name;
- uint64_t address_size;
- uint64_t size_size;
- uint64_t entry_size;
-
- /* Get the sizes of memory range addresses and sizes. */
- if (fdt_read_number(&n, "#address-cells", &address_size)) {
- address_size *= sizeof(uint32_t);
- } else {
- address_size = sizeof(uint32_t);
- }
-
- if (fdt_read_number(&n, "#size-cells", &size_size)) {
- size_size *= sizeof(uint32_t);
- } else {
- size_size = sizeof(uint32_t);
- }
-
- entry_size = address_size + size_size;
-
- /* Look for nodes with the device_type set to "memory". */
- if (!fdt_first_child(&n, &name)) {
- return;
- }
-
- do {
- const char *data;
- uint32_t size;
- if (!fdt_read_property(&n, "device_type", &data, &size) ||
- size != sizeof("memory") ||
- memcmp(data, "memory", sizeof("memory")) != 0 ||
- !fdt_read_property(&n, "reg", &data, &size)) {
- continue;
- }
-
- /* Traverse all memory ranges within this node. */
- while (size >= entry_size) {
- uint64_t addr = convert_number(data, address_size);
- uint64_t len =
- convert_number(data + address_size, size_size);
-
- if (len > *block_size) {
- /* Remember the largest range we've found. */
- *block_start = addr;
- *block_size = len;
- }
-
- size -= entry_size;
- data += entry_size;
- }
- } while (fdt_next_sibling(&n, &name));
-
- /* TODO: Check for "reserved-memory" nodes. */
-}
-
-/**
- * Finds the memory region where initrd is stored, and udpates the fdt node
- * cursor to the node called "chosen".
- */
-static bool find_initrd(struct fdt_node *n, uint64_t *begin, uint64_t *end)
-{
- if (!fdt_find_node(n, "chosen\0")) {
- dlog("Unable to find 'chosen'\n");
- return false;
- }
-
- if (!fdt_read_number(n, "linux,initrd-start", begin)) {
- dlog("Unable to read linux,initrd-start\n");
- return false;
- }
-
- if (!fdt_read_number(n, "linux,initrd-end", end)) {
- dlog("Unable to read linux,initrd-end\n");
- return false;
- }
-
- return true;
-}
-
-struct memiter {
- const char *next;
- const char *limit;
-};
-
-static void memiter_init(struct memiter *it, const void *data, size_t size)
-{
- it->next = data;
- it->limit = it->next + size;
-}
-
-static bool memiter_isspace(struct memiter *it)
-{
- switch (*it->next) {
- case ' ':
- case '\t':
- case '\n':
- case '\r':
- return true;
- default:
- return false;
- }
-}
-
-static void memiter_skip_space(struct memiter *it)
-{
- while (it->next < it->limit && memiter_isspace(it)) {
- it->next++;
- }
-}
-
-static bool memiter_iseq(const struct memiter *it, const char *str)
-{
- size_t len = strlen(str);
- if (len != it->limit - it->next) {
- return false;
- }
- return memcmp(it->next, str, len) == 0;
-}
-
-static bool memiter_parse_str(struct memiter *it, struct memiter *str)
-{
- /* Skip all white space and fail if we reach the end of the buffer. */
- memiter_skip_space(it);
- if (it->next >= it->limit) {
- return false;
- }
-
- str->next = it->next;
-
- /* Find the end of the string. */
- while (it->next < it->limit && !memiter_isspace(it)) {
- it->next++;
- }
-
- str->limit = it->next;
-
- return true;
-}
-
-static bool memiter_parse_uint(struct memiter *it, uint64_t *value)
-{
- uint64_t v = 0;
-
- /* Skip all white space and fail if we reach the end of the buffer. */
- memiter_skip_space(it);
- if (it->next >= it->limit) {
- return false;
- }
-
- /* Fail if it's not a number. */
- if (*it->next < '0' || *it->next > '9') {
- return false;
- }
-
- /* Parse the number. */
- do {
- v = v * 10 + *it->next - '0';
- it->next++;
- } while (it->next < it->limit && *it->next >= '0' && *it->next <= '9');
-
- *value = v;
-
- return true;
-}
-
-static bool memiter_find_file(struct cpio *c, const struct memiter *filename,
- struct memiter *it)
-{
- const char *fname;
- const void *fcontents;
- size_t fsize;
- struct cpio_iter iter;
-
- cpio_init_iter(c, &iter);
-
- while (cpio_next(&iter, &fname, &fcontents, &fsize)) {
- if (memiter_iseq(filename, fname)) {
- memiter_init(it, fcontents, fsize);
- return true;
- }
- }
-
- return false;
-}
-
-static bool find_file(struct cpio *c, const char *name, struct memiter *it)
-{
- const char *fname;
- const void *fcontents;
- size_t fsize;
- struct cpio_iter iter;
-
- cpio_init_iter(c, &iter);
-
- while (cpio_next(&iter, &fname, &fcontents, &fsize)) {
- if (!strcmp(fname, name)) {
- memiter_init(it, fcontents, fsize);
- return true;
- }
- }
-
- return false;
-}
-
-static bool load_secondary(struct cpio *c, uint64_t mem_start,
- uint64_t *mem_size)
-{
- struct memiter it;
- struct memiter str;
- uint64_t mem;
- uint64_t cpu;
- uint32_t count;
-
- if (!find_file(c, "vms.txt", &it)) {
- dlog("Unable to find vms.txt\n");
- return false;
- }
-
- for (count = 0;
- memiter_parse_uint(&it, &mem) && memiter_parse_uint(&it, &cpu) &&
- memiter_parse_str(&it, &str) && count < MAX_VMS;
- count++) {
- struct memiter kernel;
-
- if (!memiter_find_file(c, &str, &kernel)) {
- dlog("Unable to load kernel for vm %u\n", count);
- continue;
- }
-
- if (mem > *mem_size) {
- dlog("Not enough memory for vm %u (%u bytes)\n", count,
- mem);
- continue;
- }
-
- if (mem < kernel.limit - kernel.next) {
- dlog("Kernel is larger than available memory for vm "
- "%u\n",
- count);
- continue;
- }
-
- *mem_size -= mem;
- if (!copy_to_unmaped(mem_start + *mem_size, kernel.next,
- kernel.limit - kernel.next)) {
- dlog("Unable to copy kernel for vm %u\n", count);
- continue;
- }
-
- dlog("Loaded VM%u with %u vcpus, entry at 0x%x\n", count, cpu,
- mem_start + *mem_size);
- vm_init(secondary_vm + count, cpu);
- vm_start_vcpu(secondary_vm + count, 0, mem_start + *mem_size, 0,
- false);
- }
-
- secondary_vm_count = count;
-
- return true;
-}
-
-static bool load_primary(struct cpio *c, struct fdt_node *chosen)
-{
- struct memiter it;
-
- if (!find_file(c, "vmlinuz", &it)) {
- dlog("Unable to find vmlinuz\n");
- return false;
- }
-
- if (!relocate(it.next, it.limit - it.next)) {
- dlog("Unable to relocate kernel for primary vm.\n");
- return false;
- }
-
- if (!find_file(c, "initrd.img", &it)) {
- dlog("Unable to find initrd.img\n");
- return false;
- }
-
- /* Patch FDT to point to new ramdisk. */
- if (!fdt_write_number(chosen, "linux,initrd-start", (size_t)it.next)) {
- dlog("Unable to write linux,initrd-start\n");
- return false;
- }
-
- if (!fdt_write_number(chosen, "linux,initrd-end", (size_t)it.limit)) {
- dlog("Unable to write linux,initrd-end\n");
- return false;
- }
-
- /*
- * Patch fdt to reserve memory.
- */
- {
- size_t tmp = (size_t)&relocate;
- tmp = (tmp + 0x80000 - 1) & ~(0x80000 - 1);
- fdt_add_mem_reservation(fdt, tmp & ~0xfffff, 0x80000);
- vm_init(&primary_vm, MAX_CPUS);
- vm_start_vcpu(&primary_vm, 0, tmp, (size_t)fdt, true);
- }
-
- return true;
}
/**
@@ -440,126 +43,58 @@
*/
static void one_time_init(void)
{
- extern char text_begin[];
- extern char text_end[];
- extern char rodata_begin[];
- extern char rodata_end[];
- extern char data_begin[];
- extern char data_end[];
+ struct boot_params params;
+ struct boot_params_update update;
+ uint64_t new_mem_end;
+ struct memiter primary_initrd;
+ struct cpio c;
- dlog("Initializing hafnium\n");
+ dlog("Initialising hafnium\n");
cpu_module_init();
halloc_init((size_t)ptable_buf, sizeof(ptable_buf));
- if (!mm_ptable_init(&ptable, MM_MODE_NOSYNC | MM_MODE_STAGE1)) {
- dlog("Unable to allocate memory for page table.\n");
- for (;;) {
- /* do nothing */
- }
+ if (!mm_init()) {
+ panic("mm_init failed");
}
- dlog("text: 0x%x - 0x%x\n", text_begin, text_end);
- dlog("rodata: 0x%x - 0x%x\n", rodata_begin, rodata_end);
- dlog("data: 0x%x - 0x%x\n", data_begin, data_end);
+ if (!plat_get_boot_params(¶ms)) {
+ panic("unable to retrieve boot params");
+ }
- /* Map page for uart. */
- mm_ptable_map_page(&ptable, PL011_BASE, PL011_BASE,
- MM_MODE_R | MM_MODE_W | MM_MODE_D | MM_MODE_NOSYNC |
- MM_MODE_STAGE1);
+ dlog("Memory range: 0x%x - 0x%x\n", params.mem_begin,
+ params.mem_end - 1);
+ dlog("Ramdisk range: 0x%x - 0x%x\n", params.initrd_begin,
+ params.initrd_end - 1);
- /* Map each section. */
- mm_ptable_map(&ptable, (vaddr_t)text_begin, (vaddr_t)text_end,
- (paddr_t)text_begin,
- MM_MODE_X | MM_MODE_NOSYNC | MM_MODE_STAGE1);
+ /* Map initrd in, and initialise cpio parser. */
+ if (!mm_map(params.initrd_begin, params.initrd_end, params.initrd_begin,
+ MM_MODE_R)) {
+ panic("unable to map initrd in");
+ }
- mm_ptable_map(&ptable, (vaddr_t)rodata_begin, (vaddr_t)rodata_end,
- (paddr_t)rodata_begin,
- MM_MODE_R | MM_MODE_NOSYNC | MM_MODE_STAGE1);
+ cpio_init(&c, (void *)params.initrd_begin,
+ params.initrd_end - params.initrd_begin);
- mm_ptable_map(&ptable, (vaddr_t)data_begin, (vaddr_t)data_end,
- (paddr_t)data_begin,
- MM_MODE_R | MM_MODE_W | MM_MODE_NOSYNC | MM_MODE_STAGE1);
+ /* Load all VMs. */
+ new_mem_end = params.mem_end;
+ load_secondary(&c, params.mem_begin, &new_mem_end);
+ if (!load_primary(&c, params.kernel_arg, &primary_initrd)) {
+ panic("unable to load primary VM");
+ }
- arch_mm_init((paddr_t)ptable.table);
+ /* Prepare to run by updating bootparams as seens by primary VM. */
+ update.initrd_begin = (paddr_t)primary_initrd.next;
+ update.initrd_end = (paddr_t)primary_initrd.limit;
+ update.reserved_begin = new_mem_end;
+ update.reserved_end = params.mem_end - new_mem_end;
+ if (!plat_update_boot_params(&update)) {
+ panic("plat_update_boot_params failed");
+ }
- /* TODO: Code below this point should be removed from this function. */
- do {
- struct fdt_node n;
- uint64_t mem_start = 0;
- uint64_t mem_size = 0;
- uint64_t new_mem_size;
+ mm_defrag();
- /* Map in the fdt header. */
- if (!mm_ptable_map(&ptable, (vaddr_t)fdt,
- (vaddr_t)fdt + fdt_header_size(),
- (paddr_t)fdt, MM_MODE_R | MM_MODE_STAGE1)) {
- dlog("Unable to map FDT header.\n");
- break;
- }
-
- /*
- * Map the rest of the fdt plus an extra page for adding new
- * memory reservations.
- */
- if (!mm_ptable_map(&ptable, (vaddr_t)fdt,
- (vaddr_t)fdt + fdt_total_size(fdt),
- (paddr_t)fdt, MM_MODE_R | MM_MODE_STAGE1)) {
- dlog("Unable to map FDT.\n");
- break;
- }
-
- fdt_root_node(&n, fdt);
- fdt_find_child(&n, "");
-
- find_memory_range(&n, &mem_start, &mem_size);
- dlog("Memory range: 0x%x - 0x%x\n", mem_start,
- mem_start + mem_size - 1);
-
- uint64_t begin;
- uint64_t end;
-
- if (!find_initrd(&n, &begin, &end)) {
- break;
- }
-
- dlog("Ramdisk range: 0x%x - 0x%x\n", begin, end - 1);
- mm_ptable_map(&ptable, begin, end, begin,
- MM_MODE_R | MM_MODE_STAGE1);
-
- struct cpio c;
- cpio_init(&c, (void *)begin, end - begin);
-
- /* Map the fdt in r/w mode in preparation for extending it. */
- if (!mm_ptable_map(
- &ptable, (vaddr_t)fdt,
- (vaddr_t)fdt + fdt_total_size(fdt) + PAGE_SIZE,
- (paddr_t)fdt,
- MM_MODE_R | MM_MODE_W | MM_MODE_STAGE1)) {
- dlog("Unable to map FDT in r/w mode.\n");
- break;
- }
- new_mem_size = mem_size;
- load_secondary(&c, mem_start, &new_mem_size);
- load_primary(&c, &n);
-
- /* Patch fdt to reserve memory for secondary VMs. */
- fdt_add_mem_reservation(fdt, mem_start + new_mem_size,
- mem_size - new_mem_size);
-
- /* Unmap FDT. */
- if (!mm_ptable_unmap(
- &ptable, (vaddr_t)fdt,
- (vaddr_t)fdt + fdt_total_size(fdt) + PAGE_SIZE,
- MM_MODE_STAGE1)) {
- dlog("Unable to unmap the FDT.\n");
- break;
- }
- } while (0);
-
- mm_ptable_defrag(&ptable);
-
- arch_set_vm_mm(&primary_vm.page_table);
+ dlog("Hafnium initialisation completed\n");
}
/**
@@ -570,8 +105,10 @@
{
struct cpu *c = cpu();
- /* Do global one-time initialization just once. We avoid using atomics
- * by only touching the variable from cpu 0. */
+ /*
+ * Do global one-time initialisation just once. We avoid using atomics
+ * by only touching the variable from cpu 0.
+ */
static volatile bool inited = false;
if (cpu_index(c) == 0 && !inited) {
inited = true;
diff --git a/src/memiter.c b/src/memiter.c
new file mode 100644
index 0000000..d3d37d2
--- /dev/null
+++ b/src/memiter.c
@@ -0,0 +1,103 @@
+#include "memiter.h"
+
+#include "std.h"
+
+/**
+ * Initialises the given memory iterator.
+ */
+void memiter_init(struct memiter *it, const void *data, size_t size)
+{
+ it->next = data;
+ it->limit = it->next + size;
+}
+
+/**
+ * Determines if the next character is a whitespace.
+ */
+static bool memiter_isspace(struct memiter *it)
+{
+ switch (*it->next) {
+ case ' ':
+ case '\t':
+ case '\n':
+ case '\r':
+ return true;
+ default:
+ return false;
+ }
+}
+
+/**
+ * Moves iterator to the next non-whitespace character.
+ */
+static void memiter_skip_space(struct memiter *it)
+{
+ while (it->next < it->limit && memiter_isspace(it)) {
+ it->next++;
+ }
+}
+
+/**
+ * Compares the iterator to a null-terminated string.
+ */
+bool memiter_iseq(const struct memiter *it, const char *str)
+{
+ size_t len = strlen(str);
+ if (len != it->limit - it->next) {
+ return false;
+ }
+ return memcmp(it->next, str, len) == 0;
+}
+
+/**
+ * Retrieves the next string that is delimited by whitespaces. The result is
+ * stored in "str".
+ */
+bool memiter_parse_str(struct memiter *it, struct memiter *str)
+{
+ /* Skip all white space and fail if we reach the end of the buffer. */
+ memiter_skip_space(it);
+ if (it->next >= it->limit) {
+ return false;
+ }
+
+ str->next = it->next;
+
+ /* Find the end of the string. */
+ while (it->next < it->limit && !memiter_isspace(it)) {
+ it->next++;
+ }
+
+ str->limit = it->next;
+
+ return true;
+}
+
+/**
+ * Parses the next string that represents a 64-bit number.
+ */
+bool memiter_parse_uint(struct memiter *it, uint64_t *value)
+{
+ uint64_t v = 0;
+
+ /* Skip all white space and fail if we reach the end of the buffer. */
+ memiter_skip_space(it);
+ if (it->next >= it->limit) {
+ return false;
+ }
+
+ /* Fail if it's not a number. */
+ if (*it->next < '0' || *it->next > '9') {
+ return false;
+ }
+
+ /* Parse the number. */
+ do {
+ v = v * 10 + *it->next - '0';
+ it->next++;
+ } while (it->next < it->limit && *it->next >= '0' && *it->next <= '9');
+
+ *value = v;
+
+ return true;
+}
diff --git a/src/mm.c b/src/mm.c
index 6662bae..236e763 100644
--- a/src/mm.c
+++ b/src/mm.c
@@ -14,6 +14,8 @@
/* clang-format on */
+static struct mm_ptable ptable;
+
/**
* Calculates the size of the address space represented by a page table entry at
* the given level.
@@ -309,10 +311,11 @@
* Defragments the given page table by converting page table references to
* blocks whenever possible.
*/
-void mm_ptable_defrag(struct mm_ptable *t)
+void mm_ptable_defrag(struct mm_ptable *t, int mode)
{
/* TODO: Implement. */
(void)t;
+ (void)mode;
}
/**
@@ -342,3 +345,72 @@
return true;
}
+
+/**
+ * Updates the hypervisor page table such that the given virtual address range
+ * is mapped to the given physical address range in the architecture-agnostic
+ * mode provided.
+ */
+bool mm_map(vaddr_t begin, vaddr_t end, paddr_t paddr, int mode)
+{
+ return mm_ptable_map(&ptable, begin, end, paddr, mode | MM_MODE_STAGE1);
+}
+
+/**
+ * Updates the hypervisor table such that the given virtual address range is not
+ * mapped to any physical address.
+ */
+bool mm_unmap(vaddr_t begin, vaddr_t end, int mode)
+{
+ return mm_ptable_unmap(&ptable, begin, end, mode | MM_MODE_STAGE1);
+}
+
+/**
+ * Initialises memory management for the hypervisor itself.
+ */
+bool mm_init(void)
+{
+ extern char text_begin[];
+ extern char text_end[];
+ extern char rodata_begin[];
+ extern char rodata_end[];
+ extern char data_begin[];
+ extern char data_end[];
+
+ dlog("text: 0x%x - 0x%x\n", text_begin, text_end);
+ dlog("rodata: 0x%x - 0x%x\n", rodata_begin, rodata_end);
+ dlog("data: 0x%x - 0x%x\n", data_begin, data_end);
+
+ if (!mm_ptable_init(&ptable, MM_MODE_NOSYNC | MM_MODE_STAGE1)) {
+ dlog("Unable to allocate memory for page table.\n");
+ return false;
+ }
+
+ /* Map page for uart. */
+ /* TODO: We may not want to map this. */
+ mm_ptable_map_page(&ptable, PL011_BASE, PL011_BASE,
+ MM_MODE_R | MM_MODE_W | MM_MODE_D | MM_MODE_NOSYNC |
+ MM_MODE_STAGE1);
+
+ /* Map each section. */
+ mm_map((vaddr_t)text_begin, (vaddr_t)text_end, (paddr_t)text_begin,
+ MM_MODE_X | MM_MODE_NOSYNC);
+
+ mm_map((vaddr_t)rodata_begin, (vaddr_t)rodata_end,
+ (paddr_t)rodata_begin, MM_MODE_R | MM_MODE_NOSYNC);
+
+ mm_map((vaddr_t)data_begin, (vaddr_t)data_end, (paddr_t)data_begin,
+ MM_MODE_R | MM_MODE_W | MM_MODE_NOSYNC);
+
+ arch_mm_init((paddr_t)ptable.table);
+
+ return true;
+}
+
+/**
+ * Defragments the hypervisor page table.
+ */
+void mm_defrag(void)
+{
+ mm_ptable_defrag(&ptable, MM_MODE_STAGE1);
+}
diff --git a/src/rules.mk b/src/rules.mk
index 0426fba..7d56def 100644
--- a/src/rules.mk
+++ b/src/rules.mk
@@ -2,8 +2,9 @@
SRCS += api.c
SRCS += cpio.c
SRCS += cpu.c
-SRCS += fdt.c
+SRCS += load.c
SRCS += main.c
+SRCS += memiter.c
SRCS += mm.c
SRCS += std.c
SRCS += vm.c
@@ -11,3 +12,8 @@
ifeq ($(DEBUG),1)
SRCS += dlog.c
endif
+
+ifeq ($(USE_FDT),1)
+ SRCS += fdt.c
+ SRCS += fdt_handler.c
+endif
