blob: 593208f760bc331a2cd21783b8dc4417ad61fd36 [file] [log] [blame]
// Copyright 2019 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 <fuchsia/fshost/llcpp/fidl.h>
#include <fuchsia/io/llcpp/fidl.h>
#include <fuchsia/process/lifecycle/llcpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/namespace.h>
#include <lib/fidl-async/bind.h>
#include <lib/fidl/llcpp/server.h>
#include <lib/zx/channel.h>
#include <zircon/fidl.h>
#include <memory>
#include <cobalt-client/cpp/collector.h>
#include <cobalt-client/cpp/in_memory_logger.h>
#include <fbl/algorithm.h>
#include <fbl/ref_ptr.h>
#include <fs/pseudo_dir.h>
#include <zxtest/zxtest.h>
#include "fs-manager.h"
#include "fs/synchronous_vfs.h"
#include "fshost-fs-provider.h"
#include "metrics.h"
#include "registry.h"
#include "registry_vnode.h"
#include "src/storage/fshost/block-watcher.h"
namespace devmgr {
namespace {
namespace fio = ::llcpp::fuchsia::io;
std::unique_ptr<cobalt_client::Collector> MakeCollector() {
return std::make_unique<cobalt_client::Collector>(
std::make_unique<cobalt_client::InMemoryLogger>());
}
// Test that when no filesystems have been added to the fshost vnode, it
// stays empty.
TEST(VnodeTestCase, NoFilesystems) {
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
auto dir = fbl::MakeRefCounted<fs::PseudoDir>();
auto fshost_vn = fbl::MakeRefCounted<fshost::RegistryVnode>(loop.dispatcher(), dir);
fbl::RefPtr<fs::Vnode> node;
EXPECT_EQ(ZX_ERR_NOT_FOUND, dir->Lookup("0", &node));
}
// Test that when filesystem has been added to the fshost vnode, it appears
// in the supplied remote tracking directory.
TEST(VnodeTestCase, AddFilesystem) {
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
auto dir = fbl::MakeRefCounted<fs::PseudoDir>();
auto fshost_vn = fbl::MakeRefCounted<fshost::RegistryVnode>(loop.dispatcher(), dir);
// Adds a new filesystem to the fshost service node.
// This filesystem should appear as a new entry within |dir|.
auto endpoints = fidl::CreateEndpoints<::llcpp::fuchsia::io::Directory>();
ASSERT_OK(endpoints.status_value());
fidl::UnownedClientEnd<::llcpp::fuchsia::io::Directory> client_value = endpoints->client.borrow();
ASSERT_OK(fshost_vn->AddFilesystem(std::move(endpoints->client)));
fbl::RefPtr<fs::Vnode> node;
ASSERT_OK(dir->Lookup("0", &node));
EXPECT_EQ(node->GetRemote(), client_value);
}
TEST(VnodeTestCase, AddFilesystemThroughFidl) {
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
ASSERT_EQ(loop.StartThread(), ZX_OK);
// set up registry service
auto registry_endpoints = fidl::CreateEndpoints<::llcpp::fuchsia::fshost::Registry>();
ASSERT_OK(registry_endpoints.status_value());
auto [registry_client, registry_server] = std::move(registry_endpoints.value());
auto dir = fbl::MakeRefCounted<fs::PseudoDir>();
auto fshost_vn = std::make_unique<fshost::RegistryVnode>(loop.dispatcher(), dir);
auto server_binding =
fidl::BindServer(loop.dispatcher(), std::move(registry_server), std::move(fshost_vn));
ASSERT_TRUE(server_binding.is_ok());
// make a new "vfs" "client" that doesn't really point anywhere.
auto vfs_endpoints = fidl::CreateEndpoints<::llcpp::fuchsia::io::Directory>();
ASSERT_OK(vfs_endpoints.status_value());
auto [vfs_client, vfs_server] = std::move(vfs_endpoints.value());
zx_info_handle_basic_t vfs_client_info;
ASSERT_OK(vfs_client.channel().get_info(ZX_INFO_HANDLE_BASIC, &vfs_client_info,
sizeof(vfs_client_info), nullptr, nullptr));
// register the filesystem through the fidl interface
auto resp = ::llcpp::fuchsia::fshost::Registry::Call::RegisterFilesystem(registry_client,
std::move(vfs_client));
ASSERT_TRUE(resp.ok());
ASSERT_OK(resp.value().s);
// confirm that the filesystem was registered
fbl::RefPtr<fs::Vnode> node;
ASSERT_OK(dir->Lookup("0", &node));
zx_info_handle_basic_t vfs_remote_info;
auto remote = node->GetRemote();
ASSERT_OK(zx_object_get_info(remote.channel(), ZX_INFO_HANDLE_BASIC, &vfs_remote_info,
sizeof(vfs_remote_info), nullptr, nullptr));
EXPECT_EQ(vfs_remote_info.koid, vfs_client_info.koid);
}
class FakeDriverManagerAdmin final
: public llcpp::fuchsia::device::manager::Administrator::Interface {
public:
void Suspend(uint32_t flags, SuspendCompleter::Sync& completer) override {
completer.Reply(ZX_OK);
}
void UnregisterSystemStorageForShutdown(
UnregisterSystemStorageForShutdownCompleter::Sync& completer) override {
unregister_was_called_ = true;
completer.Reply(ZX_OK);
}
bool UnregisterWasCalled() { return unregister_was_called_; }
private:
std::atomic<bool> unregister_was_called_ = false;
};
// Test that the manager performs the shutdown procedure correctly with respect to externally
// observable behaviors.
TEST(FsManagerTestCase, ShutdownSignalsCompletion) {
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
ASSERT_EQ(loop.StartThread(), ZX_OK);
FakeDriverManagerAdmin driver_admin;
auto admin_endpoints = fidl::CreateEndpoints<llcpp::fuchsia::device::manager::Administrator>();
ASSERT_TRUE(admin_endpoints.is_ok());
ASSERT_TRUE(fidl::BindServer(loop.dispatcher(), std::move(admin_endpoints->server), &driver_admin)
.is_ok());
zx::channel dir_request, lifecycle_request;
FsManager manager(nullptr, std::make_unique<FsHostMetrics>(MakeCollector()));
Config config;
BlockWatcher watcher(manager, &config);
ASSERT_OK(manager.Initialize(std::move(dir_request), std::move(lifecycle_request),
std::move(admin_endpoints->client), nullptr, watcher));
// The manager should not have exited yet: No one has asked for the shutdown.
EXPECT_FALSE(manager.IsShutdown());
// Once we trigger shutdown, we expect a shutdown signal.
sync_completion_t callback_called;
manager.Shutdown([callback_called = &callback_called](zx_status_t status) {
EXPECT_OK(status);
sync_completion_signal(callback_called);
});
manager.WaitForShutdown();
EXPECT_OK(sync_completion_wait(&callback_called, ZX_TIME_INFINITE));
EXPECT_TRUE(driver_admin.UnregisterWasCalled());
// It's an error if shutdown gets called twice, but we expect the callback to still get called
// with the appropriate error message since the shutdown function has no return value.
sync_completion_reset(&callback_called);
manager.Shutdown([callback_called = &callback_called](zx_status_t status) {
EXPECT_EQ(status, ZX_ERR_INTERNAL);
sync_completion_signal(callback_called);
});
EXPECT_OK(sync_completion_wait(&callback_called, ZX_TIME_INFINITE));
}
// Test that the manager shuts down the filesystems given a call on the lifecycle channel
TEST(FsManagerTestCase, LifecycleStop) {
zx::channel dir_request, lifecycle_request, lifecycle;
zx_status_t status = zx::channel::create(0, &lifecycle_request, &lifecycle);
ASSERT_OK(status);
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
ASSERT_EQ(loop.StartThread(), ZX_OK);
FakeDriverManagerAdmin driver_admin;
auto admin_endpoints = fidl::CreateEndpoints<llcpp::fuchsia::device::manager::Administrator>();
ASSERT_TRUE(admin_endpoints.is_ok());
ASSERT_TRUE(fidl::BindServer(loop.dispatcher(), std::move(admin_endpoints->server), &driver_admin)
.is_ok());
FsManager manager(nullptr, std::make_unique<FsHostMetrics>(MakeCollector()));
Config config;
BlockWatcher watcher(manager, &config);
ASSERT_OK(manager.Initialize(std::move(dir_request), std::move(lifecycle_request),
std::move(admin_endpoints->client), nullptr, watcher));
// The manager should not have exited yet: No one has asked for an unmount.
EXPECT_FALSE(manager.IsShutdown());
// Call stop on the lifecycle channel
llcpp::fuchsia::process::lifecycle::Lifecycle::SyncClient client(std::move(lifecycle));
auto result = client.Stop();
ASSERT_OK(result.status());
// the lifecycle channel should be closed now
zx_signals_t pending;
EXPECT_OK(client.channel().wait_one(ZX_CHANNEL_PEER_CLOSED, zx::time::infinite(), &pending));
EXPECT_TRUE(pending & ZX_CHANNEL_PEER_CLOSED);
// Now we expect a shutdown signal.
manager.WaitForShutdown();
EXPECT_TRUE(driver_admin.UnregisterWasCalled());
}
class MockDirectoryAdminOpener : public fio::DirectoryAdmin::Interface {
public:
void Open(uint32_t flags, uint32_t mode, fidl::StringView path, fidl::ServerEnd<fio::Node> object,
OpenCompleter::Sync& completer) override {
saved_open_flags = flags;
saved_open_count += 1;
saved_path = path.get();
}
// Below here are a pile of stubs that aren't called in this test. Only Open() above is used.
// fuchsia.io/Node:
void Clone(uint32_t flags, fidl::ServerEnd<llcpp::fuchsia::io::Node> object,
CloneCompleter::Sync& completer) override {}
void Close(CloseCompleter::Sync& completer) override {}
void Describe(DescribeCompleter::Sync& completer) override {}
void Sync(SyncCompleter::Sync& completer) override {}
void GetAttr(GetAttrCompleter::Sync& completer) override {}
void SetAttr(uint32_t flags, llcpp::fuchsia::io::NodeAttributes attributes,
SetAttrCompleter::Sync& completer) override {}
void NodeGetFlags(NodeGetFlagsCompleter::Sync& completer) override {}
void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync& completer) override {}
// fuchsia.io/Directory:
void Unlink(fidl::StringView path, UnlinkCompleter::Sync& completer) override {}
void ReadDirents(uint64_t max_out, ReadDirentsCompleter::Sync& completer) override {}
void Rewind(RewindCompleter::Sync& completer) override {}
void GetToken(GetTokenCompleter::Sync& completer) override {}
void Rename(fidl::StringView src, zx::handle dst_parent_token, fidl::StringView dst,
RenameCompleter::Sync& completer) override {}
void Link(fidl::StringView src, zx::handle dst_parent_token, fidl::StringView dst,
LinkCompleter::Sync& completer) override {}
void Watch(uint32_t mask, uint32_t options, zx::channel watcher,
WatchCompleter::Sync& completer) override {}
void AddInotifyFilter(llcpp::fuchsia::io2::InotifyWatchMask filters, fidl::StringView path,
uint32_t watch_descriptor, zx::socket socket,
fidl::ServerEnd<llcpp::fuchsia::io2::Inotifier> controller,
AddInotifyFilterCompleter::Sync& completer) override {}
// fuchsia.io/DirectoryAdmin:
void Mount(fidl::ClientEnd<llcpp::fuchsia::io::Directory> remote,
MountCompleter::Sync& completer) override {}
void MountAndCreate(fidl::ClientEnd<llcpp::fuchsia::io::Directory> remote, fidl::StringView name,
uint32_t flags, MountAndCreateCompleter::Sync& completer) override {}
void Unmount(UnmountCompleter::Sync& completer) override {}
void UnmountNode(UnmountNodeCompleter::Sync& completer) override {}
void QueryFilesystem(QueryFilesystemCompleter::Sync& completer) override {}
void GetDevicePath(GetDevicePathCompleter::Sync& completer) override {}
// Test fields used for validation.
uint32_t saved_open_flags = 0;
uint32_t saved_open_count = 0;
std::string saved_path;
};
// Test that asking FshostFsProvider for blobexec opens /fs/blob from the
// current installed namespace with the EXEC right
TEST(FshostFsProviderTestCase, CloneBlobExec) {
async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread);
ASSERT_EQ(loop.StartThread(), ZX_OK);
fdio_ns_t* ns;
ASSERT_OK(fdio_ns_get_installed(&ns));
// Mock out an object that implements DirectoryOpen and records some state;
// bind it to the server handle. Install it at /fs.
auto admin = fidl::CreateEndpoints<fio::DirectoryAdmin>();
ASSERT_OK(admin.status_value());
auto server_ptr = std::make_unique<MockDirectoryAdminOpener>();
auto& server = *server_ptr;
ASSERT_TRUE(
fidl::BindServer(loop.dispatcher(), std::move(admin->server), std::move(server_ptr)).is_ok());
fdio_ns_bind(ns, "/fs", admin->client.channel().release());
// Verify that requesting blobexec gets you the handle at /fs/blob, with the
// permissions expected.
FshostFsProvider provider;
zx::channel blobexec = provider.CloneFs("blobexec");
// Force a describe call on the target of the Open, to resolve the Open. We
// expect this to fail because our mock just closes the channel after Open.
int fd;
EXPECT_EQ(ZX_ERR_PEER_CLOSED, fdio_fd_create(blobexec.release(), &fd));
EXPECT_EQ(1, server.saved_open_count);
uint32_t expected_flags = ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE | ZX_FS_RIGHT_EXECUTABLE |
ZX_FS_RIGHT_ADMIN | ZX_FS_FLAG_DIRECTORY | ZX_FS_FLAG_NOREMOTE;
EXPECT_EQ(expected_flags, server.saved_open_flags);
EXPECT_STR_EQ("blob", server.saved_path);
// Tear down.
ASSERT_OK(fdio_ns_unbind(ns, "/fs"));
}
} // namespace
} // namespace devmgr