[vm] Make ELF loader Fuchsia compatible.

Change-Id: I519fb04c6bf1fbef53a833957c714f3a1e394f21
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127641
Commit-Queue: Samir Jindel <sjindel@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>

Author: sjindel-google

runtime/bin/BUILD.gn

@@ -124,23 +124,35 @@ static_library("crashpad") {
   }
 }
 
-static_library("elf_loader") {
-  configs += [
-    "..:dart_arch_config",
-    "..:dart_config",
-    "..:dart_product_config",
-    "..:dart_os_fuchsia_config",
-  ]
-  include_dirs = [ ".." ]
-  sources = [
-    "elf_loader.cc",
-    "elf_loader.h",
-  ]
+template("build_elf_loader") {
+  source_set(target_name) {
+    configs += [
+      "..:dart_arch_config",
+      "..:dart_config",
+      "..:dart_product_config",
+      "..:dart_os_fuchsia_config",
+    ]
+    include_dirs = [ ".." ]
+    sources = [
+      "elf_loader.cc",
+      "elf_loader.h",
+    ]
+    deps = invoker.deps
+  }
+}
+
+build_elf_loader("elf_loader") {
   deps = [
     ":libdart_builtin",
   ]
 }
 
+build_elf_loader("elf_loader_product") {
+  deps = [
+    ":libdart_builtin_product",
+  ]
+}
+
 template("build_gen_snapshot") {
   extra_configs = []
   if (defined(invoker.extra_configs)) {

runtime/bin/elf_loader.cc

@@ -9,6 +9,10 @@
 #include <vm/cpu.h>
 #include <vm/virtual_memory.h>
 
+#if defined(HOST_OS_FUCHSIA)
+#include <sys/mman.h>
+#endif
+
 #include <memory>
 
 namespace dart {
@@ -20,9 +24,15 @@ namespace elf {
 /// Dart_CreateAppAOTSnapshotAsElf.
 class LoadedElf {
  public:
+#if defined(HOST_OS_FUCHSIA)
+  explicit LoadedElf(int fd, uint64_t elf_data_offset)
+      : fd_(fd), elf_data_offset_(elf_data_offset) {}
+#else
   explicit LoadedElf(const char* filename, uint64_t elf_data_offset)
       : filename_(strdup(filename), std::free),
         elf_data_offset_(elf_data_offset) {}
+#endif
+
   ~LoadedElf();
 
   /// Loads the ELF object into memory. Returns whether the load was successful.
@@ -61,7 +71,11 @@ class LoadedElf {
                              uword length,
                              const void** mapping_start);
 
+#if defined(HOST_OS_FUCHSIA)
+  int fd_ = -1;
+#else
   std::unique_ptr<char, decltype(std::free)*> filename_;
+#endif
   const uint64_t elf_data_offset_;
 
   // Initialized on a successful Load().
@@ -124,8 +138,12 @@ bool LoadedElf::Load() {
   CHECK_ERROR(Utils::IsAligned(elf_data_offset_, PageSize()),
               "File offset must be page-aligned.");
 
+#if defined(HOST_OS_FUCHSIA)
+  file_ = File::OpenFD(fd_);
+#else
   file_ = File::Open(/*namespc=*/nullptr, filename_.get(),
                      bin::File::FileOpenMode::kRead);
+#endif
   CHECK_ERROR(file_ != nullptr, "Cannot open ELF object file.");
   CHECK_ERROR(file_->SetPosition(elf_data_offset_), "Invalid file offset.");
 
@@ -249,7 +267,7 @@ bool LoadedElf::LoadSegments() {
 
   base_.reset(VirtualMemory::AllocateAligned(
       total_memory, /*alignment=*/maximum_alignment,
-      /*is_executable=*/false, /*mapping name=*/filename_.get()));
+      /*is_executable=*/false, /*mapping name=*/nullptr));
   CHECK_ERROR(base_ != nullptr, "Could not reserve virtual memory.");
 
   for (uword i = 0; i < header_.num_program_headers; ++i) {
@@ -282,6 +300,27 @@ bool LoadedElf::LoadSegments() {
       ERROR("Unsupported segment flag set.");
     }
 
+#if defined(HOST_OS_FUCHSIA)
+    // mmap is less flexible on Fuchsia than on Linux and Darwin, in (at least)
+    // two important ways:
+    //
+    // 1. We cannot map a file opened as RX into an RW mapping, even if the
+    //    mode is MAP_PRIVATE (which implies copy-on-write).
+    // 2. We cannot atomically replace an existing anonymous mapping with a
+    //    file mapping: we must first unmap the existing mapping.
+
+    if (map_type == File::kReadWrite) {
+      CHECK_ERROR(file_->SetPosition(file_start),
+                  "Could not advance file position.");
+      CHECK_ERROR(file_->ReadFully(memory_start, length),
+                  "Could not read file.");
+      continue;
+    }
+
+    CHECK_ERROR(munmap(memory_start, length) == 0,
+                "Could not unmap reservation.");
+#endif
+
     std::unique_ptr<MappedMemory> memory(
         file_->Map(map_type, file_start, length, memory_start));
     CHECK_ERROR(memory != nullptr, "Could not map segment.");
@@ -376,6 +415,27 @@ MappedMemory* LoadedElf::MapFilePiece(uword file_start,
 }  // namespace bin
 }  // namespace dart
 
+#if defined(HOST_OS_FUCHSIA)
+DART_EXPORT Dart_LoadedElf* Dart_LoadELF_Fd(int fd,
+                                            uint64_t file_offset,
+                                            const char** error,
+                                            const uint8_t** vm_snapshot_data,
+                                            const uint8_t** vm_snapshot_instrs,
+                                            const uint8_t** vm_isolate_data,
+                                            const uint8_t** vm_isolate_instrs) {
+  std::unique_ptr<dart::bin::elf::LoadedElf> elf(
+      new dart::bin::elf::LoadedElf(fd, file_offset));
+
+  if (!elf->Load() ||
+      !elf->ResolveSymbols(vm_snapshot_data, vm_snapshot_instrs,
+                           vm_isolate_data, vm_isolate_instrs)) {
+    *error = elf->error();
+    return nullptr;
+  }
+
+  return reinterpret_cast<Dart_LoadedElf*>(elf.release());
+}
+#else
 DART_EXPORT Dart_LoadedElf* Dart_LoadELF(const char* filename,
                                          uint64_t file_offset,
                                          const char** error,
@@ -396,6 +456,8 @@ DART_EXPORT Dart_LoadedElf* Dart_LoadELF(const char* filename,
   return reinterpret_cast<Dart_LoadedElf*>(elf.release());
 }
 
+#endif
+
 DART_EXPORT void Dart_UnloadELF(Dart_LoadedElf* loaded) {
   delete reinterpret_cast<dart::bin::elf::LoadedElf*>(loaded);
 }

runtime/bin/elf_loader.h

@@ -10,25 +10,37 @@
 typedef struct {
 } Dart_LoadedElf;
 
-/// Loads an ELF object in 'filename'.
+/// Load an ELF object from a file.
 ///
-/// On success, returns a handle to the library which may be used to close it
+/// On success, return a handle to the library which may be used to close it
 /// in Dart_UnloadELF. On error, returns 'nullptr' and sets 'error'. The error
 /// string should not be 'free'-d.
 ///
 /// `file_offset` may be non-zero to read an ELF object embedded inside another
 /// type of file.
 ///
-/// Looks up the Dart snapshot symbols "_kVmSnapshotData",
+/// Look up the Dart snapshot symbols "_kVmSnapshotData",
 /// "_kVmSnapshotInstructions", "_kVmIsolateData" and "_kVmIsolateInstructions"
 /// into the respectively named out-parameters.
+///
+/// On Fuchsia, Dart_LoadELF_Fd takes ownership of the file descriptor.
+#if defined(__Fuchsia__)
+DART_EXPORT Dart_LoadedElf* Dart_LoadELF_Fd(int fd,
+                                            uint64_t file_offset,
+                                            const char** error,
+                                            const uint8_t** vm_snapshot_data,
+                                            const uint8_t** vm_snapshot_instrs,
+                                            const uint8_t** vm_isolate_data,
+                                            const uint8_t** vm_isolate_instrs);
+#else
 DART_EXPORT Dart_LoadedElf* Dart_LoadELF(const char* filename,
                                          uint64_t file_offset,
                                          const char** error,
                                          const uint8_t** vm_snapshot_data,
                                          const uint8_t** vm_snapshot_instrs,
                                          const uint8_t** vm_isolate_data,
                                          const uint8_t** vm_isolate_instrs);
+#endif
 
 DART_EXPORT void Dart_UnloadELF(Dart_LoadedElf* loaded);
 

runtime/bin/file.h

@@ -213,6 +213,10 @@ class File : public ReferenceCounted<File> {
   // (stdin, stout or stderr).
   static File* OpenStdio(int fd);
 
+#if defined(HOST_OS_FUCHSIA)
+  static File* OpenFD(int fd);
+#endif
+
   static bool Exists(Namespace* namespc, const char* path);
   static bool Create(Namespace* namespc, const char* path);
   static bool CreateLink(Namespace* namespc,

runtime/bin/file_fuchsia.cc

@@ -202,6 +202,10 @@ File* File::FileOpenW(const wchar_t* system_name, FileOpenMode mode) {
   return NULL;
 }
 
+File* File::OpenFD(int fd) {
+  return new File(new FileHandle(fd));
+}
+
 File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) {
   NamespaceScope ns(namespc, name);
   // Report errors for non-regular files.
@@ -236,7 +240,7 @@ File* File::Open(Namespace* namespc, const char* name, FileOpenMode mode) {
       return NULL;
     }
   }
-  return new File(new FileHandle(fd));
+  return OpenFD(fd);
 }
 
 File* File::OpenUri(Namespace* namespc, const char* uri, FileOpenMode mode) {