Merge pull request #1721 from abejgonzalez/dts_parsing

Enable more configuration using the DTB

Author: aswaterman

riscv/dts.cc

@@ -13,14 +13,17 @@
 #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,
-                     const char* bootargs,
-                     size_t pmpregions,
-                     size_t pmpgranularity,
-                     std::vector<processor_t*> procs,
+                     const cfg_t* cfg,
                      std::vector<std::pair<reg_t, abstract_mem_t*>> mems,
                      std::string device_nodes)
 {
+  reg_t initrd_start = cfg->initrd_bounds.first;
+  reg_t initrd_end = cfg->initrd_bounds.second;
+  const char* bootargs = cfg->bootargs;
+  reg_t pmpregions = cfg->pmpregions;
+  reg_t pmpgranularity = cfg->pmpgranularity;
+  isa_parser_t isa(cfg->isa, cfg->priv);
+
   std::stringstream s;
   s << std::dec <<
          "/dts-v1/;\n"
@@ -54,14 +57,14 @@ std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
          "    #address-cells = <1>;\n"
          "    #size-cells = <0>;\n"
          "    timebase-frequency = <" << (cpu_hz/insns_per_rtc_tick) << ">;\n";
-  for (size_t i = 0; i < procs.size(); i++) {
+    for (size_t i = 0; i < cfg->nprocs(); i++) {
     s << "    CPU" << i << ": cpu@" << i << " {\n"
          "      device_type = \"cpu\";\n"
-         "      reg = <" << i << ">;\n"
+         "      reg = <" << cfg->hartids[i] << ">;\n"
          "      status = \"okay\";\n"
          "      compatible = \"riscv\";\n"
-         "      riscv,isa = \"" << procs[i]->get_isa().get_isa_string() << "\";\n"
-         "      mmu-type = \"riscv," << (procs[i]->get_isa().get_max_xlen() <= 32 ? "sv32" : "sv57") << "\";\n"
+         "      riscv,isa = \"" << isa.get_isa_string() << "\";\n"
+         "      mmu-type = \"riscv," << (isa.get_max_xlen() <= 32 ? "sv32" : "sv57") << "\";\n"
          "      riscv,pmpregions = <" << pmpregions << ">;\n"
          "      riscv,pmpgranularity = <" << pmpgranularity << ">;\n"
          "      clock-frequency = <" << cpu_hz << ">;\n"
@@ -96,86 +99,91 @@ std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
   return s.str();
 }
 
-std::string dts_compile(const std::string& dts)
+std::string dtc_compile(const std::string& dtc_input, const std::string& input_type, const std::string& output_type)
 {
-  // Convert the DTS to DTB
-  int dts_pipe[2];
-  pid_t dts_pid;
+  if (input_type == output_type)
+    std::cerr << "Must have differing {in,out}put types for running " DTC << std::endl;
+
+  if (!((input_type == "dts" && output_type == "dtb") || (input_type == "dtb" && output_type == "dts")))
+    std::cerr << "Invalid {in,out}put types for running " DTC ": Must convert from 'dts' to 'dtb' (or vice versa)" << std::endl;
+
+  int dtc_input_pipe[2];
+  pid_t dtc_input_pid;
 
   fflush(NULL); // flush stdout/stderr before forking
-  if (pipe(dts_pipe) != 0 || (dts_pid = fork()) < 0) {
-    std::cerr << "Failed to fork dts child: " << strerror(errno) << std::endl;
+  if (pipe(dtc_input_pipe) != 0 || (dtc_input_pid = fork()) < 0) {
+    std::cerr << "Failed to fork dtc_input child: " << strerror(errno) << std::endl;
     exit(1);
   }
 
-  // Child process to output dts
-  if (dts_pid == 0) {
-    close(dts_pipe[0]);
-    int step, len = dts.length();
-    const char *buf = dts.c_str();
+  // Child process to output dtc_input
+  if (dtc_input_pid == 0) {
+    close(dtc_input_pipe[0]);
+    int step, len = dtc_input.length();
+    const char *buf = dtc_input.c_str();
     for (int done = 0; done < len; done += step) {
-      step = write(dts_pipe[1], buf+done, len-done);
+      step = write(dtc_input_pipe[1], buf+done, len-done);
       if (step == -1) {
-        std::cerr << "Failed to write dts: " << strerror(errno) << std::endl;
+        std::cerr << "Failed to write dtc_input: " << strerror(errno) << std::endl;
         exit(1);
       }
     }
-    close(dts_pipe[1]);
+    close(dtc_input_pipe[1]);
     exit(0);
   }
 
-  pid_t dtb_pid;
-  int dtb_pipe[2];
-  if (pipe(dtb_pipe) != 0 || (dtb_pid = fork()) < 0) {
-    std::cerr << "Failed to fork dtb child: " << strerror(errno) << std::endl;
+  pid_t dtc_output_pid;
+  int dtc_output_pipe[2];
+  if (pipe(dtc_output_pipe) != 0 || (dtc_output_pid = fork()) < 0) {
+    std::cerr << "Failed to fork dtc_output child: " << strerror(errno) << std::endl;
     exit(1);
   }
 
-  // Child process to output dtb
-  if (dtb_pid == 0) {
-    dup2(dts_pipe[0], 0);
-    dup2(dtb_pipe[1], 1);
-    close(dts_pipe[0]);
-    close(dts_pipe[1]);
-    close(dtb_pipe[0]);
-    close(dtb_pipe[1]);
-    execlp(DTC, DTC, "-O", "dtb", (char *)0);
+  // Child process to output dtc_output
+  if (dtc_output_pid == 0) {
+    dup2(dtc_input_pipe[0], 0);
+    dup2(dtc_output_pipe[1], 1);
+    close(dtc_input_pipe[0]);
+    close(dtc_input_pipe[1]);
+    close(dtc_output_pipe[0]);
+    close(dtc_output_pipe[1]);
+    execlp(DTC, DTC, "-O", output_type.c_str(), "-I", input_type.c_str(), (char *)0);
     std::cerr << "Failed to run " DTC ": " << strerror(errno) << std::endl;
     exit(1);
   }
 
-  close(dts_pipe[1]);
-  close(dts_pipe[0]);
-  close(dtb_pipe[1]);
+  close(dtc_input_pipe[1]);
+  close(dtc_input_pipe[0]);
+  close(dtc_output_pipe[1]);
 
-  // Read-out dtb
-  std::stringstream dtb;
+  // Read-out dtc_output
+  std::stringstream dtc_output;
 
   int got;
   char buf[4096];
-  while ((got = read(dtb_pipe[0], buf, sizeof(buf))) > 0) {
-    dtb.write(buf, got);
+  while ((got = read(dtc_output_pipe[0], buf, sizeof(buf))) > 0) {
+    dtc_output.write(buf, got);
   }
   if (got == -1) {
-    std::cerr << "Failed to read dtb: " << strerror(errno) << std::endl;
+    std::cerr << "Failed to read dtc_output: " << strerror(errno) << std::endl;
     exit(1);
   }
-  close(dtb_pipe[0]);
+  close(dtc_output_pipe[0]);
 
   // Reap children
   int status;
-  waitpid(dts_pid, &status, 0);
+  waitpid(dtc_input_pid, &status, 0);
   if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
-    std::cerr << "Child dts process failed" << std::endl;
+    std::cerr << "Child dtc_input process failed" << std::endl;
     exit(1);
   }
-  waitpid(dtb_pid, &status, 0);
+  waitpid(dtc_output_pid, &status, 0);
   if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
-    std::cerr << "Child dtb process failed" << std::endl;
+    std::cerr << "Child dtc_output process failed" << std::endl;
     exit(1);
   }
 
-  return dtb.str();
+  return dtc_output.str();
 }
 
 int fdt_get_node_addr_size(const void *fdt, int node, reg_t *addr,
@@ -386,3 +394,44 @@ int fdt_parse_mmu_type(const void *fdt, int cpu_offset, const char **mmu_type)
 
   return 0;
 }
+
+int fdt_parse_isa(const void *fdt, int cpu_offset, const char **isa)
+{
+  assert(isa);
+
+  int len, rc;
+  const void *prop;
+
+  if ((rc = check_cpu_node(fdt, cpu_offset)) < 0)
+    return rc;
+
+  prop = fdt_getprop(fdt, cpu_offset, "riscv,isa", &len);
+  if (!prop || !len)
+    return -EINVAL;
+
+  *isa = (const char *)prop;
+
+  return 0;
+}
+
+int fdt_parse_hartid(const void *fdt, int cpu_offset, uint32_t *hartid)
+{
+  int len, rc;
+  const void *prop;
+  const fdt32_t *val;
+
+  if ((rc = check_cpu_node(fdt, cpu_offset)) < 0)
+    return rc;
+
+  val = (fdt32_t*) fdt_getprop(fdt, cpu_offset, "reg", &len);
+  if (!val || len < (int) sizeof(fdt32_t))
+    return -EINVAL;
+
+  if (len > (int) sizeof(fdt32_t))
+    val++;
+
+  if (hartid)
+    *hartid = fdt32_to_cpu(*val);
+
+  return 0;
+}

riscv/dts.h

@@ -7,15 +7,11 @@
 #include <string>
 
 std::string make_dts(size_t insns_per_rtc_tick, size_t cpu_hz,
-                     reg_t initrd_start, reg_t initrd_end,
-                     const char* bootargs,
-                     size_t pmpregions,
-                     size_t pmpgranularity,
-                     std::vector<processor_t*> procs,
+                     const cfg_t* cfg,
                      std::vector<std::pair<reg_t, abstract_mem_t*>> mems,
                      std::string device_nodes);
 
-std::string dts_compile(const std::string& dts);
+std::string dtc_compile(const std::string& dtc_input, const std::string& input_type, const std::string& output_type);
 
 int fdt_get_node_addr_size(const void *fdt, int node, reg_t *addr,
                            unsigned long *size, const char *field);
@@ -33,4 +29,6 @@ int fdt_parse_ns16550(const void *fdt, reg_t *ns16550_addr,
 int fdt_parse_pmp_num(const void *fdt, int cpu_offset, reg_t *pmp_num);
 int fdt_parse_pmp_alignment(const void *fdt, int cpu_offset, reg_t *pmp_align);
 int fdt_parse_mmu_type(const void *fdt, int cpu_offset, const char **mmu_type);
+int fdt_parse_isa(const void *fdt, int cpu_offset, const char **isa_str);
+int fdt_parse_hartid(const void *fdt, int cpu_offset, uint32_t *hartid);
 #endif

riscv/interactive.cc

@@ -342,8 +342,10 @@ void sim_t::interactive()
         (this->*funcs[cmd])(cmd, args);
       else
         out << "Unknown command " << cmd << std::endl;
-    } catch(trap_t& t) {
+    } catch(trap_interactive& t) {
       out << "Bad or missing arguments for command " << cmd << std::endl;
+    } catch(trap_t& t){
+      out << "Received trap: " << t.name() << std::endl;
     }
 #ifdef HAVE_BOOST_ASIO
     if (socketif)
@@ -473,15 +475,9 @@ void sim_t::interactive_insn(const std::string& cmd, const std::vector<std::stri
   int max_xlen = p->get_isa().get_max_xlen();
 
   std::ostream out(sout_.rdbuf());
-  try
-  {
-    insn_t insn(get_insn(args));
-    out << std::hex << std::setfill('0') << "0x" << std::setw(max_xlen/4)
-        << zext(insn.bits(), max_xlen) << " " << p->get_disassembler()->disassemble(insn) << std::endl;
-  }
-  catch (trap_t& t) {
-    out << "Unable to obtain insn due to " << t.name() << std::endl;
-  }
+  insn_t insn(get_insn(args)); // ensure this is outside of ostream to not pollute output on non-interactive trap
+  out << std::hex << std::setfill('0') << "0x" << std::setw(max_xlen/4)
+      << zext(insn.bits(), max_xlen) << " " << p->get_disassembler()->disassemble(insn) << std::endl;
 }
 
 void sim_t::interactive_priv(const std::string& cmd, const std::vector<std::string>& args)
@@ -717,8 +713,9 @@ void sim_t::interactive_mem(const std::string& cmd, const std::vector<std::strin
   int max_xlen = procs[0]->get_isa().get_max_xlen();
 
   std::ostream out(sout_.rdbuf());
+  reg_t mem_val = get_mem(args); // ensure this is outside of ostream to not pollute output on non-interactive trap
   out << std::hex << "0x" << std::setfill('0') << std::setw(max_xlen/4)
-      << zext(get_mem(args), max_xlen) << std::endl;
+      << zext(mem_val, max_xlen) << std::endl;
 }
 
 void sim_t::interactive_str(const std::string& cmd, const std::vector<std::string>& args)