Make spike capable of booting Linux

Latest Linux does not boot Spike mainly because:
1. Spike does not set bootargs in DTS
2. Spike does not provide mechanism to load initrd for Linux

This patch addresses both above issues and we can now
get latest Linux to prompt on Spike.

Signed-off-by: Anup Patel <anup.patel@wdc.com>

riscv/dts.cc

@@ -9,6 +9,7 @@
 #include <sys/types.h>
 
 std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
+                     reg_t initrd_start, reg_t initrd_end,
                      std::vector<processor_t*> procs,
                      std::vector<std::pair<reg_t, mem_t*>> mems)
 {
@@ -21,6 +22,15 @@ std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
          "  #size-cells = <2>;\n"
          "  compatible = \"ucbbar,spike-bare-dev\";\n"
          "  model = \"ucbbar,spike-bare\";\n"
+         "  chosen {\n";
+  if (initrd_start < initrd_end) {
+    s << "    bootargs = \"root=/dev/ram console=hvc0 earlycon=sbi\";\n"
+         "    linux,initrd-start = <" << (size_t)initrd_start << ">;\n"
+         "    linux,initrd-end = <" << (size_t)initrd_end << ">;\n";
+  } else {
+    s << "    bootargs = \"console=hvc0 earlycon=sbi\";\n";
+  }
+    s << "  };\n"
          "  cpus {\n"
          "    #address-cells = <1>;\n"
          "    #size-cells = <0>;\n"

riscv/dts.h

@@ -7,6 +7,7 @@
 #include <string>
 
 std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
+                     reg_t initrd_start, reg_t initrd_end,
                      std::vector<processor_t*> procs,
                      std::vector<std::pair<reg_t, mem_t*>> mems);
 

riscv/sim.cc

@@ -26,14 +26,14 @@ static void handle_signal(int sig)
 }
 
 sim_t::sim_t(const char* isa, const char* priv, const char* varch,
-             size_t nprocs, bool halted,
+             size_t nprocs, bool halted, reg_t initrd_start, reg_t initrd_end,
              reg_t start_pc, std::vector<std::pair<reg_t, mem_t*>> mems,
              std::vector<std::pair<reg_t, abstract_device_t*>> plugin_devices,
              const std::vector<std::string>& args,
              std::vector<int> const hartids,
              const debug_module_config_t &dm_config)
   : htif_t(args), mems(mems), plugin_devices(plugin_devices),
-    procs(std::max(nprocs, size_t(1))), start_pc(start_pc), current_step(0),
+    procs(std::max(nprocs, size_t(1))), initrd_start(initrd_start), initrd_end(initrd_end), start_pc(start_pc), current_step(0),
     current_proc(0), debug(false), histogram_enabled(false),
     log_commits_enabled(false), dtb_enabled(true),
     remote_bitbang(NULL), debug_module(this, dm_config)
@@ -201,7 +201,7 @@ void sim_t::make_dtb()
 
   std::vector<char> rom((char*)reset_vec, (char*)reset_vec + sizeof(reset_vec));
 
-  dts = make_dts(INSNS_PER_RTC_TICK, CPU_HZ, procs, mems);
+  dts = make_dts(INSNS_PER_RTC_TICK, CPU_HZ, initrd_start, initrd_end, procs, mems);
   std::string dtb = dts_compile(dts);
 
   rom.insert(rom.end(), dtb.begin(), dtb.end());

riscv/sim.h

@@ -22,7 +22,7 @@ class sim_t : public htif_t, public simif_t
 {
 public:
   sim_t(const char* isa, const char* priv, const char* varch, size_t _nprocs,
-        bool halted,
+        bool halted, reg_t initrd_start, reg_t initrd_end,
         reg_t start_pc, std::vector<std::pair<reg_t, mem_t*>> mems,
         std::vector<std::pair<reg_t, abstract_device_t*>> plugin_devices,
         const std::vector<std::string>& args, const std::vector<int> hartids,
@@ -54,6 +54,8 @@ private:
   std::vector<std::pair<reg_t, abstract_device_t*>> plugin_devices;
   mmu_t* debug_mmu;  // debug port into main memory
   std::vector<processor_t*> procs;
+  reg_t initrd_start;
+  reg_t initrd_end;
   reg_t start_pc;
   std::string dts;
   std::unique_ptr<rom_device_t> boot_rom;

spike_main/spike.cc

@@ -12,6 +12,7 @@
 #include <vector>
 #include <string>
 #include <memory>
+#include <fstream>
 #include "../VERSION"
 
 static void help(int exit_code = 1)
@@ -49,6 +50,7 @@ static void help(int exit_code = 1)
   fprintf(stderr, "  --rbb-port=<port>     Listen on <port> for remote bitbang connection\n");
   fprintf(stderr, "  --dump-dts            Print device tree string and exit\n");
   fprintf(stderr, "  --disable-dtb         Don't write the device tree blob into memory\n");
+  fprintf(stderr, "  --initrd=<path>       Load kernel initrd into memory\n");
   fprintf(stderr, "  --dm-progsize=<words> Progsize for the debug module [default 2]\n");
   fprintf(stderr, "  --dm-sba=<bits>       Debug bus master supports up to "
       "<bits> wide accesses [default 0]\n");
@@ -70,6 +72,26 @@ static void suggest_help()
   exit(1);
 }
 
+static bool check_file_exists(const char *fileName)
+{
+  std::ifstream infile(fileName);
+  return infile.good();
+}
+
+static std::ifstream::pos_type get_file_size(const char *filename)
+{
+  std::ifstream in(filename, std::ios::ate | std::ios::binary);
+  return in.tellg();
+}
+
+static void read_file_bytes(const char *filename,size_t fileoff,
+                            char *read_buf, size_t read_sz)
+{
+  std::ifstream in(filename, std::ios::in | std::ios::binary);
+  in.seekg(fileoff, std::ios::beg);
+  in.read(read_buf, read_sz);
+}
+
 static std::vector<std::pair<reg_t, mem_t*>> make_mems(const char* arg)
 {
   // handle legacy mem argument
@@ -110,6 +132,8 @@ int main(int argc, char** argv)
   bool dump_dts = false;
   bool dtb_enabled = true;
   size_t nprocs = 1;
+  size_t initrd_size;
+  reg_t initrd_start = 0, initrd_end = 0;
   reg_t start_pc = reg_t(-1);
   std::vector<std::pair<reg_t, mem_t*>> mems;
   std::vector<std::pair<reg_t, abstract_device_t*>> plugin_devices;
@@ -119,6 +143,7 @@ int main(int argc, char** argv)
   bool log_cache = false;
   bool log_commits = false;
   std::function<extension_t*()> extension;
+  const char* initrd = NULL;
   const char* isa = DEFAULT_ISA;
   const char* priv = DEFAULT_PRIV;
   const char* varch = DEFAULT_VARCH;
@@ -215,6 +240,7 @@ int main(int argc, char** argv)
   parser.option(0, "extension", 1, [&](const char* s){extension = find_extension(s);});
   parser.option(0, "dump-dts", 0, [&](const char *s){dump_dts = true;});
   parser.option(0, "disable-dtb", 0, [&](const char *s){dtb_enabled = false;});
+  parser.option(0, "initrd", 1, [&](const char* s){initrd = s;});
   parser.option(0, "extlib", 1, [&](const char *s){
     void *lib = dlopen(s, RTLD_NOW | RTLD_GLOBAL);
     if (lib == NULL) {
@@ -248,7 +274,19 @@ int main(int argc, char** argv)
   if (!*argv1)
     help();
 
-  sim_t s(isa, priv, varch, nprocs, halted, start_pc, mems, plugin_devices, htif_args,
+  if (initrd && check_file_exists(initrd)) {
+    initrd_size = get_file_size(initrd);
+    for (auto& m : mems) {
+      if (initrd_size && (initrd_size + 0x1000) < m.second->size()) {
+         initrd_end = m.first + m.second->size() - 0x1000;
+         initrd_start = initrd_end - initrd_size;
+         read_file_bytes(initrd, 0, m.second->contents() + (initrd_start - m.first), initrd_size);
+         break;
+      }
+    }
+  }
+
+  sim_t s(isa, priv, varch, nprocs, halted, initrd_start, initrd_end, start_pc, mems, plugin_devices, htif_args,
       std::move(hartids), dm_config);
   std::unique_ptr<remote_bitbang_t> remote_bitbang((remote_bitbang_t *) NULL);
   std::unique_ptr<jtag_dtm_t> jtag_dtm(