src/lib/isolated_devmgr/isolated_devmgr_tests.cc - fuchsia - Git at Google

 // 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 <fcntl.h>
 #include <fuchsia/hardware/ethertap/cpp/fidl.h>
 #include <fuchsia/sys/cpp/fidl.h>
 #include <fuchsia/virtualaudio/cpp/fidl.h>
 #include <lib/ddk/platform-defs.h>
 #include <lib/devmgr-integration-test/fixture.h>
 #include <lib/fdio/cpp/caller.h>
 #include <lib/fdio/directory.h>
 #include <lib/sys/cpp/component_context.h>

 #include <sdk/lib/device-watcher/cpp/device-watcher.h>

 #include "isolated_devmgr.h"
 #include "src/lib/files/glob.h"
 #include "src/lib/testing/loop_fixture/real_loop_fixture.h"

 namespace isolated_devmgr {
 namespace testing {

 class DevmgrTest : public ::gtest::RealLoopFixture {
  protected:
   static constexpr const char* kSysdevDriver = "/boot/driver/sysdev.so";
   static constexpr const char* kPlatformDriver = "/boot/driver/platform-bus.so";
   const board_test::DeviceEntry kTestDeviceEntry = []() {
     board_test::DeviceEntry entry = {};
     strcpy(entry.name, "test");
     entry.vid = PDEV_VID_TEST;
     entry.pid = PDEV_PID_TEST;
     return entry;
   }();

   const board_test::DeviceEntry kCrashDeviceEntry = []() {
     board_test::DeviceEntry entry = {};
     strcpy(entry.name, "crash-device");
     entry.vid = PDEV_VID_TEST;
     entry.pid = PDEV_PID_GENERIC;
     entry.did = PDEV_DID_TEST_CRASH;
     return entry;
   }();

   std::unique_ptr<IsolatedDevmgr> CreateDevmgrSysdev() {
     devmgr_launcher::Args args;
     IsolatedDevmgr::ExtraArgs extra_args;
     args.sys_device_driver = "/boot/driver/test-parent-sys.so";

     args.stdio = fbl::unique_fd(open("/dev/null", O_RDWR));
     args.disable_block_watcher = true;
     return IsolatedDevmgr::Create(std::move(args));
   }

   std::unique_ptr<IsolatedDevmgr> CreateDevmgrPlatTest(const char* crash_policy = "do-nothing") {
     devmgr_launcher::Args args;
     auto device_list_ptr = std::unique_ptr<fbl::Vector<board_test::DeviceEntry>>(
         new fbl::Vector<board_test::DeviceEntry>());
     args.sys_device_driver = kPlatformDriver;

     args.stdio = fbl::unique_fd(open("/dev/null", O_RDWR));
     args.disable_block_watcher = true;
     args.boot_args = {{"driver-manager.driver-host-crash-policy", crash_policy}};
     device_list_ptr->push_back(kTestDeviceEntry);
     device_list_ptr->push_back(kCrashDeviceEntry);
     return IsolatedDevmgr::Create(std::move(args), std::move(device_list_ptr), dispatcher());
   }

   fidl::InterfaceHandle<fuchsia::hardware::ethertap::TapDevice> CreateTapDevice(
       const zx::channel& devfs) {
     fidl::SynchronousInterfacePtr<fuchsia::hardware::ethertap::TapControl> tapctl;
     fdio_service_connect_at(devfs.get(), "sys/test/tapctl",
                             tapctl.NewRequest().TakeChannel().release());
     fuchsia::hardware::ethertap::Config config;
     config.mtu = 1500;
     config.options = 0;
     config.features = 0;
     const uint8_t mac[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
     memcpy(config.mac.octets.data(), mac, sizeof(mac));

     fidl::InterfaceHandle<fuchsia::hardware::ethertap::TapDevice> device;
     zx_status_t status, o_status;
     if ((status = tapctl->OpenDevice("tap_device", std::move(config), device.NewRequest(),
                                      &o_status)) != ZX_OK ||
         o_status != ZX_OK) {
       fprintf(stderr, "status: %d, o_status: %d\n", status, o_status);
       // discard channel
       device = nullptr;
     }
     return device;
   }

   void EnableVirtualAudio(zx::channel devfs) {
     fbl::unique_fd devfs_fd, fd;
     ASSERT_EQ(ZX_OK, fdio_fd_create(devfs.release(), devfs_fd.reset_and_get_address()));
     ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(
                          devfs_fd, "sys/platform/00:00:2f/virtual_audio", &fd));

     fdio_cpp::UnownedFdioCaller caller(devfs_fd.get());

     fuchsia::virtualaudio::ControlSyncPtr virtual_audio_control;
     fdio_service_connect_at(caller.borrow_channel(), "sys/platform/00:00:2f/virtual_audio",
                             virtual_audio_control.NewRequest().TakeChannel().release());

     // Perform a simple RPC with a reply to sanity check we're talking to the driver.
     ASSERT_EQ(ZX_OK, virtual_audio_control->RemoveAll());
   }
 };

 TEST_F(DevmgrTest, CreateTapSysdev) {
   auto devmgr = CreateDevmgrSysdev();
   ASSERT_TRUE(devmgr);
   ASSERT_EQ(devmgr->WaitForFile("sys/test/tapctl"), ZX_OK);

   fidl::InterfaceHandle<fuchsia::io::Directory> dir;
   devmgr->Connect(dir.NewRequest().TakeChannel());
   auto tap = CreateTapDevice(dir.channel());
   ASSERT_TRUE(tap);
   // after having created tap, we should be able to see an ethernet device show
   // up:
   ASSERT_EQ(devmgr->WaitForFile("class/ethernet/000"), ZX_OK);
 }

 TEST_F(DevmgrTest, DeviceEntryEnumerationTest) {
   auto devmgr = CreateDevmgrPlatTest();
   ASSERT_TRUE(devmgr);

   fbl::unique_fd fd;

   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(devmgr->devfs_root(), "sys/platform", &fd));
   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(
                        devmgr->devfs_root(), "sys/platform/platform-passthrough/test-board", &fd));
   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(devmgr->devfs_root(),
                                                         "sys/platform/11:18:0/test-device", &fd));
 }

 TEST_F(DevmgrTest, ExceptionCallback) {
   auto devmgr = CreateDevmgrPlatTest();
   ASSERT_TRUE(devmgr);

   bool exception = false;
   devmgr->SetExceptionCallback([&exception](zx_exception_info_t) { exception = true; });

   ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

   zx_handle_t dir;
   ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

   RunLoopUntil([&exception, &dir]() {
     // keep trying to open crash-device until we see an exception
     zx::channel a, b;
     EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
     fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

     return exception;
   });
 }

 // Driver manager will never crash, triggering a system reboot.
 TEST_F(DevmgrTest, ExceptionCallback_SystemReboot) {
   auto devmgr = CreateDevmgrPlatTest("reboot-system");
   ASSERT_TRUE(devmgr);

   zx_info_handle_basic_t process_info;
   ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
                                                       sizeof(process_info), nullptr, nullptr),
             ZX_OK);

   std::atomic<bool> driver_manager_crashed = false;
   devmgr->SetExceptionCallback(
       [&driver_manager_crashed, &process_info](zx_exception_info_t exception_info) {
         driver_manager_crashed = process_info.koid == exception_info.pid;
       });

   ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

   zx_handle_t dir;
   ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

   // A single crash should cause driver manager to crash, but we don't know when crash-device will
   // be available.
   RunLoopUntil([&driver_manager_crashed, &dir]() {
     zx::channel a, b;
     EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
     fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

     return driver_manager_crashed.load();
   });
 }

 // Driver manager will never crash, and the driver host should be reloaded 3 times.
 TEST_F(DevmgrTest, ExceptionCallback_RestartDriverHost) {
   auto devmgr = CreateDevmgrPlatTest("restart-driver-host");
   ASSERT_TRUE(devmgr);

   zx_info_handle_basic_t process_info;
   ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
                                                       sizeof(process_info), nullptr, nullptr),
             ZX_OK);

   std::atomic<bool> driver_manager_crashed = false;
   std::atomic<uint32_t> exception_count = 0;
   devmgr->SetExceptionCallback([&driver_manager_crashed, &process_info,
                                 &exception_count](zx_exception_info_t exception_info) {
     driver_manager_crashed = process_info.koid == exception_info.pid;
     exception_count += 1;
   });

   ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

   zx_handle_t dir;
   ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

   RunLoopUntil([&driver_manager_crashed, &dir, &exception_count]() {
     zx::channel a, b;
     EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
     fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

     return driver_manager_crashed.load() || exception_count.load() == 4u;
   });

   ASSERT_FALSE(RunLoopWithTimeoutOrUntil(
       [&driver_manager_crashed, &dir]() {
         zx::channel a, b;
         EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
         fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

         return driver_manager_crashed.load();
       },
       zx::sec(5)));

   ASSERT_FALSE(driver_manager_crashed.load());
   ASSERT_GE(exception_count.load(), 4u);
 }

 // Driver manager will never crash, and the driver host should never be reloaded.
 TEST_F(DevmgrTest, ExceptionCallback_DoNothing) {
   auto devmgr = CreateDevmgrPlatTest("do-nothing");
   ASSERT_TRUE(devmgr);

   zx_info_handle_basic_t process_info;
   ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
                                                       sizeof(process_info), nullptr, nullptr),
             ZX_OK);

   std::atomic<bool> driver_manager_crashed = false;
   std::atomic<uint32_t> exception_count = 0;
   devmgr->SetExceptionCallback([&driver_manager_crashed, &process_info,
                                 &exception_count](zx_exception_info_t exception_info) {
     driver_manager_crashed = process_info.koid == exception_info.pid;
     exception_count += 1;
   });

   ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

   zx_handle_t dir;
   ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

   RunLoopUntil([&driver_manager_crashed, &dir, &exception_count]() {
     zx::channel a, b;
     EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
     fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

     return driver_manager_crashed.load() || exception_count.load() == 1u;
   });

   ASSERT_FALSE(RunLoopWithTimeoutOrUntil(
       [&driver_manager_crashed, &dir]() {
         zx::channel a, b;
         EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
         fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

         return driver_manager_crashed.load();
       },
       zx::sec(5)));

   ASSERT_FALSE(driver_manager_crashed.load());
   ASSERT_EQ(exception_count.load(), 1u);
 }

 TEST_F(DevmgrTest, ExposedThroughComponent) {
   auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
   fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
   ctx->svc()->Connect(launcher.NewRequest());

   zx::channel req;
   auto services = sys::ServiceDirectory::CreateWithRequest(&req);

   fuchsia::sys::LaunchInfo info;
   info.directory_request = std::move(req);
   info.url =
       "fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/"
       "ethertap-devmgr.cmx";
   fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;

   launcher->CreateComponent(std::move(info), ctlr.NewRequest());
   ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });

   zx::channel devfs_req, devfs;
   zx::channel::create(0, &devfs_req, &devfs);
   services->Connect("fuchsia.example.IsolatedDevmgr", std::move(devfs_req));

   auto tap = CreateTapDevice(devfs);
   ASSERT_TRUE(tap);
 }

 TEST_F(DevmgrTest, ExposeDriverFromComponentNamespace) {
   auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
   fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
   ctx->svc()->Connect(launcher.NewRequest());

   zx::channel req;
   auto services = sys::ServiceDirectory::CreateWithRequest(&req);

   fuchsia::sys::LaunchInfo info;
   info.directory_request = std::move(req);
   info.url =
       "fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/"
       "virtual-audio-devmgr.cmx";
   fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;

   launcher->CreateComponent(std::move(info), ctlr.NewRequest());
   ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });

   zx::channel devfs_req, devfs;
   zx::channel::create(0, &devfs_req, &devfs);
   services->Connect("fuchsia.example.IsolatedDevmgr", std::move(devfs_req));

   EnableVirtualAudio(std::move(devfs));
 }

 TEST_F(DevmgrTest, ExposeDevfsToHub) {
   auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
   fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
   ctx->svc()->Connect(launcher.NewRequest());

   fuchsia::sys::LaunchInfo info;
   info.url =
       "fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/virtual-audio-devmgr.cmx";
   auto echo_svc = sys::ServiceDirectory::CreateWithRequest(&info.directory_request);
   fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;
   launcher->CreateComponent(std::move(info), ctlr.NewRequest());

   ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });
   bool ready = false;
   ctlr.events().OnDirectoryReady = [&ready] { ready = true; };
   RunLoopUntil([&ready] { return ready; });
   ASSERT_TRUE(ready);

   // Verify that devfs is indeed visible in outgoing directory
   constexpr char kGlob[] = "/hub/c/virtual-audio-devmgr.cmx/*/out/dev";
   files::Glob glob(kGlob);
   EXPECT_EQ(glob.size(), 1u) << kGlob << " expected to match exactly once.";
 }

 TEST_F(DevmgrTest, DiagnosticsFiles) {
   auto devmgr = CreateDevmgrSysdev();
   ASSERT_TRUE(devmgr);

   fbl::unique_fd fd;
   ASSERT_EQ(ZX_OK,
             device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(), "diagnostics", &fd));
   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(),
                                                                 "diagnostics/class", &fd));
   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(),
                                                                 "diagnostics/driver_manager", &fd));
   ASSERT_EQ(ZX_OK,
             device_watcher::RecursiveWaitForFileReadOnly(
                 devmgr->devfs_root(), "diagnostics/driver_manager/fuchsia.inspect.Tree", &fd));
   ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(
                        devmgr->devfs_root(), "diagnostics/driver_manager/driver_host", &fd));

   // TODO(fxbug.dev/50569): Add test for root,sys,misc,test driver_host files once koids are
   // available via dm.inspect
 }

 }  // namespace testing
 }  // namespace isolated_devmgr
	// 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 <fcntl.h>
	#include <fuchsia/hardware/ethertap/cpp/fidl.h>
	#include <fuchsia/sys/cpp/fidl.h>
	#include <fuchsia/virtualaudio/cpp/fidl.h>
	#include <lib/ddk/platform-defs.h>
	#include <lib/devmgr-integration-test/fixture.h>
	#include <lib/fdio/cpp/caller.h>
	#include <lib/fdio/directory.h>
	#include <lib/sys/cpp/component_context.h>

	#include <sdk/lib/device-watcher/cpp/device-watcher.h>

	#include "isolated_devmgr.h"
	#include "src/lib/files/glob.h"
	#include "src/lib/testing/loop_fixture/real_loop_fixture.h"

	namespace isolated_devmgr {
	namespace testing {

	class DevmgrTest : public ::gtest::RealLoopFixture {
	protected:
	static constexpr const char* kSysdevDriver = "/boot/driver/sysdev.so";
	static constexpr const char* kPlatformDriver = "/boot/driver/platform-bus.so";
	const board_test::DeviceEntry kTestDeviceEntry = []() {
	board_test::DeviceEntry entry = {};
	strcpy(entry.name, "test");
	entry.vid = PDEV_VID_TEST;
	entry.pid = PDEV_PID_TEST;
	return entry;
	}();

	const board_test::DeviceEntry kCrashDeviceEntry = []() {
	board_test::DeviceEntry entry = {};
	strcpy(entry.name, "crash-device");
	entry.vid = PDEV_VID_TEST;
	entry.pid = PDEV_PID_GENERIC;
	entry.did = PDEV_DID_TEST_CRASH;
	return entry;
	}();

	std::unique_ptr<IsolatedDevmgr> CreateDevmgrSysdev() {
	devmgr_launcher::Args args;
	IsolatedDevmgr::ExtraArgs extra_args;
	args.sys_device_driver = "/boot/driver/test-parent-sys.so";

	args.stdio = fbl::unique_fd(open("/dev/null", O_RDWR));
	args.disable_block_watcher = true;
	return IsolatedDevmgr::Create(std::move(args));
	}

	std::unique_ptr<IsolatedDevmgr> CreateDevmgrPlatTest(const char* crash_policy = "do-nothing") {
	devmgr_launcher::Args args;
	auto device_list_ptr = std::unique_ptr<fbl::Vector<board_test::DeviceEntry>>(
	new fbl::Vector<board_test::DeviceEntry>());
	args.sys_device_driver = kPlatformDriver;

	args.stdio = fbl::unique_fd(open("/dev/null", O_RDWR));
	args.disable_block_watcher = true;
	args.boot_args = {{"driver-manager.driver-host-crash-policy", crash_policy}};
	device_list_ptr->push_back(kTestDeviceEntry);
	device_list_ptr->push_back(kCrashDeviceEntry);
	return IsolatedDevmgr::Create(std::move(args), std::move(device_list_ptr), dispatcher());
	}

	fidl::InterfaceHandle<fuchsia::hardware::ethertap::TapDevice> CreateTapDevice(
	const zx::channel& devfs) {
	fidl::SynchronousInterfacePtr<fuchsia::hardware::ethertap::TapControl> tapctl;
	fdio_service_connect_at(devfs.get(), "sys/test/tapctl",
	tapctl.NewRequest().TakeChannel().release());
	fuchsia::hardware::ethertap::Config config;
	config.mtu = 1500;
	config.options = 0;
	config.features = 0;
	const uint8_t mac[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
	memcpy(config.mac.octets.data(), mac, sizeof(mac));

	fidl::InterfaceHandle<fuchsia::hardware::ethertap::TapDevice> device;
	zx_status_t status, o_status;
	if ((status = tapctl->OpenDevice("tap_device", std::move(config), device.NewRequest(),
	&o_status)) != ZX_OK \|\|
	o_status != ZX_OK) {
	fprintf(stderr, "status: %d, o_status: %d\n", status, o_status);
	// discard channel
	device = nullptr;
	}
	return device;
	}

	void EnableVirtualAudio(zx::channel devfs) {
	fbl::unique_fd devfs_fd, fd;
	ASSERT_EQ(ZX_OK, fdio_fd_create(devfs.release(), devfs_fd.reset_and_get_address()));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(
	devfs_fd, "sys/platform/00:00:2f/virtual_audio", &fd));

	fdio_cpp::UnownedFdioCaller caller(devfs_fd.get());

	fuchsia::virtualaudio::ControlSyncPtr virtual_audio_control;
	fdio_service_connect_at(caller.borrow_channel(), "sys/platform/00:00:2f/virtual_audio",
	virtual_audio_control.NewRequest().TakeChannel().release());

	// Perform a simple RPC with a reply to sanity check we're talking to the driver.
	ASSERT_EQ(ZX_OK, virtual_audio_control->RemoveAll());
	}
	};

	TEST_F(DevmgrTest, CreateTapSysdev) {
	auto devmgr = CreateDevmgrSysdev();
	ASSERT_TRUE(devmgr);
	ASSERT_EQ(devmgr->WaitForFile("sys/test/tapctl"), ZX_OK);

	fidl::InterfaceHandle<fuchsia::io::Directory> dir;
	devmgr->Connect(dir.NewRequest().TakeChannel());
	auto tap = CreateTapDevice(dir.channel());
	ASSERT_TRUE(tap);
	// after having created tap, we should be able to see an ethernet device show
	// up:
	ASSERT_EQ(devmgr->WaitForFile("class/ethernet/000"), ZX_OK);
	}

	TEST_F(DevmgrTest, DeviceEntryEnumerationTest) {
	auto devmgr = CreateDevmgrPlatTest();
	ASSERT_TRUE(devmgr);

	fbl::unique_fd fd;

	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(devmgr->devfs_root(), "sys/platform", &fd));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(
	devmgr->devfs_root(), "sys/platform/platform-passthrough/test-board", &fd));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFile(devmgr->devfs_root(),
	"sys/platform/11:18:0/test-device", &fd));
	}

	TEST_F(DevmgrTest, ExceptionCallback) {
	auto devmgr = CreateDevmgrPlatTest();
	ASSERT_TRUE(devmgr);

	bool exception = false;
	devmgr->SetExceptionCallback([&exception](zx_exception_info_t) { exception = true; });

	ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

	zx_handle_t dir;
	ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

	RunLoopUntil([&exception, &dir]() {
	// keep trying to open crash-device until we see an exception
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return exception;
	});
	}

	// Driver manager will never crash, triggering a system reboot.
	TEST_F(DevmgrTest, ExceptionCallback_SystemReboot) {
	auto devmgr = CreateDevmgrPlatTest("reboot-system");
	ASSERT_TRUE(devmgr);

	zx_info_handle_basic_t process_info;
	ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
	sizeof(process_info), nullptr, nullptr),
	ZX_OK);

	std::atomic<bool> driver_manager_crashed = false;
	devmgr->SetExceptionCallback(
	[&driver_manager_crashed, &process_info](zx_exception_info_t exception_info) {
	driver_manager_crashed = process_info.koid == exception_info.pid;
	});

	ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

	zx_handle_t dir;
	ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

	// A single crash should cause driver manager to crash, but we don't know when crash-device will
	// be available.
	RunLoopUntil([&driver_manager_crashed, &dir]() {
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return driver_manager_crashed.load();
	});
	}

	// Driver manager will never crash, and the driver host should be reloaded 3 times.
	TEST_F(DevmgrTest, ExceptionCallback_RestartDriverHost) {
	auto devmgr = CreateDevmgrPlatTest("restart-driver-host");
	ASSERT_TRUE(devmgr);

	zx_info_handle_basic_t process_info;
	ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
	sizeof(process_info), nullptr, nullptr),
	ZX_OK);

	std::atomic<bool> driver_manager_crashed = false;
	std::atomic<uint32_t> exception_count = 0;
	devmgr->SetExceptionCallback([&driver_manager_crashed, &process_info,
	&exception_count](zx_exception_info_t exception_info) {
	driver_manager_crashed = process_info.koid == exception_info.pid;
	exception_count += 1;
	});

	ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

	zx_handle_t dir;
	ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

	RunLoopUntil([&driver_manager_crashed, &dir, &exception_count]() {
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return driver_manager_crashed.load() \|\| exception_count.load() == 4u;
	});

	ASSERT_FALSE(RunLoopWithTimeoutOrUntil(
	[&driver_manager_crashed, &dir]() {
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return driver_manager_crashed.load();
	},
	zx::sec(5)));

	ASSERT_FALSE(driver_manager_crashed.load());
	ASSERT_GE(exception_count.load(), 4u);
	}

	// Driver manager will never crash, and the driver host should never be reloaded.
	TEST_F(DevmgrTest, ExceptionCallback_DoNothing) {
	auto devmgr = CreateDevmgrPlatTest("do-nothing");
	ASSERT_TRUE(devmgr);

	zx_info_handle_basic_t process_info;
	ASSERT_EQ(devmgr->driver_manager_process().get_info(ZX_INFO_HANDLE_BASIC, &process_info,
	sizeof(process_info), nullptr, nullptr),
	ZX_OK);

	std::atomic<bool> driver_manager_crashed = false;
	std::atomic<uint32_t> exception_count = 0;
	devmgr->SetExceptionCallback([&driver_manager_crashed, &process_info,
	&exception_count](zx_exception_info_t exception_info) {
	driver_manager_crashed = process_info.koid == exception_info.pid;
	exception_count += 1;
	});

	ASSERT_EQ(devmgr->WaitForFile("sys/platform/11:00:1f"), ZX_OK);

	zx_handle_t dir;
	ASSERT_EQ(fdio_get_service_handle(devmgr->root(), &dir), ZX_OK);

	RunLoopUntil([&driver_manager_crashed, &dir, &exception_count]() {
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return driver_manager_crashed.load() \|\| exception_count.load() == 1u;
	});

	ASSERT_FALSE(RunLoopWithTimeoutOrUntil(
	[&driver_manager_crashed, &dir]() {
	zx::channel a, b;
	EXPECT_EQ(zx::channel::create(0, &a, &b), ZX_OK);
	fdio_service_connect_at(dir, "sys/platform/11:00:1f/crash-device", b.release());

	return driver_manager_crashed.load();
	},
	zx::sec(5)));

	ASSERT_FALSE(driver_manager_crashed.load());
	ASSERT_EQ(exception_count.load(), 1u);
	}

	TEST_F(DevmgrTest, ExposedThroughComponent) {
	auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
	fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
	ctx->svc()->Connect(launcher.NewRequest());

	zx::channel req;
	auto services = sys::ServiceDirectory::CreateWithRequest(&req);

	fuchsia::sys::LaunchInfo info;
	info.directory_request = std::move(req);
	info.url =
	"fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/"
	"ethertap-devmgr.cmx";
	fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;

	launcher->CreateComponent(std::move(info), ctlr.NewRequest());
	ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });

	zx::channel devfs_req, devfs;
	zx::channel::create(0, &devfs_req, &devfs);
	services->Connect("fuchsia.example.IsolatedDevmgr", std::move(devfs_req));

	auto tap = CreateTapDevice(devfs);
	ASSERT_TRUE(tap);
	}

	TEST_F(DevmgrTest, ExposeDriverFromComponentNamespace) {
	auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
	fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
	ctx->svc()->Connect(launcher.NewRequest());

	zx::channel req;
	auto services = sys::ServiceDirectory::CreateWithRequest(&req);

	fuchsia::sys::LaunchInfo info;
	info.directory_request = std::move(req);
	info.url =
	"fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/"
	"virtual-audio-devmgr.cmx";
	fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;

	launcher->CreateComponent(std::move(info), ctlr.NewRequest());
	ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });

	zx::channel devfs_req, devfs;
	zx::channel::create(0, &devfs_req, &devfs);
	services->Connect("fuchsia.example.IsolatedDevmgr", std::move(devfs_req));

	EnableVirtualAudio(std::move(devfs));
	}

	TEST_F(DevmgrTest, ExposeDevfsToHub) {
	auto ctx = sys::ComponentContext::CreateAndServeOutgoingDirectory();
	fidl::InterfacePtr<fuchsia::sys::Launcher> launcher;
	ctx->svc()->Connect(launcher.NewRequest());

	fuchsia::sys::LaunchInfo info;
	info.url =
	"fuchsia-pkg://fuchsia.com/isolated-devmgr-tests-package#meta/virtual-audio-devmgr.cmx";
	auto echo_svc = sys::ServiceDirectory::CreateWithRequest(&info.directory_request);
	fidl::InterfacePtr<fuchsia::sys::ComponentController> ctlr;
	launcher->CreateComponent(std::move(info), ctlr.NewRequest());

	ctlr.set_error_handler([](zx_status_t err) { FAIL() << "Controller shouldn't exit"; });
	bool ready = false;
	ctlr.events().OnDirectoryReady = [&ready] { ready = true; };
	RunLoopUntil([&ready] { return ready; });
	ASSERT_TRUE(ready);

	// Verify that devfs is indeed visible in outgoing directory
	constexpr char kGlob[] = "/hub/c/virtual-audio-devmgr.cmx/*/out/dev";
	files::Glob glob(kGlob);
	EXPECT_EQ(glob.size(), 1u) << kGlob << " expected to match exactly once.";
	}

	TEST_F(DevmgrTest, DiagnosticsFiles) {
	auto devmgr = CreateDevmgrSysdev();
	ASSERT_TRUE(devmgr);

	fbl::unique_fd fd;
	ASSERT_EQ(ZX_OK,
	device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(), "diagnostics", &fd));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(),
	"diagnostics/class", &fd));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(devmgr->devfs_root(),
	"diagnostics/driver_manager", &fd));
	ASSERT_EQ(ZX_OK,
	device_watcher::RecursiveWaitForFileReadOnly(
	devmgr->devfs_root(), "diagnostics/driver_manager/fuchsia.inspect.Tree", &fd));
	ASSERT_EQ(ZX_OK, device_watcher::RecursiveWaitForFileReadOnly(
	devmgr->devfs_root(), "diagnostics/driver_manager/driver_host", &fd));

	// TODO(fxbug.dev/50569): Add test for root,sys,misc,test driver_host files once koids are
	// available via dm.inspect
	}

	} // namespace testing
	} // namespace isolated_devmgr