zircon/kernel/object/vm_object_dispatcher.cpp - fuchsia - Git at Google

 // Copyright 2016 The Fuchsia Authors
 //
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT

 #include <object/vm_object_dispatcher.h>

 #include <vm/vm_aspace.h>
 #include <vm/vm_object.h>
 #include <vm/vm_object_paged.h>

 #include <zircon/rights.h>

 #include <fbl/alloc_checker.h>
 #include <lib/counters.h>

 #include <assert.h>
 #include <err.h>
 #include <inttypes.h>
 #include <trace.h>

 #define LOCAL_TRACE 0

 KCOUNTER(dispatcher_vmo_create_count, "dispatcher.vmo.create")
 KCOUNTER(dispatcher_vmo_destroy_count, "dispatcher.vmo.destroy")

 zx_status_t VmObjectDispatcher::parse_create_syscall_flags(uint32_t flags, uint32_t* out_flags) {
     uint32_t res = 0;
     if (flags & ZX_VMO_NON_RESIZABLE) {
         flags &= ~ZX_VMO_NON_RESIZABLE;
     } else {
         flags &= ~ZX_VMO_RESIZABLE;
         res |= VmObjectPaged::kResizable;
     }

     if (flags) {
         return ZX_ERR_INVALID_ARGS;
     }

     *out_flags = res;

     return ZX_OK;
 }

 zx_status_t VmObjectDispatcher::Create(fbl::RefPtr<VmObject> vmo,
                                        zx_koid_t pager_koid,
                                        fbl::RefPtr<Dispatcher>* dispatcher,
                                        zx_rights_t* rights) {
     fbl::AllocChecker ac;
     auto disp = new (&ac) VmObjectDispatcher(ktl::move(vmo), pager_koid);
     if (!ac.check())
         return ZX_ERR_NO_MEMORY;

     disp->vmo()->set_user_id(disp->get_koid());
     *rights = default_rights();
     *dispatcher = fbl::AdoptRef<Dispatcher>(disp);
     return ZX_OK;
 }

 VmObjectDispatcher::VmObjectDispatcher(fbl::RefPtr<VmObject> vmo, zx_koid_t pager_koid)
     : SoloDispatcher(ZX_VMO_ZERO_CHILDREN), vmo_(vmo), pager_koid_(pager_koid) {
     kcounter_add(dispatcher_vmo_create_count, 1);
     vmo_->SetChildObserver(this);
 }

 VmObjectDispatcher::~VmObjectDispatcher() {
     kcounter_add(dispatcher_vmo_destroy_count, 1);
     // Intentionally leave vmo_->user_id() set to our koid even though we're
     // dying and the koid will no longer map to a Dispatcher. koids are never
     // recycled, and it could be a useful breadcrumb.
 }


 void VmObjectDispatcher::OnZeroChild() {
     UpdateState(0, ZX_VMO_ZERO_CHILDREN);
 }

 void VmObjectDispatcher::OnOneChild() {
     UpdateState(ZX_VMO_ZERO_CHILDREN, 0);
 }

 void VmObjectDispatcher::get_name(char out_name[ZX_MAX_NAME_LEN]) const {
     canary_.Assert();
     vmo_->get_name(out_name, ZX_MAX_NAME_LEN);
 }

 zx_status_t VmObjectDispatcher::set_name(const char* name, size_t len) {
     canary_.Assert();
     return vmo_->set_name(name, len);
 }

 void VmObjectDispatcher::on_zero_handles() {
     // Clear when handle count reaches zero rather in the destructor because we're retaining a
     // VmObject that might call back into |this| via VmObjectChildObserver when it's destroyed.
     vmo_->SetChildObserver(nullptr);
 }

 zx_status_t VmObjectDispatcher::Read(user_out_ptr<void> user_data,
                                      size_t length,
                                      uint64_t offset) {
     canary_.Assert();

     return vmo_->ReadUser(user_data, offset, length);
 }

 zx_status_t VmObjectDispatcher::Write(user_in_ptr<const void> user_data,
                                       size_t length,
                                       uint64_t offset) {
     canary_.Assert();

     return vmo_->WriteUser(user_data, offset, length);
 }

 zx_status_t VmObjectDispatcher::SetSize(uint64_t size) {
     canary_.Assert();

     return vmo_->Resize(size);
 }

 zx_status_t VmObjectDispatcher::GetSize(uint64_t* size) {
     canary_.Assert();

     *size = vmo_->size();

     return ZX_OK;
 }

 zx_info_vmo_t VmoToInfoEntry(const VmObject* vmo,
                              bool is_handle, zx_rights_t handle_rights) {
     zx_info_vmo_t entry = {};
     entry.koid = vmo->user_id();
     vmo->get_name(entry.name, sizeof(entry.name));
     entry.size_bytes = vmo->size();
     entry.parent_koid = vmo->parent_user_id();
     entry.num_children = vmo->num_user_children();
     entry.num_mappings = vmo->num_mappings();
     entry.share_count = vmo->share_count();
     entry.flags =
         (vmo->is_paged() ? ZX_INFO_VMO_TYPE_PAGED : ZX_INFO_VMO_TYPE_PHYSICAL) |
         (vmo->is_resizable() ? ZX_INFO_VMO_RESIZABLE : 0) |
         (vmo->is_pager_backed() ? ZX_INFO_VMO_PAGER_BACKED : 0) |
         (vmo->is_contiguous() ? ZX_INFO_VMO_CONTIGUOUS : 0);
     entry.committed_bytes = vmo->AllocatedPages() * PAGE_SIZE;
     entry.cache_policy = vmo->GetMappingCachePolicy();
     if (is_handle) {
         entry.flags |= ZX_INFO_VMO_VIA_HANDLE;
         entry.handle_rights = handle_rights;
     } else {
         entry.flags |= ZX_INFO_VMO_VIA_MAPPING;
     }
     switch (vmo->child_type()) {
         case VmObject::ChildType::kCowClone:
             entry.flags |= ZX_INFO_VMO_IS_COW_CLONE;
             break;
         case VmObject::ChildType::kNotChild:
             break;
     }
     return entry;
 }

 zx_info_vmo_t VmObjectDispatcher::GetVmoInfo(void)
 {
     return VmoToInfoEntry(vmo().get(), true, 0);
 }

 zx_status_t VmObjectDispatcher::RangeOp(uint32_t op, uint64_t offset, uint64_t size,
                                         user_inout_ptr<void> buffer, size_t buffer_size,
                                         zx_rights_t rights) {
     canary_.Assert();

     LTRACEF("op %u offset %#" PRIx64 " size %#" PRIx64
             " buffer %p buffer_size %zu rights %#x\n",
             op, offset, size, buffer.get(), buffer_size, rights);

     switch (op) {
         case ZX_VMO_OP_COMMIT: {
             if ((rights & ZX_RIGHT_WRITE) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             // TODO: handle partial commits
             auto status = vmo_->CommitRange(offset, size);
             return status;
         }
         case ZX_VMO_OP_DECOMMIT: {
             if ((rights & ZX_RIGHT_WRITE) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             // TODO: handle partial decommits
             auto status = vmo_->DecommitRange(offset, size);
             return status;
         }
         case ZX_VMO_OP_LOCK:
         case ZX_VMO_OP_UNLOCK:
             // TODO: handle or remove
             return ZX_ERR_NOT_SUPPORTED;

         case ZX_VMO_OP_CACHE_SYNC:
             if ((rights & ZX_RIGHT_READ) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             return vmo_->SyncCache(offset, size);
         case ZX_VMO_OP_CACHE_INVALIDATE:
             // A straight invalidate op requires the write right since
             // it may drop dirty cache lines, thus modifying the contents
             // of the VMO.
             if ((rights & ZX_RIGHT_WRITE) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             return vmo_->InvalidateCache(offset, size);
         case ZX_VMO_OP_CACHE_CLEAN:
             if ((rights & ZX_RIGHT_READ) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             return vmo_->CleanCache(offset, size);
         case ZX_VMO_OP_CACHE_CLEAN_INVALIDATE:
             if ((rights & ZX_RIGHT_READ) == 0) {
                 return ZX_ERR_ACCESS_DENIED;
             }
             return vmo_->CleanInvalidateCache(offset, size);
         default:
             return ZX_ERR_INVALID_ARGS;
     }
 }

 zx_status_t VmObjectDispatcher::SetMappingCachePolicy(uint32_t cache_policy) {
     return vmo_->SetMappingCachePolicy(cache_policy);
 }

 zx_status_t VmObjectDispatcher::CreateChild(uint32_t options, uint64_t offset, uint64_t size,
         bool copy_name, fbl::RefPtr<VmObject>* child_vmo) {
     canary_.Assert();

     LTRACEF("options 0x%x offset %#" PRIx64 " size %#" PRIx64 "\n",
             options, offset, size);

     // Check for mutually-exclusive child type flags.
     CloneType type;
     if (options & ZX_VMO_CHILD_COPY_ON_WRITE) {
         options &= ~ZX_VMO_CHILD_COPY_ON_WRITE;
         type = CloneType::Unidirectional;
     } else if (options & ZX_VMO_CHILD_COPY_ON_WRITE2) {
         options &= ~ZX_VMO_CHILD_COPY_ON_WRITE2;
         type = CloneType::Bidirectional;
     } else {
         return ZX_ERR_INVALID_ARGS;
     }

     Resizability resizable = Resizability::Resizable;
     if (options & ZX_VMO_CHILD_NON_RESIZEABLE) {
         resizable = Resizability::NonResizable;
         options &= ~ZX_VMO_CHILD_NON_RESIZEABLE;
     } else {
         options &= ~ZX_VMO_CHILD_RESIZABLE;
     }

     if (options)
         return ZX_ERR_INVALID_ARGS;

     return vmo_->CreateCowClone(resizable, type, offset, size, copy_name, child_vmo);
 }
	// Copyright 2016 The Fuchsia Authors
	//
	// Use of this source code is governed by a MIT-style
	// license that can be found in the LICENSE file or at
	// https://opensource.org/licenses/MIT

	#include <object/vm_object_dispatcher.h>

	#include <vm/vm_aspace.h>
	#include <vm/vm_object.h>
	#include <vm/vm_object_paged.h>

	#include <zircon/rights.h>

	#include <fbl/alloc_checker.h>
	#include <lib/counters.h>

	#include <assert.h>
	#include <err.h>
	#include <inttypes.h>
	#include <trace.h>

	#define LOCAL_TRACE 0

	KCOUNTER(dispatcher_vmo_create_count, "dispatcher.vmo.create")
	KCOUNTER(dispatcher_vmo_destroy_count, "dispatcher.vmo.destroy")

	zx_status_t VmObjectDispatcher::parse_create_syscall_flags(uint32_t flags, uint32_t* out_flags) {
	uint32_t res = 0;
	if (flags & ZX_VMO_NON_RESIZABLE) {
	flags &= ~ZX_VMO_NON_RESIZABLE;
	} else {
	flags &= ~ZX_VMO_RESIZABLE;
	res \|= VmObjectPaged::kResizable;
	}

	if (flags) {
	return ZX_ERR_INVALID_ARGS;
	}

	*out_flags = res;

	return ZX_OK;
	}

	zx_status_t VmObjectDispatcher::Create(fbl::RefPtr<VmObject> vmo,
	zx_koid_t pager_koid,
	fbl::RefPtr<Dispatcher>* dispatcher,
	zx_rights_t* rights) {
	fbl::AllocChecker ac;
	auto disp = new (&ac) VmObjectDispatcher(ktl::move(vmo), pager_koid);
	if (!ac.check())
	return ZX_ERR_NO_MEMORY;

	disp->vmo()->set_user_id(disp->get_koid());
	*rights = default_rights();
	*dispatcher = fbl::AdoptRef<Dispatcher>(disp);
	return ZX_OK;
	}

	VmObjectDispatcher::VmObjectDispatcher(fbl::RefPtr<VmObject> vmo, zx_koid_t pager_koid)
	: SoloDispatcher(ZX_VMO_ZERO_CHILDREN), vmo_(vmo), pager_koid_(pager_koid) {
	kcounter_add(dispatcher_vmo_create_count, 1);
	vmo_->SetChildObserver(this);
	}

	VmObjectDispatcher::~VmObjectDispatcher() {
	kcounter_add(dispatcher_vmo_destroy_count, 1);
	// Intentionally leave vmo_->user_id() set to our koid even though we're
	// dying and the koid will no longer map to a Dispatcher. koids are never
	// recycled, and it could be a useful breadcrumb.
	}


	void VmObjectDispatcher::OnZeroChild() {
	UpdateState(0, ZX_VMO_ZERO_CHILDREN);
	}

	void VmObjectDispatcher::OnOneChild() {
	UpdateState(ZX_VMO_ZERO_CHILDREN, 0);
	}

	void VmObjectDispatcher::get_name(char out_name[ZX_MAX_NAME_LEN]) const {
	canary_.Assert();
	vmo_->get_name(out_name, ZX_MAX_NAME_LEN);
	}

	zx_status_t VmObjectDispatcher::set_name(const char* name, size_t len) {
	canary_.Assert();
	return vmo_->set_name(name, len);
	}

	void VmObjectDispatcher::on_zero_handles() {
	// Clear when handle count reaches zero rather in the destructor because we're retaining a
	// VmObject that might call back into \|this\| via VmObjectChildObserver when it's destroyed.
	vmo_->SetChildObserver(nullptr);
	}

	zx_status_t VmObjectDispatcher::Read(user_out_ptr<void> user_data,
	size_t length,
	uint64_t offset) {
	canary_.Assert();

	return vmo_->ReadUser(user_data, offset, length);
	}

	zx_status_t VmObjectDispatcher::Write(user_in_ptr<const void> user_data,
	size_t length,
	uint64_t offset) {
	canary_.Assert();

	return vmo_->WriteUser(user_data, offset, length);
	}

	zx_status_t VmObjectDispatcher::SetSize(uint64_t size) {
	canary_.Assert();

	return vmo_->Resize(size);
	}

	zx_status_t VmObjectDispatcher::GetSize(uint64_t* size) {
	canary_.Assert();

	*size = vmo_->size();

	return ZX_OK;
	}

	zx_info_vmo_t VmoToInfoEntry(const VmObject* vmo,
	bool is_handle, zx_rights_t handle_rights) {
	zx_info_vmo_t entry = {};
	entry.koid = vmo->user_id();
	vmo->get_name(entry.name, sizeof(entry.name));
	entry.size_bytes = vmo->size();
	entry.parent_koid = vmo->parent_user_id();
	entry.num_children = vmo->num_user_children();
	entry.num_mappings = vmo->num_mappings();
	entry.share_count = vmo->share_count();
	entry.flags =
	(vmo->is_paged() ? ZX_INFO_VMO_TYPE_PAGED : ZX_INFO_VMO_TYPE_PHYSICAL) \|
	(vmo->is_resizable() ? ZX_INFO_VMO_RESIZABLE : 0) \|
	(vmo->is_pager_backed() ? ZX_INFO_VMO_PAGER_BACKED : 0) \|
	(vmo->is_contiguous() ? ZX_INFO_VMO_CONTIGUOUS : 0);
	entry.committed_bytes = vmo->AllocatedPages() * PAGE_SIZE;
	entry.cache_policy = vmo->GetMappingCachePolicy();
	if (is_handle) {
	entry.flags \|= ZX_INFO_VMO_VIA_HANDLE;
	entry.handle_rights = handle_rights;
	} else {
	entry.flags \|= ZX_INFO_VMO_VIA_MAPPING;
	}
	switch (vmo->child_type()) {
	case VmObject::ChildType::kCowClone:
	entry.flags \|= ZX_INFO_VMO_IS_COW_CLONE;
	break;
	case VmObject::ChildType::kNotChild:
	break;
	}
	return entry;
	}

	zx_info_vmo_t VmObjectDispatcher::GetVmoInfo(void)
	{
	return VmoToInfoEntry(vmo().get(), true, 0);
	}

	zx_status_t VmObjectDispatcher::RangeOp(uint32_t op, uint64_t offset, uint64_t size,
	user_inout_ptr<void> buffer, size_t buffer_size,
	zx_rights_t rights) {
	canary_.Assert();

	LTRACEF("op %u offset %#" PRIx64 " size %#" PRIx64
	" buffer %p buffer_size %zu rights %#x\n",
	op, offset, size, buffer.get(), buffer_size, rights);

	switch (op) {
	case ZX_VMO_OP_COMMIT: {
	if ((rights & ZX_RIGHT_WRITE) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	// TODO: handle partial commits
	auto status = vmo_->CommitRange(offset, size);
	return status;
	}
	case ZX_VMO_OP_DECOMMIT: {
	if ((rights & ZX_RIGHT_WRITE) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	// TODO: handle partial decommits
	auto status = vmo_->DecommitRange(offset, size);
	return status;
	}
	case ZX_VMO_OP_LOCK:
	case ZX_VMO_OP_UNLOCK:
	// TODO: handle or remove
	return ZX_ERR_NOT_SUPPORTED;

	case ZX_VMO_OP_CACHE_SYNC:
	if ((rights & ZX_RIGHT_READ) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	return vmo_->SyncCache(offset, size);
	case ZX_VMO_OP_CACHE_INVALIDATE:
	// A straight invalidate op requires the write right since
	// it may drop dirty cache lines, thus modifying the contents
	// of the VMO.
	if ((rights & ZX_RIGHT_WRITE) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	return vmo_->InvalidateCache(offset, size);
	case ZX_VMO_OP_CACHE_CLEAN:
	if ((rights & ZX_RIGHT_READ) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	return vmo_->CleanCache(offset, size);
	case ZX_VMO_OP_CACHE_CLEAN_INVALIDATE:
	if ((rights & ZX_RIGHT_READ) == 0) {
	return ZX_ERR_ACCESS_DENIED;
	}
	return vmo_->CleanInvalidateCache(offset, size);
	default:
	return ZX_ERR_INVALID_ARGS;
	}
	}

	zx_status_t VmObjectDispatcher::SetMappingCachePolicy(uint32_t cache_policy) {
	return vmo_->SetMappingCachePolicy(cache_policy);
	}

	zx_status_t VmObjectDispatcher::CreateChild(uint32_t options, uint64_t offset, uint64_t size,
	bool copy_name, fbl::RefPtr<VmObject>* child_vmo) {
	canary_.Assert();

	LTRACEF("options 0x%x offset %#" PRIx64 " size %#" PRIx64 "\n",
	options, offset, size);

	// Check for mutually-exclusive child type flags.
	CloneType type;
	if (options & ZX_VMO_CHILD_COPY_ON_WRITE) {
	options &= ~ZX_VMO_CHILD_COPY_ON_WRITE;
	type = CloneType::Unidirectional;
	} else if (options & ZX_VMO_CHILD_COPY_ON_WRITE2) {
	options &= ~ZX_VMO_CHILD_COPY_ON_WRITE2;
	type = CloneType::Bidirectional;
	} else {
	return ZX_ERR_INVALID_ARGS;
	}

	Resizability resizable = Resizability::Resizable;
	if (options & ZX_VMO_CHILD_NON_RESIZEABLE) {
	resizable = Resizability::NonResizable;
	options &= ~ZX_VMO_CHILD_NON_RESIZEABLE;
	} else {
	options &= ~ZX_VMO_CHILD_RESIZABLE;
	}

	if (options)
	return ZX_ERR_INVALID_ARGS;

	return vmo_->CreateCowClone(resizable, type, offset, size, copy_name, child_vmo);
	}