// Copyright 2016 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 <ctype.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <threads.h>
#include <unistd.h>
#include <utility>

#include <fbl/string_printf.h>
#include <fbl/unique_fd.h>
#include <fbl/vector.h>
#include <fuchsia/boot/c/fidl.h>
#include <launchpad/launchpad.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/devmgr-launcher/processargs.h>
#include <lib/fdio/directory.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fdio/io.h>
#include <lib/fdio/namespace.h>
#include <lib/fdio/spawn.h>
#include <lib/fdio/watcher.h>
#include <lib/zx/debuglog.h>
#include <lib/zx/event.h>
#include <lib/zx/port.h>
#include <lib/zx/resource.h>
#include <lib/zx/time.h>
#include <lib/zx/vmo.h>
#include <loader-service/loader-service.h>
#include <zircon/boot/image.h>
#include <zircon/device/vfs.h>
#include <zircon/dlfcn.h>
#include <zircon/process.h>
#include <zircon/processargs.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/log.h>
#include <zircon/syscalls/object.h>
#include <zircon/syscalls/policy.h>

#include "boot-args.h"
#include "coordinator.h"
#include "devfs.h"
#include "devhost-loader-service.h"

#include "../shared/env.h"
#include "../shared/fdio.h"
#include "../shared/log.h"

namespace {

constexpr char kArgumentsPath[] = "/bootsvc/" fuchsia_boot_Arguments_Name;
constexpr char kItemsPath[] = "/bootsvc/" fuchsia_boot_Items_Name;
constexpr char kRootResourcePath[] = "/bootsvc/" fuchsia_boot_RootResource_Name;

struct {
    // The handle used to transmit messages to appmgr.
    zx::channel appmgr_client;

    // The handle used by appmgr to serve incoming requests.
    // If appmgr cannot be launched within a timeout, this handle is closed.
    zx::channel appmgr_server;

    zx::unowned_job root_job;
    zx::job svc_job;
    zx::job fuchsia_job;
    zx::channel svchost_outgoing;

    zx::channel fs_root;

    // Used to bind the svchost to the virtual-console binary to provide fidl
    // services.
    zx::channel virtcon_fidl;
} g_handles;

// Wait for the requested file.  Its parent directory must exist.
zx_status_t wait_for_file(const char* path, zx::time deadline) {
    char path_copy[PATH_MAX];
    if (strlen(path) >= PATH_MAX) {
        return ZX_ERR_INVALID_ARGS;
    }
    strcpy(path_copy, path);

    char* last_slash = strrchr(path_copy, '/');
    // Waiting on the root of the fs or paths with no slashes is not supported by this function
    if (last_slash == path_copy || last_slash == nullptr) {
        return ZX_ERR_NOT_SUPPORTED;
    }
    last_slash[0] = 0;
    char* dirname = path_copy;
    char* basename = last_slash + 1;

    auto watch_func = [](int dirfd, int event, const char* fn, void* cookie) -> zx_status_t {
        auto basename = static_cast<const char*>(cookie);
        if (event != WATCH_EVENT_ADD_FILE) {
            return ZX_OK;
        }
        if (!strcmp(fn, basename)) {
            return ZX_ERR_STOP;
        }
        return ZX_OK;
    };

    fbl::unique_fd dirfd(open(dirname, O_RDONLY));
    if (!dirfd.is_valid()) {
        return ZX_ERR_INVALID_ARGS;
    }
    zx_status_t status = fdio_watch_directory(dirfd.get(), watch_func, deadline.get(),
                                              reinterpret_cast<void*>(basename));
    if (status == ZX_ERR_STOP) {
        return ZX_OK;
    }
    return status;
}

void do_autorun(const char* name, const char* cmd) {
    if (cmd != nullptr) {
        auto args = devmgr::ArgumentVector::FromCmdline(cmd);
        args.Print("autorun");
        devmgr::devmgr_launch(g_handles.svc_job, name, args.argv(), nullptr, -1,
                              nullptr, nullptr, 0, nullptr, FS_ALL);
    }
}

// Get kernel arguments from the arguments service.
zx_status_t get_arguments(zx::vmo* args_vmo, size_t* args_size) {
    zx::channel local, remote;
    zx_status_t status = zx::channel::create(0, &local, &remote);
    if (status != ZX_OK) {
        return status;
    }
    status = fdio_service_connect(kArgumentsPath, remote.release());
    if (status != ZX_OK) {
        return status;
    }
    return fuchsia_boot_ArgumentsGet(local.get(), args_vmo->reset_and_get_address(), args_size);
}

// Get ramdisk from the boot items service.
zx_status_t get_ramdisk(zx::vmo* ramdisk_vmo) {
    zx::channel local, remote;
    zx_status_t status = zx::channel::create(0, &local, &remote);
    if (status != ZX_OK) {
        return status;
    }
    status = fdio_service_connect(kItemsPath, remote.release());
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: get_arguments: fdio_service_connect returned %d\n",
                status);
        return status;
    }
    uint32_t length;
    return fuchsia_boot_ItemsGet(local.get(), ZBI_TYPE_STORAGE_RAMDISK, 0,
                                 ramdisk_vmo->reset_and_get_address(), &length);
}

// Get the root resource from the root resource service. Not receiving the
// startup handle is logged, but not fatal.  In test environments, it would not
// be present.
zx_status_t get_root_resource(zx::resource* root_resource) {
    zx::channel local, remote;
    zx_status_t status = zx::channel::create(0, &local, &remote);
    if (status != ZX_OK) {
        return status;
    }
    status = fdio_service_connect(kRootResourcePath, remote.release());
    if (status != ZX_OK) {
        return status;
    }
    return fuchsia_boot_RootResourceGet(local.get(), root_resource->reset_and_get_address());
}

int fuchsia_starter(void* arg) {
    auto coordinator = static_cast<devmgr::Coordinator*>(arg);
    bool appmgr_started = false;
    bool autorun_started = false;
    bool drivers_loaded = false;

    size_t appmgr_timeout = 20;
    zx::time deadline = zx::deadline_after(zx::sec(appmgr_timeout));

    do {
        zx_status_t status = coordinator->fshost_event().wait_one(
            FSHOST_SIGNAL_READY, deadline, nullptr);
        if (status == ZX_ERR_TIMED_OUT) {
            if (g_handles.appmgr_server.is_valid()) {
                if (coordinator->require_system()) {
                    fprintf(stderr, "devcoordinator: appmgr not launched in %zus, closing appmgr handle\n",
                            appmgr_timeout);
                }
                g_handles.appmgr_server.reset();
            }
            deadline = zx::time::infinite();
            continue;
        }
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: error waiting on fuchsia start event: %d\n", status);
            break;
        }
        status = coordinator->fshost_event().signal(FSHOST_SIGNAL_READY, 0);
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: error signaling fshost: %d\n", status);
        }

        if (!drivers_loaded) {
            // we're starting the appmgr because /system is present
            // so we also signal the device coordinator that those
            // drivers are now loadable
            coordinator->set_system_available(true);
            coordinator->ScanSystemDrivers();
            drivers_loaded = true;
        }

        const char* argv_appmgr[] = {
            "/system/bin/appmgr",
            nullptr,
        };

        struct stat s;
        if (!appmgr_started && stat(argv_appmgr[0], &s) == 0) {
            unsigned int appmgr_hnd_count = 0;
            zx_handle_t appmgr_hnds[2] = {};
            uint32_t appmgr_ids[2] = {};
            if (g_handles.appmgr_server.is_valid()) {
                assert(appmgr_hnd_count < fbl::count_of(appmgr_hnds));
                appmgr_hnds[appmgr_hnd_count] = g_handles.appmgr_server.release();
                appmgr_ids[appmgr_hnd_count] = PA_DIRECTORY_REQUEST;
                appmgr_hnd_count++;
            }
            devmgr::devmgr_launch(g_handles.fuchsia_job, "appmgr",
                                  argv_appmgr, nullptr, -1, appmgr_hnds, appmgr_ids,
                                  appmgr_hnd_count, nullptr, FS_FOR_APPMGR);
            appmgr_started = true;
        }
        if (!autorun_started) {
            do_autorun("autorun:system", coordinator->boot_args().Get("zircon.autorun.system"));
            autorun_started = true;
        }
    } while (!appmgr_started);
    return 0;
}

int console_starter(void* arg) {
    auto& boot_args = *static_cast<const devmgr::BootArgs*>(arg);

    // If we got a TERM environment variable (aka a TERM=... argument on
    // the kernel command line), pass this down; otherwise pass TERM=uart.
    const char* term = boot_args.Get("TERM");
    if (term == nullptr) {
        term = "TERM=uart";
    } else {
        term -= sizeof("TERM=") - 1;
    }

    const char* device = boot_args.Get("console.path");
    if (device == nullptr) {
        device = "/dev/misc/console";
    }

    const char* envp[] = {
        term,
        nullptr,
    };

    zx_status_t status = wait_for_file(device, zx::time::infinite());
    if (status != ZX_OK) {
        printf("devcoordinator: failed to wait for console '%s'\n", device);
        return 1;
    }
    fbl::unique_fd fd(open(device, O_RDWR));
    if (!fd.is_valid()) {
        printf("devcoordinator: failed to open console '%s'\n", device);
        return 1;
    }

    const char* argv_sh[] = {"/boot/bin/sh", nullptr};
    devmgr::devmgr_launch(g_handles.svc_job, "sh:console", argv_sh,
                          envp, fd.release(), nullptr, nullptr, 0, nullptr, FS_ALL);
    return 0;
}

int pwrbtn_monitor_starter(void* arg) {
    const char* name = "pwrbtn-monitor";
    const char* argv[] = {"/boot/bin/pwrbtn-monitor", nullptr};

    zx::job job_copy;
    zx_status_t status =
        g_handles.svc_job.duplicate(ZX_RIGHTS_BASIC | ZX_RIGHT_READ | ZX_RIGHT_WRITE, &job_copy);
    if (status != ZX_OK) {
        printf("devcoordinator: svc_job.duplicate failed %s\n", zx_status_get_string(status));
        return 1;
    }

    zx::debuglog debuglog;
    if ((status = zx::debuglog::create(zx::resource(), 0, &debuglog) != ZX_OK)) {
        printf("devcoordinator: cannot create debuglog handle\n");
        return 1;
    }

    zx::channel input_handle = devmgr::fs_clone("dev/class/input");
    if (!input_handle.is_valid()) {
        printf("devcoordinator: failed to clone /dev/input\n");
        return 1;
    }

    zx::channel svc_handle = devmgr::fs_clone("svc");
    if (!svc_handle.is_valid()) {
        printf("devcoordinator: failed to clone /svc\n");
        return 1;
    }

    fdio_spawn_action_t actions[] = {
        {.action = FDIO_SPAWN_ACTION_SET_NAME, .name = {.data = name}},
        {.action = FDIO_SPAWN_ACTION_ADD_NS_ENTRY,
         .ns = {.prefix = "/input", .handle = input_handle.release()}},
        // Ideally we'd only expose /svc/fuchsia.device.manager.Administrator, but we do not
        // support exposing single services.
        {.action = FDIO_SPAWN_ACTION_ADD_NS_ENTRY,
         .ns = {.prefix = "/svc", .handle = svc_handle.release()}},
        {.action = FDIO_SPAWN_ACTION_ADD_HANDLE,
         .h = {.id = PA_HND(PA_FD, FDIO_FLAG_USE_FOR_STDIO | 0),
               .handle = debuglog.release()}},
    };

    char err_msg[FDIO_SPAWN_ERR_MSG_MAX_LENGTH];
    uint32_t spawn_flags = FDIO_SPAWN_CLONE_JOB | FDIO_SPAWN_DEFAULT_LDSVC;
    status = fdio_spawn_etc(job_copy.get(), spawn_flags, argv[0], argv,
                            nullptr, fbl::count_of(actions), actions,
                            nullptr, err_msg);
    if (status != ZX_OK) {
        printf("devcoordinator: spawn %s (%s) failed: %s: %s\n", argv[0], name, err_msg,
               zx_status_get_string(status));
        return 1;
    }

    printf("devcoordinator: launch %s (%s) OK\n", argv[0], name);
    return 0;
}

void start_console_shell(const devmgr::BootArgs& boot_args) {
    // Only start a shell on the kernel console if it isn't already running a shell.
    if (boot_args.GetBool("kernel.shell", false)) {
        return;
    }
    thrd_t t;
    int ret = thrd_create_with_name(&t, console_starter, const_cast<devmgr::BootArgs*>(&boot_args),
                                    "console-starter");
    if (ret == thrd_success) {
        thrd_detach(t);
    }
}

zx_status_t fuchsia_create_job() {
    zx_status_t status = zx::job::create(*g_handles.root_job, 0u, &g_handles.fuchsia_job);
    if (status != ZX_OK) {
        printf("devcoordinator: unable to create fuchsia job: %d (%s)\n", status,
               zx_status_get_string(status));
        return status;
    }

    g_handles.fuchsia_job.set_property(ZX_PROP_NAME, "fuchsia", 7);

    const zx_policy_basic_t basic_policy[] = {
        // Lock down process creation. Child tasks must use fuchsia.process.Launcher.
        {.condition = ZX_POL_NEW_PROCESS, .policy = ZX_POL_ACTION_DENY}};

    status = g_handles.fuchsia_job.set_policy(ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, basic_policy,
                                              fbl::count_of(basic_policy));
    if (status != ZX_OK) {
        printf("devcoordinator: unable to set basic policy for fuchsia job: %d (%s)\n", status,
               zx_status_get_string(status));
        return status;
    }

    // Set the minimum timer slack amount and default mode. The amount should be large enough to
    // allow for some coalescing of timers, but small enough to ensure applications don't miss
    // deadlines.
    //
    // Why LATE and not CENTER or EARLY? Timers firing a little later than requested is not uncommon
    // in non-realtime systems. Programs are generally tolerant of some delays. However, timers
    // firing before their dealine can be unexpected and lead to bugs.
    const zx_policy_timer_slack_t timer_slack_policy{ZX_USEC(500), ZX_TIMER_SLACK_LATE};

    status = g_handles.fuchsia_job.set_policy(ZX_JOB_POL_RELATIVE, ZX_JOB_POL_TIMER_SLACK,
                                              &timer_slack_policy, 1);
    if (status != ZX_OK) {
        printf("devcoordinator: unable to set timer slack policy for fuchsia job: %d (%s)\n", status,
               zx_status_get_string(status));
        return status;
    }

    return ZX_OK;
}

zx_status_t svchost_start(bool require_system, devmgr::Coordinator* coordinator,
                          zx::channel fshost_client) {
    const auto& root_resource = coordinator->root_resource();
    zx::channel dir_request, svchost_local;
    zx::debuglog logger;
    zx::channel appmgr_svc_req;
    zx::channel appmgr_svc;

    zx_status_t status = zx::channel::create(0, &dir_request, &svchost_local);
    if (status != ZX_OK) {
        return status;
    }

    status = zx::debuglog::create(zx::resource(), 0, &logger);
    if (status != ZX_OK) {
        return status;
    }

    status = zx::channel::create(0, &appmgr_svc_req, &appmgr_svc);
    if (status != ZX_OK) {
        return status;
    }

    status =
        fdio_service_connect_at(g_handles.appmgr_client.get(), "svc", appmgr_svc_req.release());
    if (status != ZX_OK) {
        return status;
    }

    const char* name = "svchost";
    const char* argv[2] = {
        "/boot/bin/svchost",
        require_system ? "--require-system" : nullptr,
    };
    int argc = require_system ? 2 : 1;

    zx::job svc_job_copy;
    status = g_handles.svc_job.duplicate(
        ZX_RIGHTS_BASIC | ZX_RIGHT_MANAGE_JOB | ZX_RIGHT_MANAGE_PROCESS, &svc_job_copy);
    if (status != ZX_OK) {
        return status;
    }

    zx::job root_job_copy;
    status = g_handles.root_job->duplicate(ZX_RIGHTS_BASIC | ZX_RIGHTS_IO | ZX_RIGHTS_PROPERTY |
                                               ZX_RIGHT_ENUMERATE | ZX_RIGHT_MANAGE_PROCESS,
                                           &root_job_copy);
    if (status != ZX_OK) {
        return status;
    }

    zx::channel fidl_client;
    {
        zx::channel fidl_server;
        status = zx::channel::create(0, &fidl_server, &fidl_client);
        if (status != ZX_OK) {
            return status;
        }

        status = coordinator->BindOutgoingServices(std::move(fidl_server));
        if (status != ZX_OK) {
            printf("Unable to start fidl services.\n");
            return status;
        }
    }

    zx::channel virtcon_client;
    status = zx::channel::create(0, &virtcon_client, &g_handles.virtcon_fidl);
    if (status != ZX_OK) {
        printf("Unable to create virtcon channel.\n");
        return status;
    }

    // svchost needs to hold this to talk to zx_kerneldebug but doesn't need any rights.
    // TODO(ZX-971): when zx_debug_send_command syscall is descoped, update this too.
    zx::resource root_resource_copy;
    if (root_resource.is_valid()) {
        status = root_resource.duplicate(ZX_RIGHT_TRANSFER, &root_resource_copy);
        if (status != ZX_OK) {
            return status;
        }
    }

    launchpad_t* lp = nullptr;
    launchpad_create(svc_job_copy.get(), name, &lp);
    launchpad_load_from_file(lp, argv[0]);
    launchpad_set_args(lp, argc, argv);
    launchpad_add_handle(lp, dir_request.release(), PA_DIRECTORY_REQUEST);
    launchpad_add_handle(lp, logger.release(), PA_HND(PA_FD, FDIO_FLAG_USE_FOR_STDIO));

    // Remove once svchost hosts the tracelink service itself.
    launchpad_add_handle(lp, appmgr_svc.release(), PA_HND(PA_USER0, 0));

    // Give svchost a restricted root job handle. svchost is already a privileged system service
    // as it controls system-wide process launching. With the root job it can consolidate a few
    // services such as crashsvc and the profile service.
    launchpad_add_handle(lp, root_job_copy.release(), PA_HND(PA_USER0, 1));

    // Also give svchost a restricted root resource handle, this allows it to run the kernel-debug
    // service.
    if (root_resource_copy.is_valid()) {
        launchpad_add_handle(lp, root_resource_copy.release(), PA_HND(PA_USER0, 2));
    }

    // TODO(smklein): Merge "fidl_client" (proxying requests to devmgr) and
    // "fshost_client" (proxying requests to fshost) into one service provider
    // PseudoDirectory.

    // Add handle to channel to allow svchost to proxy fidl services to us.
    launchpad_add_handle(lp, fidl_client.release(), PA_HND(PA_USER0, 3));

    // Add a handle to allow svchost to proxy services to fshost.
    launchpad_add_handle(lp, fshost_client.release(), PA_HND(PA_USER0, 4));
    if (!coordinator->boot_args().GetBool("virtcon.disable", false)) {
        // Add handle to channel to allow svchost to proxy fidl services to
        // virtcon.
        launchpad_add_handle(lp, virtcon_client.release(), PA_HND(PA_USER0, 5));
    }

    // Give svchost access to /dev/class/sysmem, to enable svchost to forward sysmem service
    // requests to the sysmem driver.  Create a namespace containing /dev/class/sysmem.
    const char* nametable[1] = {};
    uint32_t count = 0;
    zx::channel fs_handle = devmgr::fs_clone("dev/class/sysmem");
    if (fs_handle.is_valid()) {
        nametable[count] = "/sysmem";
        launchpad_add_handle(lp, fs_handle.release(), PA_HND(PA_NS_DIR, count++));
    } else {
        launchpad_abort(lp, ZX_ERR_BAD_STATE, "devcoordinator: failed to clone /dev/class/sysmem");
        // The launchpad_go() call below will fail, but will still free lp.
    }

    launchpad_set_nametable(lp, count, nametable);

    const char* errmsg = nullptr;
    if ((status = launchpad_go(lp, nullptr, &errmsg)) != ZX_OK) {
        printf("devcoordinator: launchpad %s (%s) failed: %s: %d\n", argv[0], name, errmsg, status);
        return status;
    } else {
        printf("devcoordinator: launch %s (%s) OK\n", argv[0], name);
    }

    zx::channel svchost_public_remote;
    status = zx::channel::create(0, &svchost_public_remote, &g_handles.svchost_outgoing);
    if (status != ZX_OK) {
        return status;
    }

    return fdio_service_connect_at(svchost_local.get(), "public", svchost_public_remote.release());
}

void fshost_start(devmgr::Coordinator* coordinator, const devmgr::DevmgrArgs& devmgr_args,
                  zx::channel fshost_server) {
    // assemble handles to pass down to fshost
    zx_handle_t handles[ZX_CHANNEL_MAX_MSG_HANDLES];
    uint32_t types[fbl::count_of(handles)];
    size_t n = 0;
    zx_handle_t ldsvc;

    // Pass "fs_root", and ldsvc handles to fshost.
    if (zx_channel_create(0, g_handles.fs_root.reset_and_get_address(), &handles[n]) == ZX_OK) {
        types[n++] = PA_HND(PA_USER0, 0);
    }
    if (zx_channel_create(0, &ldsvc, &handles[n]) == ZX_OK) {
        types[n++] = PA_HND(PA_USER0, 2);
    } else {
        ldsvc = ZX_HANDLE_INVALID;
    }

    // The "public directory" of the fshost service.
    handles[n] = fshost_server.release();
    types[n++] = PA_HND(PA_USER0, 3);

    // pass fuchsia start event to fshost
    zx::event fshost_event_duplicate;
    if (coordinator->fshost_event().duplicate(ZX_RIGHT_SAME_RIGHTS, &fshost_event_duplicate) ==
        ZX_OK) {
        handles[n] = fshost_event_duplicate.release();
        types[n++] = PA_HND(PA_USER1, 0);
    }

    // pass VDSO VMOS to fshost
    for (uint32_t m = 0; n < fbl::count_of(handles); m++) {
        uint32_t type = PA_HND(PA_VMO_VDSO, m);
        if (m == 0) {
            // By this point, launchpad has already moved PA_HND(PA_VMO_VDSO, 0) into a static.
            handles[n] = ZX_HANDLE_INVALID;
            launchpad_get_vdso_vmo(&handles[n]);
        } else {
            handles[n] = zx_take_startup_handle(type);
        }

        if (handles[n] != ZX_HANDLE_INVALID) {
            types[n++] = type;
        } else {
            break;
        }
    }

    // pass ramdisk to fshost
    zx::vmo ramdisk_vmo;
    zx_status_t status = get_ramdisk(&ramdisk_vmo);
    if (status == ZX_OK && ramdisk_vmo.is_valid()) {
        handles[n] = ramdisk_vmo.release();
        types[n++] = PA_HND(PA_VMO_BOOTDATA, 0);
    }

    // pass command line to the fshost
    fbl::Vector<const char*> args{"/boot/bin/fshost"};
    if (coordinator->boot_args().GetBool("netsvc.netboot", false) ||
        coordinator->boot_args().GetBool("zircon.system.disable-automount", false)) {
        args.push_back("--netboot");
    }
    if (devmgr_args.disable_block_watcher) {
        args.push_back("--disable-block-watcher");
    }
    args.push_back(nullptr);

    // pass zircon.system.* options to the fshost as environment variables
    fbl::Vector<const char*> env;
    coordinator->boot_args().Collect("zircon.system", &env);
    env.push_back(nullptr);

    devmgr::devmgr_launch(g_handles.svc_job, "fshost", args.get(), env.get(), -1, handles, types, n,
                          nullptr, FS_BOOT | FS_DEV | FS_SVC);

    // switch to system loader service provided by fshost
    zx_handle_close(dl_set_loader_service(ldsvc));
}

void devmgr_vfs_init(devmgr::Coordinator* coordinator, const devmgr::DevmgrArgs& devmgr_args,
                     bool needs_svc_mount, zx::channel fshost_server) {
    fdio_ns_t* ns;
    zx_status_t r;
    r = fdio_ns_get_installed(&ns);
    ZX_ASSERT_MSG(r == ZX_OK, "devcoordinator: cannot get namespace: %s\n", zx_status_get_string(r));
    r = fdio_ns_bind(ns, "/dev", devmgr::fs_clone("dev").release());
    ZX_ASSERT_MSG(r == ZX_OK, "devcoordinator: cannot bind /dev to namespace: %s\n",
                  zx_status_get_string(r));

    if (needs_svc_mount) {
        r = fdio_ns_bind(ns, "/svc", devmgr::fs_clone("svc").release());
        ZX_ASSERT_MSG(r == ZX_OK, "devcoordinator: cannot bind /svc to namespace: %s\n",
                      zx_status_get_string(r));
    }

    // Start fshost before binding /system, since it publishes it.
    fshost_start(coordinator, devmgr_args, std::move(fshost_server));

    if ((r = fdio_ns_bind(ns, "/system", devmgr::fs_clone("system").release())) != ZX_OK) {
        printf("devcoordinator: cannot bind /system to namespace: %d\n", r);
    }
}

int service_starter(void* arg) {
    auto coordinator = static_cast<devmgr::Coordinator*>(arg);

    bool netboot = false;
    bool vruncmd = false;
    fbl::String vcmd;
    if (!(coordinator->boot_args().GetBool("netsvc.disable", false) ||
          coordinator->disable_netsvc())) {
        const char* args[] = {
            "/boot/bin/netsvc", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
        int argc = 1;

        if (coordinator->boot_args().GetBool("netsvc.netboot", false)) {
            args[argc++] = "--netboot";
            netboot = true;
            vruncmd = true;
        }

        if (coordinator->boot_args().GetBool("netsvc.advertise", true)) {
            args[argc++] = "--advertise";
        }

        const char* interface = coordinator->boot_args().Get("netsvc.interface");
        if (interface != nullptr) {
            args[argc++] = "--interface";
            args[argc++] = interface;
        }

        const char* nodename = coordinator->boot_args().Get("zircon.nodename");
        if (nodename) {
            args[argc++] = nodename;
        }

        zx::process proc;
        zx_status_t status = devmgr::devmgr_launch(g_handles.svc_job, "netsvc", args, nullptr, -1,
                                                   nullptr, nullptr, 0, &proc, FS_ALL);
        if (status == ZX_OK) {
            if (vruncmd) {
                zx_info_handle_basic_t info = {};
                proc.get_info(ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
                proc.reset();
                vcmd = fbl::StringPrintf("dlog -f -t -p %zu", info.koid);
            }
        } else {
            vruncmd = false;
        }
        __UNUSED auto leaked_handle = proc.release();
    }

    if (!coordinator->boot_args().GetBool("virtcon.disable", false)) {
        // pass virtcon.* options along
        fbl::Vector<const char*> env;
        coordinator->boot_args().Collect("virtcon.", &env);
        env.push_back(nullptr);

        const char* num_shells =
            coordinator->require_system() && !netboot ? "0" : "3";
        size_t handle_count = 0;
        zx_handle_t handles[2];
        uint32_t types[2];

        handles[handle_count] = g_handles.virtcon_fidl.release();
        types[handle_count] = PA_HND(PA_USER0, 0);
        ++handle_count;

        zx::debuglog debuglog;
        zx_status_t status = zx::debuglog::create(coordinator->root_resource(),
                                                  ZX_LOG_FLAG_READABLE, &debuglog);
        if (status == ZX_OK) {
            handles[handle_count] = debuglog.release();
            types[handle_count] = PA_HND(PA_USER0, 1);
            ++handle_count;
        }

        const char* args[] = {"/boot/bin/virtual-console", "--shells", num_shells, nullptr, nullptr,
                              nullptr};
        if (vruncmd) {
            args[3] = "--run";
            args[4] = vcmd.data();
        }
        devmgr::devmgr_launch(g_handles.svc_job, "virtual-console", args, env.get(), -1, handles,
                              types, handle_count, nullptr, FS_ALL);
    }

    const char* epoch = coordinator->boot_args().Get("devmgr.epoch");
    if (epoch) {
        zx_time_t offset = ZX_SEC(atoi(epoch));
        zx_clock_adjust(coordinator->root_resource().get(), ZX_CLOCK_UTC, offset);
    }

    do_autorun("autorun:boot", coordinator->boot_args().Get("zircon.autorun.boot"));

    thrd_t t;
    int ret = thrd_create_with_name(&t, fuchsia_starter, coordinator, "fuchsia-starter");
    if (ret == thrd_success) {
        thrd_detach(t);
    }

    return 0;
}

void ParseArgs(int argc, char** argv, devmgr::DevmgrArgs* out) {
    enum {
        kDriverSearchPath,
        kLoadDriver,
        kSysDeviceDriver,
        kUseSystemSvchost,
        kDisableBlockWatcher,
        kDisableNetsvc,
    };
    option options[] = {
        {"driver-search-path", required_argument, nullptr, kDriverSearchPath},
        {"load-driver", required_argument, nullptr, kLoadDriver},
        {"sys-device-driver", required_argument, nullptr, kSysDeviceDriver},
        {"use-system-svchost", no_argument, nullptr, kUseSystemSvchost},
        {"disable-block-watcher", no_argument, nullptr, kDisableBlockWatcher},
        {"disable-netsvc", no_argument, nullptr, kDisableNetsvc},
    };

    auto print_usage_and_exit = [options]() {
        printf("devcoordinator: supported arguments:\n");
        for (const auto& option : options) {
            printf("  --%s\n", option.name);
        }
        abort();
    };

    auto check_not_duplicated = [print_usage_and_exit](const char* arg) {
        if (arg != nullptr) {
            printf("devcoordinator: duplicated argument\n");
            print_usage_and_exit();
        }
    };

    // Reset the args state
    *out = devmgr::DevmgrArgs();

    int opt;
    while ((opt = getopt_long(argc, argv, "", options, nullptr)) != -1) {
        switch (opt) {
        case kDriverSearchPath:
            out->driver_search_paths.push_back(optarg);
            break;
        case kLoadDriver:
            out->load_drivers.push_back(optarg);
            break;
        case kSysDeviceDriver:
            check_not_duplicated(out->sys_device_driver);
            out->sys_device_driver = optarg;
            break;
        case kUseSystemSvchost:
            out->use_system_svchost = true;
            break;
        case kDisableBlockWatcher:
            out->disable_block_watcher = true;
            break;
        case kDisableNetsvc:
            out->disable_netsvc = true;
            break;
        default:
            print_usage_and_exit();
        }
    }
}

zx_status_t CreateDevhostJob(const zx::job& root_job, zx::job* devhost_job_out) {
    zx::job devhost_job;
    zx_status_t status = zx::job::create(root_job, 0u, &devhost_job);
    if (status != ZX_OK) {
        log(ERROR, "devcoordinator: unable to create devhost job\n");
        return status;
    }
    static const zx_policy_basic_t policy[] = {
        {ZX_POL_BAD_HANDLE, ZX_POL_ACTION_EXCEPTION},
    };
    status = devhost_job.set_policy(ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy,
                                    fbl::count_of(policy));
    if (status != ZX_OK) {
        log(ERROR, "devcoordinator: zx_job_set_policy() failed\n");
        return status;
    }
    status = devhost_job.set_property(ZX_PROP_NAME, "zircon-drivers", 15);
    if (status != ZX_OK) {
        log(ERROR, "devcoordinator: zx_job_set_property() failed\n");
        return status;
    }

    *devhost_job_out = std::move(devhost_job);
    return ZX_OK;
}

} // namespace

namespace devmgr {

zx::channel fs_clone(const char* path) {
    if (!strcmp(path, "dev")) {
        return devfs_root_clone();
    }
    zx::channel h0, h1;
    if (zx::channel::create(0, &h0, &h1) != ZX_OK) {
        return zx::channel();
    }
    if (!strcmp(path, "boot")) {
        fdio_open("/boot", ZX_FS_RIGHT_READABLE, h1.release());
        return h0;
    }
    zx::unowned_channel fs(g_handles.fs_root);
    int flags = FS_DIR_FLAGS;
    if (!strcmp(path, "hub")) {
        fs = zx::unowned_channel(g_handles.appmgr_client);
    } else if (!strcmp(path, "svc")) {
        flags = ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE;
        fs = zx::unowned_channel(g_handles.svchost_outgoing);
        path = ".";
    } else if (!strncmp(path, "dev/", 4)) {
        fs = devfs_root_borrow();
        path += 4;
    }
    fdio_open_at(fs->get(), path, flags, h1.release());
    return h0;
}

} // namespace devmgr

int main(int argc, char** argv) {
    devmgr::BootArgs boot_args;
    zx::vmo args_vmo;
    size_t args_size;
    zx_status_t status = get_arguments(&args_vmo, &args_size);
    if (status == ZX_OK) {
        status = devmgr::BootArgs::Create(std::move(args_vmo), args_size, &boot_args);
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: failed to create boot arguments (size %lu): %d\n",
                    args_size, status);
            return 1;
        }
    } else {
        fprintf(stderr, "devcoordinator: failed to get boot arguments (status: %d), assuming test "
                        "environment and continuing\n", status);
    }

    if (boot_args.GetBool("devmgr.verbose", false)) {
        devmgr::log_flags |= LOG_ALL;
    }

    devmgr::DevmgrArgs devmgr_args;
    ParseArgs(argc, argv, &devmgr_args);
    // Set up the default values for our arguments if they weren't given.
    if (devmgr_args.driver_search_paths.size() == 0) {
        devmgr_args.driver_search_paths.push_back("/boot/driver");
    }
    if (devmgr_args.sys_device_driver == nullptr) {
        devmgr_args.sys_device_driver = "/boot/driver/platform-bus.so";
    }

    g_handles.root_job = zx::job::default_job();
    g_handles.root_job->set_property(ZX_PROP_NAME, "root", 4);
    bool require_system = boot_args.GetBool("devmgr.require-system", false);

    async::Loop loop(&kAsyncLoopConfigNoAttachToThread);
    devmgr::CoordinatorConfig config{};
    config.dispatcher = loop.dispatcher();
    config.boot_args = &boot_args;
    config.require_system = require_system;
    config.asan_drivers = boot_args.GetBool("devmgr.devhost.asan", false);
    config.suspend_fallback = boot_args.GetBool("devmgr.suspend-timeout-fallback", false);
    config.suspend_debug = boot_args.GetBool("devmgr.suspend-timeout-debug", false);
    config.disable_netsvc = devmgr_args.disable_netsvc;

    status = get_root_resource(&config.root_resource);
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: failed to get root resource, assuming test "
                        "environment and continuing\n");
    }
    // TODO: limit to enumerate rights
    status = g_handles.root_job->duplicate(ZX_RIGHT_SAME_RIGHTS, &config.sysinfo_job);
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: failed to duplicate root job for sysinfo: %d\n", status);
    }
    status = CreateDevhostJob(*g_handles.root_job, &config.devhost_job);
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: failed to create devhost job: %d\n", status);
        return 1;
    }
    status = zx::event::create(0, &config.fshost_event);
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: failed to create fshost event: %d\n", status);
        return 1;
    }

    devmgr::Coordinator coordinator(std::move(config));
    status = coordinator.InitializeCoreDevices(devmgr_args.sys_device_driver);
    if (status != ZX_OK) {
        log(ERROR, "devcoordinator: failed to initialize core devices\n");
        return 1;
    }

    devmgr::devfs_init(coordinator.root_device(), loop.dispatcher());
    devfs_publish(coordinator.root_device(), coordinator.misc_device());
    devfs_publish(coordinator.root_device(), coordinator.sys_device());
    devfs_publish(coordinator.root_device(), coordinator.test_device());

    // Check if whatever launched devmgr gave a channel to be connected to /dev.
    // This is for use in tests to let the test environment see devfs.
    zx::channel devfs_client(zx_take_startup_handle(DEVMGR_LAUNCHER_DEVFS_ROOT_HND));
    if (devfs_client.is_valid()) {
        fdio_service_clone_to(devmgr::devfs_root_borrow()->get(), devfs_client.release());
    }

    status = zx::job::create(*g_handles.root_job, 0u, &g_handles.svc_job);
    if (status != ZX_OK) {
        fprintf(stderr, "devcoordinator: failed to create service job: %d\n", status);
        return 1;
    }
    g_handles.svc_job.set_property(ZX_PROP_NAME, "zircon-services", 16);

    status = fuchsia_create_job();
    if (status != ZX_OK) {
        return 1;
    }

    zx::channel fshost_client, fshost_server;
    zx::channel::create(0, &fshost_client, &fshost_server);
    zx::channel::create(0, &g_handles.appmgr_client, &g_handles.appmgr_server);

    if (devmgr_args.use_system_svchost) {
        zx::channel dir_request;
        zx_status_t status = zx::channel::create(0, &dir_request, &g_handles.svchost_outgoing);
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: failed to create svchost_outgoing channel\n");
            return 1;
        }
        status = fdio_service_connect("/svc", dir_request.release());
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: failed to connect to /svc\n");
            return 1;
        }
    } else {
        status = svchost_start(require_system, &coordinator, std::move(fshost_client));
        if (status != ZX_OK) {
            fprintf(stderr, "devcoordinator: failed to start svchost: %d", status);
            return 1;
        }
    }

    const bool needs_svc_mount = !devmgr_args.use_system_svchost;
    devmgr_vfs_init(&coordinator, devmgr_args, needs_svc_mount, std::move(fshost_server));

    // If this is not a full Fuchsia build, do not setup appmgr services, as
    // this will delay startup.
    if (!require_system) {
        devmgr::devmgr_disable_appmgr_services();
    }

    thrd_t t;
    int ret = thrd_create_with_name(&t, pwrbtn_monitor_starter, nullptr, "pwrbtn-monitor-starter");
    if (ret != thrd_success) {
        log(ERROR, "devcoordinator: failed to create pwrbtn monitor starter thread\n");
        return 1;
    }
    thrd_detach(t);

    start_console_shell(boot_args);

    ret = thrd_create_with_name(&t, service_starter, &coordinator, "service-starter");
    if (ret != thrd_success) {
        log(ERROR, "devcoordinator: failed to create service starter thread\n");
        return 1;
    }
    thrd_detach(t);

    fbl::unique_ptr<devmgr::DevhostLoaderService> loader_service;
    if (boot_args.GetBool("devmgr.devhost.strict-linking", false)) {
        status = devmgr::DevhostLoaderService::Create(loop.dispatcher(), &loader_service);
        if (status != ZX_OK) {
            return 1;
        }
        coordinator.set_loader_service(loader_service.get());
    }

    for (const char* path : devmgr_args.driver_search_paths) {
        devmgr::find_loadable_drivers(
            path, fit::bind_member(&coordinator, &devmgr::Coordinator::DriverAddedInit));
    }
    for (const char* driver : devmgr_args.load_drivers) {
        devmgr::load_driver(driver,
                            fit::bind_member(&coordinator, &devmgr::Coordinator::DriverAddedInit));
    }

    // Special case early handling for the ramdisk boot
    // path where /system is present before the coordinator
    // starts.  This avoids breaking the "priority hack" and
    // can be removed once the real driver priority system
    // exists.
    if (coordinator.system_available()) {
        status = coordinator.ScanSystemDrivers();
        if (status != ZX_OK) {
            return 1;
        }
    }

    if (coordinator.require_system() && !coordinator.system_loaded()) {
        printf(
            "devcoordinator: full system required, ignoring fallback drivers until /system is loaded\n");
    } else {
        coordinator.UseFallbackDrivers();
    }

    coordinator.PrepareProxy(coordinator.sys_device(), nullptr);
    coordinator.PrepareProxy(coordinator.test_device(), nullptr);
    // Initial bind attempt for drivers enumerated at startup.
    coordinator.BindDrivers();

    coordinator.set_running(true);
    status = loop.Run();
    fprintf(stderr, "devcoordinator: coordinator exited unexpectedly: %d\n", status);
    return status == ZX_OK ? 0 : 1;
}