| // Copyright 2018 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 <fidl/fuchsia.device/cpp/wire.h> | |
| #include <fidl/fuchsia.storage.block/cpp/wire.h> | |
| #include <lib/component/incoming/cpp/protocol.h> | |
| #include <lib/fdio/cpp/caller.h> | |
| #include <lib/fdio/watcher.h> | |
| #include <memory> | |
| #include <fbl/unique_fd.h> | |
| #include "src/lib/uuid/uuid.h" | |
| void usage() { | |
| fprintf(stderr, | |
| "usage: waitfor <expr>+ wait for devices to be published\n" | |
| "\n" | |
| "expr: class=<name> device class <name> (required)\n" | |
| "\n" | |
| " topo=<path> topological path contains <path>\n" | |
| " part.guid=<guid> block device GUID matches <guid>\n" | |
| " part.type.guid=<guid> partition type GUID matches <guid>\n" | |
| " part.name=<name> partition name matches <name>\n" | |
| "\n" | |
| " timeout=<msec> fail if no match after <msec> milliseconds\n" | |
| " print write name of matching devices to stdout\n" | |
| " forever don't stop after the first match\n" | |
| " also don't fail on timeout after first match\n" | |
| " verbose print debug chatter to stderr\n" | |
| "\n" | |
| "example: waitfor class=block part.name=system print\n"); | |
| } | |
| struct App; | |
| class Rule { | |
| public: | |
| using Func = zx_status_t (*)(const App& app, const char* arg, | |
| fidl::UnownedClientEnd<fuchsia_io::Directory> dir, const char* name); | |
| Rule(const char* arg, Func func) : func_(func), arg_(arg) {} | |
| zx_status_t Call(const App& app, fidl::UnownedClientEnd<fuchsia_io::Directory> dir, | |
| const char* name) const { | |
| return func_(app, arg_, dir, name); | |
| } | |
| private: | |
| Func func_; | |
| const char* arg_; | |
| }; | |
| struct App { | |
| bool matched; | |
| const bool verbose; | |
| const bool print; | |
| const bool forever; | |
| const char* devclass; | |
| const std::vector<Rule> rules; | |
| }; | |
| zx_status_t watchcb(int dirfd, int event, const char* fn, void* cookie) { | |
| if (std::string_view{fn} == ".") { | |
| return ZX_OK; | |
| } | |
| if (event != WATCH_EVENT_ADD_FILE) { | |
| return ZX_OK; | |
| } | |
| App& app = *static_cast<App*>(cookie); | |
| if (app.verbose) { | |
| fprintf(stderr, "waitfor: device='/dev/class/%s/%s'\n", app.devclass, fn); | |
| } | |
| const fdio_cpp::UnownedFdioCaller caller(dirfd); | |
| for (const Rule& r : app.rules) { | |
| switch (const zx_status_t status = r.Call(app, caller.directory(), fn); status) { | |
| case ZX_OK: | |
| // rule matched | |
| continue; | |
| case ZX_ERR_NEXT: | |
| // rule did not match | |
| return ZX_OK; | |
| default: | |
| // fatal error | |
| return status; | |
| } | |
| } | |
| app.matched = true; | |
| if (app.print) { | |
| printf("/dev/class/%s/%s\n", app.devclass, fn); | |
| } | |
| if (app.forever) { | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_STOP; | |
| } | |
| // Expression evaluators return OK on match, NEXT on no-match | |
| // any other error is fatal | |
| zx_status_t expr_topo(const App& app, const char* arg, | |
| fidl::UnownedClientEnd<fuchsia_io::Directory> dir, const char* name) { | |
| std::string controller_path = std::string(name) + "/device_controller"; | |
| zx::result controller = | |
| component::ConnectAt<fuchsia_device::Controller>(dir, controller_path.c_str()); | |
| if (controller.is_error()) { | |
| fprintf(stderr, "waitfor: warning: failed to open: '%s' :%s \n", name, | |
| controller.status_string()); | |
| return controller.error_value(); | |
| } | |
| const fidl::WireResult result = fidl::WireCall(controller.value())->GetTopologicalPath(); | |
| if (!result.ok()) { | |
| fprintf(stderr, "waitfor: warning: cannot request topological path: '%s': %s\n", | |
| controller_path.c_str(), result.FormatDescription().c_str()); | |
| return result.status(); | |
| } | |
| const auto* res = result.Unwrap(); | |
| if (res->is_error()) { | |
| const zx_status_t status = res->error_value(); | |
| fprintf(stderr, "waitfor: warning: failed to get topological path: %s\n", | |
| zx_status_get_string(status)); | |
| return status; | |
| } | |
| const std::string_view got = res->value()->path.get(); | |
| const std::string_view expected(arg); | |
| if (app.verbose) { | |
| fprintf(stderr, "waitfor: topological path='%s'\n", std::string(got).c_str()); | |
| } | |
| // Check if the topo path contains our needle. | |
| if (got.find(expected) != std::string::npos) { | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_NEXT; | |
| } | |
| zx_status_t expr_part_guid(const App& app, const char* arg, | |
| fidl::UnownedClientEnd<fuchsia_io::Directory> dir, const char* name) { | |
| zx::result partition = component::ConnectAt<fuchsia_storage_block::Block>(dir, name); | |
| if (partition.is_error()) { | |
| fprintf(stderr, "waitfor: warning: failed to open: '%s :%s \n", name, | |
| partition.status_string()); | |
| return partition.error_value(); | |
| } | |
| const fidl::WireResult result = fidl::WireCall(partition.value())->GetInstanceGuid(); | |
| if (!result.ok()) { | |
| fprintf(stderr, "waitfor: warning: cannot request instance guid: %s\n", | |
| result.FormatDescription().c_str()); | |
| return result.status(); | |
| } | |
| const fidl::WireResponse response = result.value(); | |
| if (const zx_status_t status = response.status; status != ZX_OK) { | |
| fprintf(stderr, "waitfor: warning: cannot get instance guid: %s\n", | |
| zx_status_get_string(status)); | |
| return result.status(); | |
| } | |
| fidl::Array value = response.guid->value; | |
| static_assert(decltype(value)::size() == uuid::kUuidSize); | |
| const std::string text = uuid::Uuid(value.data()).ToString(); | |
| if (app.verbose) { | |
| fprintf(stderr, "waitfor: part.guid='%s'\n", text.c_str()); | |
| } | |
| if (strcasecmp(text.c_str(), arg) == 0) { | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_NEXT; | |
| } | |
| zx_status_t expr_part_type_guid(const App& app, const char* arg, | |
| fidl::UnownedClientEnd<fuchsia_io::Directory> dir, | |
| const char* name) { | |
| zx::result partition = component::ConnectAt<fuchsia_storage_block::Block>(dir, name); | |
| if (partition.is_error()) { | |
| fprintf(stderr, "waitfor: warning: failed to open: '%s' :%s \n", name, | |
| partition.status_string()); | |
| return partition.error_value(); | |
| } | |
| const fidl::WireResult result = fidl::WireCall(partition.value())->GetTypeGuid(); | |
| if (!result.ok()) { | |
| fprintf(stderr, "waitfor: warning: cannot request type guid: %s\n", | |
| result.FormatDescription().c_str()); | |
| return result.status(); | |
| } | |
| const fidl::WireResponse response = result.value(); | |
| if (const zx_status_t status = response.status; status != ZX_OK) { | |
| fprintf(stderr, "waitfor: warning: cannot get type guid: %s\n", zx_status_get_string(status)); | |
| return result.status(); | |
| } | |
| fidl::Array value = response.guid->value; | |
| static_assert(decltype(value)::size() == uuid::kUuidSize); | |
| const std::string text = uuid::Uuid(value.data()).ToString(); | |
| if (app.verbose) { | |
| fprintf(stderr, "waitfor: part.type.guid='%s'\n", text.c_str()); | |
| } | |
| if (strcasecmp(text.c_str(), arg) == 0) { | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_NEXT; | |
| } | |
| zx_status_t expr_part_name(const App& app, const char* arg, | |
| fidl::UnownedClientEnd<fuchsia_io::Directory> dir, const char* name) { | |
| zx::result partition = component::ConnectAt<fuchsia_storage_block::Block>(dir, name); | |
| if (partition.is_error()) { | |
| fprintf(stderr, "waitfor: warning: failed to open: '%s' :%s \n", name, | |
| partition.status_string()); | |
| return partition.error_value(); | |
| } | |
| const fidl::WireResult result = fidl::WireCall(partition.value())->GetName(); | |
| if (!result.ok()) { | |
| fprintf(stderr, "waitfor: warning: cannot request partition name: %s\n", | |
| result.FormatDescription().c_str()); | |
| return result.status(); | |
| } | |
| const fidl::WireResponse response = result.value(); | |
| if (const zx_status_t status = response.status; status != ZX_OK) { | |
| fprintf(stderr, "waitfor: warning: cannot get type guid: %s\n", zx_status_get_string(status)); | |
| return result.status(); | |
| } | |
| const std::string partition_name(response.name.get()); | |
| if (app.verbose) { | |
| fprintf(stderr, "waitfor: part.name='%s'\n", partition_name.c_str()); | |
| } | |
| if (strcmp(arg, partition_name.c_str()) == 0) { | |
| return ZX_OK; | |
| } | |
| return ZX_ERR_NEXT; | |
| } | |
| int main(int argc, char** argv) { | |
| if (argc == 1) { | |
| usage(); | |
| exit(1); | |
| } | |
| bool print = false; | |
| bool verbose = false; | |
| bool forever = false; | |
| zx_duration_t timeout = 0; | |
| const char* devclass = nullptr; | |
| std::vector<Rule> rules; | |
| while (argc > 1) { | |
| if (!strcmp(argv[1], "print")) { | |
| print = true; | |
| } else if (!strcmp(argv[1], "verbose")) { | |
| verbose = true; | |
| } else if (!strcmp(argv[1], "forever")) { | |
| forever = true; | |
| } else if (!strncmp(argv[1], "timeout=", 8)) { | |
| timeout = ZX_MSEC(atoi(argv[1] + 8)); | |
| if (timeout == 0) { | |
| fprintf(stderr, "waitfor: error: timeout of 0 not allowed\n"); | |
| exit(1); | |
| } | |
| } else if (!strncmp(argv[1], "class=", 6)) { | |
| devclass = argv[1] + 6; | |
| } else if (!strncmp(argv[1], "topo=", 5)) { | |
| rules.emplace_back(argv[1] + 5, expr_topo); | |
| } else if (!strncmp(argv[1], "part.guid=", 10)) { | |
| rules.emplace_back(argv[1] + 10, expr_part_guid); | |
| } else if (!strncmp(argv[1], "part.type.guid=", 15)) { | |
| rules.emplace_back(argv[1] + 15, expr_part_guid); | |
| } else if (!strncmp(argv[1], "part.name=", 10)) { | |
| rules.emplace_back(argv[1] + 10, expr_part_name); | |
| } else { | |
| fprintf(stderr, "waitfor: error: unknown expr '%s'\n\n", argv[1]); | |
| usage(); | |
| exit(1); | |
| } | |
| argc--; | |
| argv++; | |
| } | |
| if (devclass == nullptr) { | |
| fprintf(stderr, "waitfor: error: no class specified\n"); | |
| exit(1); | |
| } | |
| if (rules.empty()) { | |
| fprintf(stderr, "waitfor: error: no match expressions specified\n"); | |
| exit(1); | |
| } | |
| const std::string path = std::string("/dev/class/") + devclass; | |
| const fbl::unique_fd dirfd(open(path.c_str(), O_DIRECTORY | O_RDONLY)); | |
| if (!dirfd.is_valid()) { | |
| fprintf(stderr, "waitfor: error: cannot watch class '%s': %s\n", devclass, strerror(errno)); | |
| exit(1); | |
| } | |
| zx_instant_mono_t deadline; | |
| if (timeout == 0) { | |
| deadline = ZX_TIME_INFINITE; | |
| } else { | |
| deadline = zx_deadline_after(timeout); | |
| } | |
| App app = { | |
| .verbose = verbose, | |
| .print = print, | |
| .forever = forever, | |
| .devclass = devclass, | |
| .rules = std::move(rules), | |
| }; | |
| switch (const zx_status_t status = fdio_watch_directory(dirfd.get(), watchcb, deadline, &app); | |
| status) { | |
| case ZX_ERR_STOP: | |
| // clean exit on a match | |
| return 0; | |
| case ZX_ERR_TIMED_OUT: | |
| // timeout, but if we're in forever mode and matched any, its good | |
| if (app.matched && app.forever) { | |
| return 0; | |
| } | |
| break; | |
| default: | |
| // any other situation? failure | |
| return 1; | |
| } | |
| } |