dart_utils Namespace Reference

Classes
class	BuildInfo
class	BuildInfoTest
class	ElfSnapshot
class	MappedResource
class	RootInspectNode
class	VMServiceObject

Functions
	TEST_F (BuildInfoTest, AllPropertiesAreDefined)
	TEST_F (BuildInfoTest, AllPropertiesAreDumped)
bool	ReadFileToString (const std::string &path, std::string *result)
bool	ReadFileToStringAt (int dirfd, const std::string &path, std::string *result)
bool	WriteFile (const std::string &path, const char *data, ssize_t size)
void	HandleIfException (std::shared_ptr<::sys::ServiceDirectory > services, const std::string &component_url, Dart_Handle result)
void	HandleException (std::shared_ptr<::sys::ServiceDirectory > services, const std::string &component_url, const std::string &error, const std::string &stack_trace)
template<size_t SIZE, typename T >
size_t	ArraySize (T(&array)[SIZE])
static bool	OpenVmo (fuchsia::mem::Buffer *resource_vmo, fdio_ns_t *namespc, const std::string &path, bool executable)
static int	OpenFdExec (const std::string &path, int dirfd)
void	BindTemp (fdio_ns_t *ns)
bool	VmoFromFilename (const std::string &filename, bool executable, fuchsia::mem::Buffer *buffer)
bool	VmoFromFilenameAt (int dirfd, const std::string &filename, bool executable, fuchsia::mem::Buffer *buffer)
zx_status_t	IsSizeValid (const fuchsia::mem::Buffer &buffer, bool *is_valid)

Function Documentation

ArraySize()

template<size_t SIZE, typename T >

size_t dart_utils::ArraySize ( T(&)  array[SIZE] )

inline

Definition at line 11 of file inlines.h.

                                          {
  return SIZE;
}

Referenced by dart_runner::DartRunner::DartRunner().

BindTemp()

void dart_utils::BindTemp

(

fdio_ns_t *

ns

)

Definition at line 23 of file tempfs.cc.

                             {
  // TODO(zra): Should isolates share a /tmp file system within a process, or
  // should isolates each get their own private file system for /tmp? For now,
  // sharing the process-wide /tmp simplifies hot reload since the hot reload
  // devfs requires sharing between the service isolate and the app isolates.
  fdio_flat_namespace_t* rootns;
  if (zx_status_t status = fdio_ns_export_root(&rootns); status != ZX_OK) {
    FML_LOG(ERROR) << "Failed to export root ns: "
                   << zx_status_get_string(status);
    return;
  }
 
  zx_handle_t tmp_dir_handle;
  for (size_t i = 0; i < rootns->count; i++) {
    if (std::string_view{rootns->path[i]} == kTmpPath) {
      tmp_dir_handle = std::exchange(rootns->handle[i], ZX_HANDLE_INVALID);
    }
  }
  fdio_ns_free_flat_ns(rootns);
 
  if (zx_status_t status = fdio_ns_bind(ns, kTmpPath, tmp_dir_handle);
      status != ZX_OK) {
    zx_handle_close(tmp_dir_handle);
    FML_LOG(ERROR) << "Failed to bind /tmp directory into isolate namespace: "
                   << zx_status_get_string(status);
  }
}

References FML_LOG, and i.

HandleException()

void dart_utils::HandleException	(	std::shared_ptr<::sys::ServiceDirectory >	services,
		const std::string &	component_url,
		const std::string &	error,
		const std::string &	stack_trace
	)

Definition at line 105 of file handle_exception.cc.

                                                   {
  fuchsia::feedback::CrashReport crash_report =
      BuildCrashReport(component_url, error, stack_trace);
 
  fuchsia::feedback::CrashReporterPtr crash_reporter =
      services->Connect<fuchsia::feedback::CrashReporter>();
  crash_reporter->FileReport(
      std::move(crash_report),
      [](fuchsia::feedback::CrashReporter_FileReport_Result result) {
        if (result.is_err()) {
          FML_LOG(ERROR) << "Failed to report Dart exception: "
                         << static_cast<uint32_t>(result.err());
        }
      });
}

References error, and FML_LOG.

Referenced by HandleIfException().

HandleIfException()

void dart_utils::HandleIfException	(	std::shared_ptr<::sys::ServiceDirectory >	services,
		const std::string &	component_url,
		Dart_Handle	result
	)

Definition at line 90 of file handle_exception.cc.

                                           {
  if (!Dart_IsError(result) || !Dart_ErrorHasException(result)) {
    return;
  }
 
  const std::string error =
      tonic::StdStringFromDart(Dart_ToString(Dart_ErrorGetException(result)));
  const std::string stack_trace =
      tonic::StdStringFromDart(Dart_ToString(Dart_ErrorGetStackTrace(result)));
 
  return HandleException(services, component_url, error, stack_trace);
}

References error, HandleException(), and tonic::StdStringFromDart().

IsSizeValid()

zx_status_t dart_utils::IsSizeValid	(	const fuchsia::mem::Buffer &	buffer,
		bool *	is_valid
	)

Definition at line 90 of file vmo.cc.

                                                                        {
  size_t vmo_size;
  zx_status_t status = buffer.vmo.get_size(&vmo_size);
  if (status == ZX_OK) {
    *is_valid = vmo_size >= buffer.size;
  } else {
    *is_valid = false;
  }
  return status;
}

OpenFdExec()

static int dart_utils::OpenFdExec ( const std::string &  path, int  dirfd  )

static

Definition at line 104 of file mapped_resource.cc.

                                                        {
  int fd = -1;
  // fdio_open3_fd_at only allows relative paths
  const char* path_ptr = path.c_str();
  if (path_ptr && path_ptr[0] == '/') {
    ++path_ptr;
  }
  zx_status_t result = fdio_open3_fd_at(
      dirfd, path_ptr,
      uint64_t{fuchsia::io::PERM_READABLE | fuchsia::io::PERM_EXECUTABLE}, &fd);
  if (result != ZX_OK) {
    FML_LOG(ERROR) << "fdio_open3_fd_at(" << path << ") "
                   << "failed: " << zx_status_get_string(result);
    return -1;
  }
  return fd;
}

References FML_LOG.

Referenced by dart_utils::ElfSnapshot::Load().

OpenVmo()

static bool dart_utils::OpenVmo ( fuchsia::mem::Buffer *  resource_vmo, fdio_ns_t *  namespc, const std::string &  path, bool  executable  )

static

Definition at line 28 of file mapped_resource.cc.

                                     {
  TRACE_DURATION("dart", "LoadFromNamespace", "path", path);
 
  if (namespc == nullptr) {
    // Opening a file in the root namespace expects an absolute path.
    FML_CHECK(path[0] == '/');
    if (!VmoFromFilename(path, executable, resource_vmo)) {
      return false;
    }
  } else {
    // openat of a path with a leading '/' ignores the namespace fd.
    // require a relative path.
    FML_CHECK(path[0] != '/');
 
    auto root_dir = fdio_ns_opendir(namespc);
    if (root_dir < 0) {
      FML_LOG(ERROR) << "Failed to open namespace directory";
      return false;
    }
 
    bool result =
        dart_utils::VmoFromFilenameAt(root_dir, path, executable, resource_vmo);
    close(root_dir);
    if (!result) {
      return result;
    }
  }
 
  return true;
}

References FML_CHECK, FML_LOG, VmoFromFilename(), and VmoFromFilenameAt().

Referenced by dart_utils::MappedResource::LoadFromNamespace().

ReadFileToString()

bool dart_utils::ReadFileToString	(	const std::string &	path,
		std::string *	result
	)

Definition at line 56 of file files.cc.

                                                                {
  return ReadFileToStringAt(AT_FDCWD, path, result);
}

References ReadFileToStringAt().

Referenced by RegisterProfilerSymbols(), and flutter_runner::RegisterProfilerSymbols().

ReadFileToStringAt()

bool dart_utils::ReadFileToStringAt	(	int	dirfd,
		const std::string &	path,
		std::string *	result
	)

Definition at line 60 of file files.cc.

                                           {
  int fd = openat(dirfd, path.c_str(), O_RDONLY);
  bool status = ReadFileDescriptor(fd, result);
  close(fd);
  return status;
}

Referenced by ReadFileToString().

TEST_F() [1/2]

dart_utils::TEST_F	(	BuildInfoTest	,
		AllPropertiesAreDefined
	)

Definition at line 37 of file build_info_unittests.cc.

                                               {
  EXPECT_NE(BuildInfo::DartSdkGitRevision(), "{{DART_SDK_GIT_REVISION}}");
  EXPECT_NE(BuildInfo::DartSdkSemanticVersion(),
            "{{DART_SDK_SEMANTIC_VERSION}}");
  EXPECT_NE(BuildInfo::FlutterEngineGitRevision(),
            "{{FLUTTER_ENGINE_GIT_REVISION}}");
  EXPECT_NE(BuildInfo::FuchsiaSdkVersion(), "{{FUCHSIA_SDK_VERSION}}");
}

References dart_utils::BuildInfo::DartSdkGitRevision(), dart_utils::BuildInfo::DartSdkSemanticVersion(), dart_utils::BuildInfo::FlutterEngineGitRevision(), and dart_utils::BuildInfo::FuchsiaSdkVersion().

TEST_F() [2/2]

dart_utils::TEST_F	(	BuildInfoTest	,
		AllPropertiesAreDumped
	)

Definition at line 46 of file build_info_unittests.cc.

                                              {
  inspect::Node node =
      dart_utils::RootInspectNode::CreateRootChild(inspect_node_name);
  BuildInfo::Dump(node);
  inspect::Hierarchy root =
      inspect::ReadFromVmo(
          std::move(
              dart_utils::RootInspectNode::GetInspector()->DuplicateVmo()))
          .take_value();
  checkProperty(root, "dart_sdk_git_revision", BuildInfo::DartSdkGitRevision());
  checkProperty(root, "dart_sdk_semantic_version",
                BuildInfo::DartSdkSemanticVersion());
  checkProperty(root, "flutter_engine_git_revision",
                BuildInfo::FlutterEngineGitRevision());
  checkProperty(root, "fuchsia_sdk_version", BuildInfo::FuchsiaSdkVersion());
}

References checkProperty(), dart_utils::RootInspectNode::CreateRootChild(), dart_utils::BuildInfo::DartSdkGitRevision(), dart_utils::BuildInfo::DartSdkSemanticVersion(), dart_utils::BuildInfo::Dump(), dart_utils::BuildInfo::FlutterEngineGitRevision(), dart_utils::BuildInfo::FuchsiaSdkVersion(), dart_utils::RootInspectNode::GetInspector(), and inspect_node_name.

VmoFromFilename()

bool dart_utils::VmoFromFilename	(	const std::string &	filename,
		bool	executable,
		fuchsia::mem::Buffer *	buffer
	)

Definition at line 57 of file vmo.cc.

                                               {
  return VmoFromFilenameAt(AT_FDCWD, filename, executable, buffer);
}

References VmoFromFilenameAt().

Referenced by OpenVmo().

VmoFromFilenameAt()

bool dart_utils::VmoFromFilenameAt	(	int	dirfd,
		const std::string &	filename,
		bool	executable,
		fuchsia::mem::Buffer *	buffer
	)

Definition at line 63 of file vmo.cc.

                                                 {
  fuchsia::io::Flags flags = fuchsia::io::PERM_READABLE;
  if (executable) {
    flags |= fuchsia::io::PERM_EXECUTABLE;
  }
  // fdio_open3_fd_at only allows relative paths
  const char* path = filename.c_str();
  if (path && path[0] == '/') {
    ++path;
  }
  int fd;
  const zx_status_t status =
      fdio_open3_fd_at(dirfd, path, uint64_t{flags}, &fd);
  if (status != ZX_OK) {
    FML_LOG(ERROR) << "fdio_open3_fd_at(" << dirfd << ", \"" << filename
                   << "\", " << std::hex << uint64_t{flags}
                   << ") failed: " << zx_status_get_string(status);
    return false;
  }
  bool result = VmoFromFd(fd, executable, buffer);
  close(fd);
  return result;
}

References FML_LOG.

Referenced by flutter_runner::FileInNamespaceBuffer::FileInNamespaceBuffer(), OpenVmo(), and VmoFromFilename().

WriteFile()

bool dart_utils::WriteFile	(	const std::string &	path,
		const char *	data,
		ssize_t	size
	)

Definition at line 69 of file files.cc.

                                                                      {
  int fd = openat(AT_FDCWD, path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0666);
  if (fd < 0) {
    return false;
  }
  bool status = WriteFileDescriptor(fd, data, size);
  close(fd);
  return status;
}

References data.