| // Copyright 2021 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "src/storage/lib/vfs/cpp/paged_vnode.h" | |
| #include <lib/async/cpp/wait.h> | |
| #include <lib/async/dispatcher.h> | |
| #include <lib/zx/result.h> | |
| #include <lib/zx/vmo.h> | |
| #include <zircon/assert.h> | |
| #include <zircon/errors.h> | |
| #include <zircon/syscalls/object.h> | |
| #include <zircon/syscalls/port.h> | |
| #include <zircon/types.h> | |
| #include <cstdint> | |
| #include <mutex> | |
| #include <utility> | |
| #include <fbl/ref_ptr.h> | |
| #include "src/storage/lib/vfs/cpp/paged_vfs.h" | |
| #include "src/storage/lib/vfs/cpp/vnode.h" | |
| namespace fs { | |
| PagedVnode::PagedVnode(PagedVfs& vfs) : clone_watcher_(this), vfs_(vfs) {} | |
| void PagedVnode::VmoDirty(uint64_t offset, uint64_t length) { | |
| ZX_ASSERT_MSG(false, "Filesystem does not support VmoDirty() (maybe read-only filesystem)."); | |
| } | |
| zx::result<> PagedVnode::EnsureCreatePagedVmo(uint64_t size, uint32_t options) { | |
| if (paged_vmo_info_.vmo.is_valid()) { | |
| return zx::ok(); | |
| } | |
| if (!vfs_.has_value()) { | |
| return zx::error(ZX_ERR_BAD_STATE); // Currently shutting down. | |
| } | |
| zx::result info_or = vfs_.value().get().CreatePagedNodeVmo(this, size, options); | |
| if (info_or.is_error()) { | |
| return info_or.take_error(); | |
| } | |
| paged_vmo_info_ = std::move(info_or.value()); | |
| return zx::ok(); | |
| } | |
| void PagedVnode::DidClonePagedVmo() { | |
| // Ensure that there is an owning reference to this vnode that goes along with the VMO clones. | |
| // This ensures that we can continue serving page requests even if all FIDL connections are | |
| // closed. This reference will be released when there are no more clones. | |
| if (!has_clones_reference_) { | |
| has_clones_reference_ = fbl::RefPtr<PagedVnode>(this); | |
| // Watch the VMO for the presence of no children. The VMO currently has no children because we | |
| // just created it, but the signal will be edge-triggered. | |
| WatchForZeroVmoClones(); | |
| } | |
| } | |
| fbl::RefPtr<Vnode> PagedVnode::FreePagedVmo() { | |
| if (!paged_vmo_info_.vmo.is_valid()) | |
| return nullptr; | |
| // Need to stop watching before deleting the VMO or there will be no handle to stop watching. | |
| StopWatchingForZeroVmoClones(); | |
| if (vfs_.has_value()) { | |
| vfs_.value().get().FreePagedVmo(std::move(paged_vmo_info_)); | |
| } | |
| // Reset to known-state after moving (or in case the paged_vfs was destroyed and we skipped | |
| // moving out of it). | |
| paged_vmo_info_.vmo = zx::vmo(); | |
| paged_vmo_info_.id = 0; | |
| // This function must not free itself since the lock must be held to call it and the caller can't | |
| // release a deleted lock. The has_clones_reference_ may be the last thing keeping this class | |
| // alive so return it to allow the caller to release it properly. | |
| return std::move(has_clones_reference_); | |
| } | |
| void PagedVnode::OnNoPagedVmoClones() { | |
| ZX_DEBUG_ASSERT(!has_clones()); | |
| // It is now save to release the VMO. Since we know there are no clones, we don't have to | |
| // call zx_pager_detach_vmo() to stop delivery of requests. And since there are no clones, the | |
| // has_clones_reference_ should also be null and there shouldn't be a reference to release | |
| // returned by FreePagedVmo(). If there is, deleting it here would cause "this" to be deleted | |
| // inside its own lock which will crash. | |
| fbl::RefPtr<fs::Vnode> pager_reference = FreePagedVmo(); | |
| ZX_DEBUG_ASSERT(!pager_reference); | |
| } | |
| void PagedVnode::OnNoPagedVmoClonesMessage(async_dispatcher_t* dispatcher, async::WaitBase* wait, | |
| zx_status_t status, const zx_packet_signal_t* signal) { | |
| // The system will cancel our wait on teardown if we're still watching the vmo. | |
| if (status == ZX_ERR_CANCELED) | |
| return; | |
| // Our clone reference must be freed, but we need to do that outside of the lock. | |
| fbl::RefPtr<PagedVnode> clone_reference; | |
| { | |
| std::lock_guard lock(mutex_); | |
| ZX_DEBUG_ASSERT(has_clones()); | |
| if (!vfs_.has_value()) { | |
| return; // Called during tear-down. | |
| } | |
| // The kernel signal delivery could have raced with us creating a new clone. Validate that there | |
| // are still no clones before tearing down. | |
| zx_info_vmo_t info; | |
| if (paged_vmo().get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr) != ZX_OK) | |
| return; // Something wrong with the VMO, don't try to tear down. | |
| if (info.num_children > 0) { | |
| // Race with new VMO. Re-arm the clone watcher and continue as if the signal was not sent. | |
| WatchForZeroVmoClones(); | |
| return; | |
| } | |
| // Move our reference for releasing outside of the lock. Clearing the member will also allow the | |
| // OnNoPagedVmoClones() observer to see "has_clones() == false" which is the new state. | |
| clone_reference = std::move(has_clones_reference_); | |
| StopWatchingForZeroVmoClones(); | |
| OnNoPagedVmoClones(); | |
| } | |
| // Release the reference to this class. This could be the last reference keeping it alive which | |
| // can cause it to be freed. | |
| clone_reference = nullptr; | |
| // THIS OBJECT IS NOW POSSIBLY DELETED. | |
| } | |
| void PagedVnode::WatchForZeroVmoClones() { | |
| clone_watcher_.set_object(paged_vmo().get()); | |
| clone_watcher_.set_trigger(ZX_VMO_ZERO_CHILDREN); | |
| if (vfs_.has_value()) { | |
| clone_watcher_.Begin(vfs_.value().get().dispatcher()); | |
| } | |
| } | |
| void PagedVnode::StopWatchingForZeroVmoClones() { | |
| // This needs to tolerate calls where the cancel is unnecessary. | |
| if (clone_watcher_.is_pending()) | |
| clone_watcher_.Cancel(); | |
| clone_watcher_.set_object(ZX_HANDLE_INVALID); | |
| } | |
| void PagedVnode::WillDestroyVfs() { | |
| std::lock_guard lock(mutex_); | |
| vfs_.reset(); | |
| } | |
| void PagedVnode::TearDown() { | |
| std::lock_guard lock(mutex_); | |
| auto node = FreePagedVmo(); | |
| } | |
| } // namespace fs |