zircon::dart::System Class Reference

#include <system.h>

Inheritance diagram for zircon::dart::System:

Static Public Member Functions
static Dart_Handle	ChannelCreate (uint32_t options)
static Dart_Handle	ChannelFromFile (std::string path)
static zx_status_t	ChannelWrite (fml::RefPtr< Handle > channel, const tonic::DartByteData &data, std::vector< Handle * > handles)
static zx_status_t	ChannelWriteEtc (fml::RefPtr< Handle > channel, const tonic::DartByteData &data, std::vector< HandleDisposition * > handle_dispositions)
static Dart_Handle	ChannelQueryAndRead (fml::RefPtr< Handle > channel)
static Dart_Handle	ChannelQueryAndReadEtc (fml::RefPtr< Handle > channel)
static Dart_Handle	EventpairCreate (uint32_t options)
static Dart_Handle	SocketCreate (uint32_t options)
static Dart_Handle	SocketWrite (fml::RefPtr< Handle > socket, const tonic::DartByteData &data, int options)
static Dart_Handle	SocketRead (fml::RefPtr< Handle > socket, size_t size)
static Dart_Handle	VmoCreate (uint64_t size, uint32_t options)
static Dart_Handle	VmoFromFile (std::string path)
static Dart_Handle	VmoGetSize (fml::RefPtr< Handle > vmo)
static zx_status_t	VmoSetSize (fml::RefPtr< Handle > vmo, uint64_t size)
static zx_status_t	VmoWrite (fml::RefPtr< Handle > vmo, uint64_t offset, const tonic::DartByteData &data)
static Dart_Handle	VmoRead (fml::RefPtr< Handle > vmo, uint64_t offset, size_t size)
static Dart_Handle	VmoMap (fml::RefPtr< Handle > vmo)
static uint64_t	ClockGetMonotonic ()
static void	RegisterNatives (tonic::DartLibraryNatives *natives)
static zx_status_t	ConnectToService (std::string path, fml::RefPtr< Handle > channel)

Additional Inherited Members
Public Types inherited from tonic::DartWrappable
enum	DartNativeFields { kPeerIndex , kNumberOfNativeFields }
Public Member Functions inherited from fml::RefCountedThreadSafe< System >
void	Release () const
Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const
Public Member Functions inherited from tonic::DartWrappable
	DartWrappable ()
virtual const DartWrapperInfo &	GetDartWrapperInfo () const =0
virtual void	RetainDartWrappableReference () const =0
virtual void	ReleaseDartWrappableReference () const =0
Dart_Handle	CreateDartWrapper (DartState *dart_state)
void	AssociateWithDartWrapper (Dart_Handle wrappable)
void	ClearDartWrapper ()
Dart_WeakPersistentHandle	dart_wrapper () const
Protected Member Functions inherited from fml::RefCountedThreadSafe< System >
	RefCountedThreadSafe ()
	~RefCountedThreadSafe ()
Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()
Protected Member Functions inherited from tonic::DartWrappable
virtual	~DartWrappable ()
Static Protected Member Functions inherited from tonic::DartWrappable
static Dart_PersistentHandle	GetTypeForWrapper (tonic::DartState *dart_state, const tonic::DartWrapperInfo &wrapper_info)

Detailed Description

Definition at line 20 of file system.h.

Member Function Documentation

ChannelCreate()

Dart_Handle zircon::dart::System::ChannelCreate ( uint32_t  options )

static

Definition at line 201 of file system.cc.

                                                  {
  zx_handle_t out0 = 0, out1 = 0;
  zx_status_t status = zx_channel_create(options, &out0, &out1);
  if (status != ZX_OK) {
    return ConstructDartObject(kHandlePairResult, ToDart(status));
  } else {
    return ConstructDartObject(kHandlePairResult, ToDart(status),
                               ToDart(Handle::Create(out0)),
                               ToDart(Handle::Create(out1)));
  }
}

ChannelFromFile()

Dart_Handle zircon::dart::System::ChannelFromFile ( std::string  path )

static

Definition at line 219 of file system.cc.

                                                  {
  fml::UniqueFD fd;
  if (zx_status_t status = FdFromPath(path.c_str(), fd); status != ZX_OK) {
    return ConstructDartObject(kHandleResult, ToDart(status));
  }
 
  zx::handle handle;
  if (zx_status_t status =
          fdio_fd_transfer(fd.release(), handle.reset_and_get_address());
      status != ZX_OK) {
    return ConstructDartObject(kHandleResult, ToDart(status));
  }
  zx_info_handle_basic_t info;
  if (zx_status_t status = handle.get_info(ZX_INFO_HANDLE_BASIC, &info,
                                           sizeof(info), nullptr, nullptr);
      status != ZX_OK) {
    return ConstructDartObject(kHandleResult, ToDart(status));
  }
  if (info.type != ZX_OBJ_TYPE_CHANNEL) {
    return ConstructDartObject(kHandleResult, ToDart(ZX_ERR_WRONG_TYPE));
  }
 
  return ConstructDartObject(kHandleResult, ToDart(ZX_OK),
                             ToDart(Handle::Create(handle.release())));
}

ChannelQueryAndRead()

Dart_Handle zircon::dart::System::ChannelQueryAndRead ( fml::RefPtr< Handle >  channel )

static

Definition at line 306 of file system.cc.

                                                                 {
  if (!channel || !channel->is_valid()) {
    return ConstructDartObject(kReadResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  uint32_t actual_bytes = 0;
  uint32_t actual_handles = 0;
 
  // Query the size of the next message.
  zx_status_t status = zx_channel_read(channel->handle(), 0, nullptr, nullptr,
                                       0, 0, &actual_bytes, &actual_handles);
  if (status != ZX_ERR_BUFFER_TOO_SMALL) {
    // An empty message or an error.
    return ConstructDartObject(kReadResult, ToDart(status));
  }
 
  // Allocate space for the bytes and handles.
  ByteDataScope bytes(actual_bytes);
  FML_DCHECK(bytes.is_valid());
  std::vector<zx_handle_t> handles(actual_handles);
 
  // Make the call to actually get the message.
  status = zx_channel_read(channel->handle(), 0, bytes.data(), handles.data(),
                           bytes.size(), handles.size(), &actual_bytes,
                           &actual_handles);
  FML_DCHECK(status != ZX_OK || bytes.size() == actual_bytes);
 
  bytes.Release();
 
  if (status == ZX_OK) {
    FML_DCHECK(handles.size() == actual_handles);
 
    // return a ReadResult object.
    return ConstructDartObject(kReadResult, ToDart(status), bytes.dart_handle(),
                               ToDart(actual_bytes), MakeHandleList(handles));
  } else {
    return ConstructDartObject(kReadResult, ToDart(status));
  }
}

ChannelQueryAndReadEtc()

Dart_Handle zircon::dart::System::ChannelQueryAndReadEtc ( fml::RefPtr< Handle >  channel )

static

Definition at line 346 of file system.cc.

                                                                    {
  if (!channel || !channel->is_valid()) {
    return ConstructDartObject(kReadEtcResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  uint32_t actual_bytes = 0;
  uint32_t actual_handles = 0;
 
  // Query the size of the next message.
  zx_status_t status = zx_channel_read(channel->handle(), 0, nullptr, nullptr,
                                       0, 0, &actual_bytes, &actual_handles);
  if (status != ZX_ERR_BUFFER_TOO_SMALL) {
    // An empty message or an error.
    return ConstructDartObject(kReadEtcResult, ToDart(status));
  }
 
  // Allocate space for the bytes and handles.
  ByteDataScope bytes(actual_bytes);
  FML_DCHECK(bytes.is_valid());
  std::vector<zx_handle_info_t> handles(actual_handles);
 
  // Make the call to actually get the message.
  status = zx_channel_read_etc(channel->handle(), 0, bytes.data(),
                               handles.data(), bytes.size(), handles.size(),
                               &actual_bytes, &actual_handles);
  FML_DCHECK(status != ZX_OK || bytes.size() == actual_bytes);
 
  bytes.Release();
 
  if (status == ZX_OK) {
    FML_DCHECK(handles.size() == actual_handles);
 
    // return a ReadResult object.
    return ConstructDartObject(kReadEtcResult, ToDart(status),
                               bytes.dart_handle(), ToDart(actual_bytes),
                               MakeHandleInfoList(handles));
  } else {
    return ConstructDartObject(kReadEtcResult, ToDart(status));
  }
}

ChannelWrite()

zx_status_t zircon::dart::System::ChannelWrite ( fml::RefPtr< Handle >  channel, const tonic::DartByteData &  data, std::vector< Handle * >  handles  )

static

Definition at line 245 of file system.cc.

                                                             {
  if (!channel || !channel->is_valid()) {
    data.Release();
    return ZX_ERR_BAD_HANDLE;
  }
 
  std::vector<zx_handle_t> zx_handles;
  for (Handle* handle : handles) {
    zx_handles.push_back(handle->handle());
  }
 
  zx_status_t status = zx_channel_write(channel->handle(), 0, data.data(),
                                        data.length_in_bytes(),
                                        zx_handles.data(), zx_handles.size());
  // Handles are always consumed.
  for (Handle* handle : handles) {
    handle->ReleaseHandle();
  }
 
  data.Release();
  return status;
}

ChannelWriteEtc()

zx_status_t zircon::dart::System::ChannelWriteEtc ( fml::RefPtr< Handle >  channel, const tonic::DartByteData &  data, std::vector< HandleDisposition * >  handle_dispositions  )

static

Definition at line 270 of file system.cc.

                                                       {
  if (!channel || !channel->is_valid()) {
    data.Release();
    return ZX_ERR_BAD_HANDLE;
  }
 
  std::vector<zx_handle_disposition_t> zx_handle_dispositions;
  for (HandleDisposition* handle : handle_dispositions) {
    FML_DCHECK(handle->result() == ZX_OK);
    zx_handle_dispositions.push_back({.operation = handle->operation(),
                                      .handle = handle->handle()->handle(),
                                      .type = handle->type(),
                                      .rights = handle->rights(),
                                      .result = ZX_OK});
  }
 
  zx_status_t status = zx_channel_write_etc(
      channel->handle(), 0, data.data(), data.length_in_bytes(),
      zx_handle_dispositions.data(), zx_handle_dispositions.size());
 
  for (size_t i = 0; i < handle_dispositions.size(); ++i) {
    handle_dispositions[i]->set_result(zx_handle_dispositions[i].result);
 
    // Handles that are not copied (i.e. moved) are always consumed.
    if (handle_dispositions[i]->operation() != ZX_HANDLE_OP_DUPLICATE) {
      handle_dispositions[i]->handle()->ReleaseHandle();
    }
  }
 
  data.Release();
  return status;
}

ClockGetMonotonic()

uint64_t zircon::dart::System::ClockGetMonotonic ( )

static

Definition at line 571 of file system.cc.

                                   {
  return zx_clock_get_monotonic();
}

ConnectToService()

zx_status_t zircon::dart::System::ConnectToService ( std::string  path, fml::RefPtr< Handle >  channel  )

static

Definition at line 213 of file system.cc.

                                                                {
  return fdio_ns_service_connect(GetNamespace(), path.c_str(),
                                 channel->ReleaseHandle());
}

EventpairCreate()

Dart_Handle zircon::dart::System::EventpairCreate ( uint32_t  options )

static

Definition at line 387 of file system.cc.

                                                    {
  zx_handle_t out0 = 0, out1 = 0;
  zx_status_t status = zx_eventpair_create(0, &out0, &out1);
  if (status != ZX_OK) {
    return ConstructDartObject(kHandlePairResult, ToDart(status));
  } else {
    return ConstructDartObject(kHandlePairResult, ToDart(status),
                               ToDart(Handle::Create(out0)),
                               ToDart(Handle::Create(out1)));
  }
}

RegisterNatives()

void zircon::dart::System::RegisterNatives ( tonic::DartLibraryNatives *  natives )

static

Definition at line 606 of file system.cc.

                                                             {
  natives->Register({FOR_EACH_STATIC_BINDING(DART_REGISTER_NATIVE_STATIC_)});
}

SocketCreate()

Dart_Handle zircon::dart::System::SocketCreate ( uint32_t  options )

static

Definition at line 399 of file system.cc.

                                                 {
  zx_handle_t out0 = 0, out1 = 0;
  zx_status_t status = zx_socket_create(options, &out0, &out1);
  if (status != ZX_OK) {
    return ConstructDartObject(kHandlePairResult, ToDart(status));
  } else {
    return ConstructDartObject(kHandlePairResult, ToDart(status),
                               ToDart(Handle::Create(out0)),
                               ToDart(Handle::Create(out1)));
  }
}

SocketRead()

Dart_Handle zircon::dart::System::SocketRead ( fml::RefPtr< Handle >  socket, size_t  size  )

static

Definition at line 426 of file system.cc.

                                                                    {
  if (!socket || !socket->is_valid()) {
    return ConstructDartObject(kReadResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  ByteDataScope bytes(size);
  size_t actual;
  zx_status_t status =
      zx_socket_read(socket->handle(), 0, bytes.data(), size, &actual);
  bytes.Release();
  if (status == ZX_OK) {
    FML_DCHECK(actual <= size);
    return ConstructDartObject(kReadResult, ToDart(status), bytes.dart_handle(),
                               ToDart(actual));
  }
 
  return ConstructDartObject(kReadResult, ToDart(status));
}

SocketWrite()

Dart_Handle zircon::dart::System::SocketWrite ( fml::RefPtr< Handle >  socket, const tonic::DartByteData &  data, int  options  )

static

Definition at line 411 of file system.cc.

                                             {
  if (!socket || !socket->is_valid()) {
    data.Release();
    return ConstructDartObject(kWriteResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  size_t actual;
  zx_status_t status = zx_socket_write(socket->handle(), options, data.data(),
                                       data.length_in_bytes(), &actual);
  data.Release();
  return ConstructDartObject(kWriteResult, ToDart(status), ToDart(actual));
}

VmoCreate()

Dart_Handle zircon::dart::System::VmoCreate ( uint64_t  size, uint32_t  options  )

static

Definition at line 445 of file system.cc.

                                                             {
  zx_handle_t vmo = ZX_HANDLE_INVALID;
  zx_status_t status = zx_vmo_create(size, options, &vmo);
  if (status != ZX_OK) {
    return ConstructDartObject(kHandleResult, ToDart(status));
  } else {
    return ConstructDartObject(kHandleResult, ToDart(status),
                               ToDart(Handle::Create(vmo)));
  }
}

VmoFromFile()

Dart_Handle zircon::dart::System::VmoFromFile ( std::string  path )

static

Definition at line 456 of file system.cc.

                                              {
  fml::UniqueFD fd;
  if (zx_status_t status = FdFromPath(path.c_str(), fd); status != ZX_OK) {
    return ConstructDartObject(kHandleResult, ToDart(status));
  }
 
  struct stat stat_struct;
  if (fstat(fd.get(), &stat_struct) != 0) {
    // TODO: can we return errno?
    return ConstructDartObject(kFromFileResult, ToDart(ZX_ERR_IO));
  }
  zx::vmo vmo;
  if (zx_status_t status =
          fdio_get_vmo_clone(fd.get(), vmo.reset_and_get_address());
      status != ZX_OK) {
    return ConstructDartObject(kFromFileResult, ToDart(status));
  }
 
  return ConstructDartObject(kFromFileResult, ToDart(ZX_OK),
                             ToDart(Handle::Create(vmo.release())),
                             ToDart(stat_struct.st_size));
}

VmoGetSize()

Dart_Handle zircon::dart::System::VmoGetSize ( fml::RefPtr< Handle >  vmo )

static

Definition at line 479 of file system.cc.

                                                    {
  if (!vmo || !vmo->is_valid()) {
    return ConstructDartObject(kGetSizeResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  uint64_t size;
  zx_status_t status = zx_vmo_get_size(vmo->handle(), &size);
 
  return ConstructDartObject(kGetSizeResult, ToDart(status), ToDart(size));
}

VmoMap()

Dart_Handle zircon::dart::System::VmoMap ( fml::RefPtr< Handle >  vmo )

static

Definition at line 543 of file system.cc.

                                                {
  if (!vmo || !vmo->is_valid())
    return ConstructDartObject(kMapResult, ToDart(ZX_ERR_BAD_HANDLE));
 
  uint64_t size;
  zx_status_t status = zx_vmo_get_size(vmo->handle(), &size);
  if (status != ZX_OK)
    return ConstructDartObject(kMapResult, ToDart(status));
 
  uintptr_t mapped_addr;
  status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo->handle(),
                       0, size, &mapped_addr);
  if (status != ZX_OK)
    return ConstructDartObject(kMapResult, ToDart(status));
 
  void* data = reinterpret_cast<void*>(mapped_addr);
  Dart_Handle object = Dart_NewExternalTypedData(Dart_TypedData_kUint8, data,
                                                 static_cast<intptr_t>(size));
  FML_DCHECK(!tonic::CheckAndHandleError(object));
 
  SizedRegion* r = new SizedRegion(data, size);
  Dart_NewFinalizableHandle(object, reinterpret_cast<void*>(r),
                            static_cast<intptr_t>(size) + sizeof(*r),
                            System::VmoMapFinalizer);
 
  return ConstructDartObject(kMapResult, ToDart(ZX_OK), object);
}

VmoRead()

Dart_Handle zircon::dart::System::VmoRead ( fml::RefPtr< Handle >  vmo, uint64_t  offset, size_t  size  )

static

Definition at line 512 of file system.cc.

                                         {
  if (!vmo || !vmo->is_valid()) {
    return ConstructDartObject(kReadResult, ToDart(ZX_ERR_BAD_HANDLE));
  }
 
  // TODO: constrain size?
  ByteDataScope bytes(size);
  zx_status_t status = zx_vmo_read(vmo->handle(), bytes.data(), offset, size);
  bytes.Release();
  if (status == ZX_OK) {
    return ConstructDartObject(kReadResult, ToDart(status), bytes.dart_handle(),
                               ToDart(size));
  }
  return ConstructDartObject(kReadResult, ToDart(status));
}

VmoSetSize()

zx_status_t zircon::dart::System::VmoSetSize ( fml::RefPtr< Handle >  vmo, uint64_t  size  )

static

Definition at line 490 of file system.cc.

                                                                   {
  if (!vmo || !vmo->is_valid()) {
    return ZX_ERR_BAD_HANDLE;
  }
  return zx_vmo_set_size(vmo->handle(), size);
}

VmoWrite()

zx_status_t zircon::dart::System::VmoWrite ( fml::RefPtr< Handle >  vmo, uint64_t  offset, const tonic::DartByteData &  data  )

static

Definition at line 497 of file system.cc.

                                                            {
  if (!vmo || !vmo->is_valid()) {
    data.Release();
    return ZX_ERR_BAD_HANDLE;
  }
 
  zx_status_t status =
      zx_vmo_write(vmo->handle(), data.data(), offset, data.length_in_bytes());
 
  data.Release();
  return status;
}

---

The documentation for this class was generated from the following files:

• shell/platform/fuchsia/dart-pkg/zircon/sdk_ext/system.h
• shell/platform/fuchsia/dart-pkg/zircon/sdk_ext/system.cc