X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=ee99f2166da870e6fbb1e368b1a1b9311af611b6;hp=7533cfa1d514b0b6f80048ad7362b5b932b3f94f;hb=4466139b7bf4573b6b85555bb1ff7e31fbaaa934;hpb=3b29ff8c2a6489b9517d61c0f63256a1ad0c36f7 diff --git a/discover/device-handler.c b/discover/device-handler.c index 7533cfa..ee99f21 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -7,16 +7,19 @@ #include #include +#include #include #include #include #include #include +#include #include "device-handler.h" #include "discover-server.h" #include "event.h" #include "parser.h" +#include "resource.h" #include "udev.h" #include "paths.h" #include "boot.h" @@ -27,175 +30,191 @@ struct device_handler { struct discover_device **devices; unsigned int n_devices; + + struct waitset *waitset; + struct waiter *timeout_waiter; + bool autoboot_enabled; + unsigned int sec_to_boot; + + struct discover_boot_option *default_boot_option; + struct list unresolved_boot_options; }; +void discover_context_add_boot_option(struct discover_context *ctx, + struct discover_boot_option *boot_option) +{ + boot_option->source = ctx->parser; + list_add_tail(&ctx->boot_options, &boot_option->list); + talloc_steal(ctx, boot_option); +} + /** - * context_commit - Commit a temporary discovery context to the handler, - * and notify the clients about any new options / devices + * device_handler_get_device_count - Get the count of current handler devices. */ -static void context_commit(struct device_handler *handler, - struct discover_context *ctx) + +int device_handler_get_device_count(const struct device_handler *handler) { - struct discover_device *dev = ctx->device; - unsigned int i, existing_device; - struct boot_option *opt, *tmp; + return handler->n_devices; +} - /* do we already have this device? */ - for (i = 0; i < handler->n_devices; i++) { - if (ctx->device == handler->devices[i]) { - existing_device = 1; - break; - } +/** + * device_handler_get_device - Get a handler device by index. + */ + +const struct discover_device *device_handler_get_device( + const struct device_handler *handler, unsigned int index) +{ + if (index >= handler->n_devices) { + assert(0 && "bad index"); + return NULL; } - /* if not already present, add the device to the handler's array */ - if (!existing_device) { - handler->n_devices++; - handler->devices = talloc_realloc(handler, handler->devices, - struct discover_device *, handler->n_devices); - handler->devices[handler->n_devices - 1] = dev; - talloc_steal(handler, dev); + return handler->devices[index]; +} - discover_server_notify_device_add(handler->server, dev->device); - } +struct discover_boot_option *discover_boot_option_create( + struct discover_context *ctx, + struct discover_device *device) +{ + struct discover_boot_option *opt; + opt = talloc_zero(ctx, struct discover_boot_option); + opt->option = talloc_zero(opt, struct boot_option); + opt->device = device; - /* move boot options from the context to the device */ - list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) { - list_remove(&opt->list); - list_add(&dev->device->boot_options, &opt->list); - dev->device->n_options++; - discover_server_notify_boot_option_add(handler->server, opt); - } + return opt; } -void discover_context_add_boot_option(struct discover_context *ctx, - struct boot_option *boot_option) +static int device_match_path(struct discover_device *dev, const char *path) { - list_add(&ctx->boot_options, &boot_option->list); - talloc_steal(ctx, boot_option); + return dev->device_path && !strcmp(dev->device_path, path); } -/** - * device_handler_remove - Remove a device from the handler device array. - */ +static int device_match_uuid(struct discover_device *dev, const char *uuid) +{ + return dev->uuid && !strcmp(dev->uuid, uuid); +} -static void device_handler_remove(struct device_handler *handler, - struct discover_device *device) +static int device_match_label(struct discover_device *dev, const char *label) { + return dev->label && !strcmp(dev->label, label); +} + +static int device_match_id(struct discover_device *dev, const char *id) +{ + return !strcmp(dev->device->id, id); +} + +static struct discover_device *device_lookup( + struct device_handler *device_handler, + int (match_fn)(struct discover_device *, const char *), + const char *str) +{ + struct discover_device *dev; unsigned int i; - for (i = 0; i < handler->n_devices; i++) - if (handler->devices[i] == device) - break; + if (!str) + return NULL; - if (i == handler->n_devices) { - assert(0 && "unknown device"); - return; + for (i = 0; i < device_handler->n_devices; i++) { + dev = device_handler->devices[i]; + + if (match_fn(dev, str)) + return dev; } - handler->n_devices--; - memmove(&handler->devices[i], &handler->devices[i + 1], - (handler->n_devices - i) * sizeof(handler->devices[0])); - handler->devices = talloc_realloc(handler, handler->devices, - struct discover_device *, handler->n_devices); + return NULL; +} - discover_server_notify_device_remove(handler->server, device->device); +struct discover_device *device_lookup_by_name(struct device_handler *handler, + const char *name) +{ + struct discover_device *dev; + char *path; - talloc_free(device); -} + if (strncmp(name, "/dev/", strlen("/dev/"))) + path = talloc_asprintf(NULL, "/dev/%s", name); + else + path = talloc_strdup(NULL, name); -/** - * device_handler_get_device_count - Get the count of current handler devices. - */ + dev = device_lookup_by_path(handler, path); -int device_handler_get_device_count(const struct device_handler *handler) -{ - return handler->n_devices; + talloc_free(path); + + return dev; } -/** - * device_handler_get_device - Get a handler device by index. - */ +struct discover_device *device_lookup_by_path( + struct device_handler *device_handler, + const char *path) +{ + return device_lookup(device_handler, device_match_path, path); +} -const struct device *device_handler_get_device( - const struct device_handler *handler, unsigned int index) +struct discover_device *device_lookup_by_uuid( + struct device_handler *device_handler, + const char *uuid) { - if (index >= handler->n_devices) { - assert(0 && "bad index"); - return NULL; - } + return device_lookup(device_handler, device_match_uuid, uuid); +} - return handler->devices[index]->device; +struct discover_device *device_lookup_by_label( + struct device_handler *device_handler, + const char *label) +{ + return device_lookup(device_handler, device_match_label, label); } -static void setup_device_links(struct discover_device *dev) +struct discover_device *device_lookup_by_id( + struct device_handler *device_handler, + const char *id) { - struct link { - const char *dir, *val; - } *link, links[] = { - { - .dir = "disk/by-uuid", - .val = dev->uuid, - }, - { - .dir = "disk/by-label", - .val = dev->label, - }, - { - .dir = NULL - } - }; + return device_lookup(device_handler, device_match_id, id); +} - for (link = links; link->dir; link++) { - char *enc, *dir, *path; +void device_handler_destroy(struct device_handler *handler) +{ + talloc_free(handler); +} - if (!link->val || !*link->val) - continue; +#ifdef PETITBOOT_TEST - enc = encode_label(dev, link->val); - dir = join_paths(dev, mount_base(), link->dir); - path = join_paths(dev, dir, enc); - - if (!pb_mkdir_recursive(dir)) { - unlink(path); - if (symlink(dev->mount_path, path)) { - pb_log("symlink(%s,%s): %s\n", - dev->mount_path, path, - strerror(errno)); - talloc_free(path); - } else { - int i = dev->n_links++; - dev->links = talloc_realloc(dev, - dev->links, char *, - dev->n_links); - dev->links[i] = path; - } +/* we have a simplified interface for petitboot testing, but still want + * to keep struct device_handler opaque. */ +struct device_handler *device_handler_init( + struct discover_server *server __attribute__((unused)), + struct waitset *waitset __attribute__((unused)), + int dry_run __attribute__((unused))) +{ + struct device_handler *handler; - } + handler = talloc_zero(NULL, struct device_handler); + list_init(&handler->unresolved_boot_options); - talloc_free(dir); - talloc_free(enc); - } + return handler; } -static void remove_device_links(struct discover_device *dev) +void device_handler_add_device(struct device_handler *handler, + struct discover_device *dev) { - int i; - - for (i = 0; i < dev->n_links; i++) - unlink(dev->links[i]); + handler->n_devices++; + handler->devices = talloc_realloc(handler, handler->devices, + struct discover_device *, handler->n_devices); + handler->devices[handler->n_devices - 1] = dev; } +#else + static int mount_device(struct discover_device *dev) { - const char *mountpoint; const char *argv[6]; - if (!dev->mount_path) { - mountpoint = mountpoint_for_device(dev->device_path); - dev->mount_path = talloc_strdup(dev, mountpoint); - } + if (!dev->device_path) + return -1; + + if (!dev->mount_path) + dev->mount_path = join_paths(dev, mount_base(), + dev->device_path); if (pb_mkdir_recursive(dev->mount_path)) pb_log("couldn't create mount directory %s: %s\n", @@ -221,7 +240,6 @@ static int mount_device(struct discover_device *dev) goto out_rmdir; } - setup_device_links(dev); return 0; out_rmdir: @@ -234,8 +252,6 @@ static int umount_device(struct discover_device *dev) int status; pid_t pid; - remove_device_links(dev); - if (!dev->mount_path) return 0; @@ -265,6 +281,38 @@ static int umount_device(struct discover_device *dev) return 0; } +struct device_handler *device_handler_init(struct discover_server *server, + struct waitset *waitset, int dry_run) +{ + struct device_handler *handler; + + handler = talloc(NULL, struct device_handler); + handler->devices = NULL; + handler->n_devices = 0; + handler->server = server; + handler->waitset = waitset; + handler->dry_run = dry_run; + handler->default_boot_option = NULL; + handler->autoboot_enabled = config_get()->autoboot_enabled; + list_init(&handler->unresolved_boot_options); + + /* set up our mount point base */ + pb_mkdir_recursive(mount_base()); + + parser_init(); + + return handler; +} + +static int destroy_device(void *arg) +{ + struct discover_device *dev = arg; + + umount_device(dev); + + return 0; +} + static struct discover_device *find_device(struct device_handler *handler, const char *id) { @@ -280,15 +328,6 @@ static struct discover_device *find_device(struct device_handler *handler, return NULL; } -static int destroy_device(void *arg) -{ - struct discover_device *dev = arg; - - umount_device(dev); - - return 0; -} - static struct discover_device *discover_device_create( struct device_handler *handler, struct discover_context *ctx, @@ -303,7 +342,7 @@ static struct discover_device *discover_device_create( dev = talloc_zero(ctx, struct discover_device); dev->device = talloc_zero(dev, struct device); - list_init(&dev->device->boot_options); + list_init(&dev->boot_options); devname = event_get_param(ctx->event, "DEVNAME"); if (devname) @@ -316,6 +355,260 @@ static struct discover_device *discover_device_create( return dev; } +/** + * device_handler_remove - Remove a device from the handler device array. + */ + +static void device_handler_remove(struct device_handler *handler, + struct discover_device *device) +{ + unsigned int i; + + for (i = 0; i < handler->n_devices; i++) + if (handler->devices[i] == device) + break; + + if (i == handler->n_devices) { + assert(0 && "unknown device"); + return; + } + + handler->n_devices--; + memmove(&handler->devices[i], &handler->devices[i + 1], + (handler->n_devices - i) * sizeof(handler->devices[0])); + handler->devices = talloc_realloc(handler, handler->devices, + struct discover_device *, handler->n_devices); + + discover_server_notify_device_remove(handler->server, device->device); + + talloc_free(device); +} + +static void boot_status(void *arg, struct boot_status *status) +{ + struct device_handler *handler = arg; + + discover_server_notify_boot_status(handler->server, status); +} + +static void countdown_status(struct device_handler *handler, + struct discover_boot_option *opt, unsigned int sec) +{ + struct boot_status status; + + status.type = BOOT_STATUS_INFO; + status.progress = -1; + status.detail = NULL; + status.message = talloc_asprintf(handler, + "Booting %s in %d sec", opt->option->name, sec); + + discover_server_notify_boot_status(handler->server, &status); + + talloc_free(status.message); +} + +static int default_timeout(void *arg) +{ + struct device_handler *handler = arg; + struct discover_boot_option *opt; + + if (!handler->default_boot_option) + return 0; + + opt = handler->default_boot_option; + + if (handler->sec_to_boot) { + countdown_status(handler, opt, handler->sec_to_boot); + handler->sec_to_boot--; + handler->timeout_waiter = waiter_register_timeout( + handler->waitset, 1000, + default_timeout, handler); + return 0; + } + + pb_log("Timeout expired, booting default option %s\n", opt->option->id); + + boot(handler, handler->default_boot_option, NULL, + handler->dry_run, boot_status, handler); + return 0; +} + +static void set_default(struct device_handler *handler, + struct discover_boot_option *opt) +{ + if (handler->default_boot_option) + return; + + if (!handler->autoboot_enabled) + return; + + pb_log("Boot option %s set as default\n", opt->option->id); + + handler->default_boot_option = opt; + handler->sec_to_boot = DEFAULT_BOOT_TIMEOUT_SEC; + default_timeout(handler); +} + +static bool resource_is_resolved(struct resource *res) +{ + return !res || res->resolved; +} + +/* We only use this in an assert, which will disappear if we're compiling + * with NDEBUG, so we need the 'used' attribute for these builds */ +static bool __attribute__((used)) boot_option_is_resolved( + struct discover_boot_option *opt) +{ + return resource_is_resolved(opt->boot_image) && + resource_is_resolved(opt->initrd) && + resource_is_resolved(opt->dtb) && + resource_is_resolved(opt->icon); +} + +static bool resource_resolve(struct resource *res, const char *name, + struct discover_boot_option *opt, + struct device_handler *handler) +{ + struct parser *parser = opt->source; + + if (resource_is_resolved(res)) + return true; + + pb_log("Attempting to resolve resource %s->%s with parser %s\n", + opt->option->id, name, parser->name); + parser->resolve_resource(handler, res); + + return res->resolved; +} + +static bool boot_option_resolve(struct discover_boot_option *opt, + struct device_handler *handler) +{ + return resource_resolve(opt->boot_image, "boot_image", opt, handler) && + resource_resolve(opt->initrd, "initrd", opt, handler) && + resource_resolve(opt->dtb, "dtb", opt, handler) && + resource_resolve(opt->icon, "icon", opt, handler); +} + +static void boot_option_finalise(struct device_handler *handler, + struct discover_boot_option *opt) +{ + assert(boot_option_is_resolved(opt)); + + /* check that the parsers haven't set any of the final data */ + assert(!opt->option->boot_image_file); + assert(!opt->option->initrd_file); + assert(!opt->option->dtb_file); + assert(!opt->option->icon_file); + assert(!opt->option->device_id); + + if (opt->boot_image) + opt->option->boot_image_file = opt->boot_image->url->full; + if (opt->initrd) + opt->option->initrd_file = opt->initrd->url->full; + if (opt->dtb) + opt->option->dtb_file = opt->dtb->url->full; + if (opt->icon) + opt->option->icon_file = opt->icon->url->full; + + opt->option->device_id = opt->device->device->id; + + if (opt->option->is_default) + set_default(handler, opt); +} + +static void process_boot_option_queue(struct device_handler *handler) +{ + struct discover_boot_option *opt, *tmp; + + list_for_each_entry_safe(&handler->unresolved_boot_options, + opt, tmp, list) { + + pb_log("queue: attempting resolution for %s\n", + opt->option->id); + + if (!boot_option_resolve(opt, handler)) + continue; + + pb_log("\tresolved!\n"); + + list_remove(&opt->list); + list_add_tail(&opt->device->boot_options, &opt->list); + talloc_steal(opt->device, opt); + boot_option_finalise(handler, opt); + discover_server_notify_boot_option_add(handler->server, + opt->option); + } +} + +/** + * context_commit - Commit a temporary discovery context to the handler, + * and notify the clients about any new options / devices + */ +static void context_commit(struct device_handler *handler, + struct discover_context *ctx) +{ + struct discover_device *dev = ctx->device; + struct discover_boot_option *opt, *tmp; + unsigned int i, existing_device = 0; + + /* do we already have this device? */ + for (i = 0; i < handler->n_devices; i++) { + if (ctx->device == handler->devices[i]) { + existing_device = 1; + break; + } + } + + /* if not already present, add the device to the handler's array */ + if (!existing_device) { + handler->n_devices++; + handler->devices = talloc_realloc(handler, handler->devices, + struct discover_device *, handler->n_devices); + handler->devices[handler->n_devices - 1] = dev; + talloc_steal(handler, dev); + + discover_server_notify_device_add(handler->server, dev->device); + + /* this new device might be able to resolve existing boot + * options */ + pb_log("New device %s, processing queue\n", dev->device->id); + process_boot_option_queue(handler); + } + + + /* move boot options from the context to the device */ + list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) { + list_remove(&opt->list); + + if (boot_option_resolve(opt, handler)) { + pb_log("boot option %s is resolved, " + "sending to clients\n", + opt->option->id); + list_add_tail(&dev->boot_options, &opt->list); + talloc_steal(dev, opt); + boot_option_finalise(handler, opt); + discover_server_notify_boot_option_add(handler->server, + opt->option); + } else { + if (!opt->source->resolve_resource) { + pb_log("parser %s gave us an unresolved " + "resource (%s), but no way to " + "resolve it\n", + opt->source->name, opt->option->id); + talloc_free(opt); + } else { + pb_log("boot option %s is unresolved, " + "adding to queue\n", + opt->option->id); + list_add(&handler->unresolved_boot_options, + &opt->list); + talloc_steal(handler, opt); + } + } + } +} + static int handle_add_udev_event(struct device_handler *handler, struct event *event) { @@ -350,7 +643,7 @@ static int handle_add_udev_event(struct device_handler *handler, } /* run the parsers. This will populate the ctx's boot_option list. */ - iterate_parsers(ctx); + iterate_parsers(ctx, CONF_METHOD_LOCAL_FILE); /* add discovered stuff to the handler */ context_commit(handler, ctx); @@ -413,6 +706,61 @@ static int handle_remove_user_event(struct device_handler *handler, return 0; } +static enum conf_method parse_conf_method(const char *str) +{ + + if (!strcasecmp(str, "dhcp")) { + return CONF_METHOD_DHCP; + } + return CONF_METHOD_UNKNOWN; +} + +static int handle_conf_user_event(struct device_handler *handler, + struct event *event) +{ + struct discover_context *ctx; + struct discover_device *dev; + enum conf_method method; + const char *val; + + ctx = talloc(handler, struct discover_context); + ctx->event = event; + list_init(&ctx->boot_options); + + val = event_get_param(event, "url"); + if (!val) { + talloc_free(ctx); + return 0; + } + + ctx->conf_url = pb_url_parse(ctx, val); + if (!ctx->conf_url) { + talloc_free(ctx); + return 0; + } + + val = event_get_param(event, "method"); + if (!val) { + talloc_free(ctx); + return 0; + } + + method = parse_conf_method(val); + if (method == CONF_METHOD_UNKNOWN) { + talloc_free(ctx); + return 0; + } + + dev = discover_device_create(handler, ctx, event); + ctx->device = dev; + + iterate_parsers(ctx, method); + + context_commit(handler, ctx); + + return 0; +} + typedef int (*event_handler)(struct device_handler *, struct event *); static event_handler handlers[EVENT_TYPE_MAX][EVENT_ACTION_MAX] = { @@ -423,6 +771,7 @@ static event_handler handlers[EVENT_TYPE_MAX][EVENT_ACTION_MAX] = { [EVENT_TYPE_USER] = { [EVENT_ACTION_ADD] = handle_add_user_event, [EVENT_ACTION_REMOVE] = handle_remove_user_event, + [EVENT_ACTION_CONF] = handle_conf_user_event, } }; @@ -440,41 +789,17 @@ int device_handler_event(struct device_handler *handler, return handlers[event->type][event->action](handler, event); } -struct device_handler *device_handler_init(struct discover_server *server, - int dry_run) -{ - struct device_handler *handler; - - handler = talloc(NULL, struct device_handler); - handler->devices = NULL; - handler->n_devices = 0; - handler->server = server; - handler->dry_run = dry_run; - - /* set up our mount point base */ - pb_mkdir_recursive(mount_base()); - - parser_init(); - - return handler; -} - -void device_handler_destroy(struct device_handler *handler) -{ - talloc_free(handler); -} - -static struct boot_option *find_boot_option_by_id( +static struct discover_boot_option *find_boot_option_by_id( struct device_handler *handler, const char *id) { unsigned int i; for (i = 0; i < handler->n_devices; i++) { struct discover_device *dev = handler->devices[i]; - struct boot_option *opt; + struct discover_boot_option *opt; - list_for_each_entry(&dev->device->boot_options, opt, list) - if (!strcmp(opt->id, id)) + list_for_each_entry(&dev->boot_options, opt, list) + if (!strcmp(opt->option->id, id)) return opt; } @@ -484,9 +809,36 @@ static struct boot_option *find_boot_option_by_id( void device_handler_boot(struct device_handler *handler, struct boot_command *cmd) { - struct boot_option *opt; + struct discover_boot_option *opt; opt = find_boot_option_by_id(handler, cmd->option_id); - boot(handler, opt, cmd, handler->dry_run); + boot(handler, opt, cmd, handler->dry_run, boot_status, handler); +} + +void device_handler_cancel_default(struct device_handler *handler) +{ + struct boot_status status; + + if (handler->timeout_waiter) + waiter_remove(handler->timeout_waiter); + + handler->timeout_waiter = NULL; + handler->autoboot_enabled = false; + + /* we only send status if we had a default boot option queued */ + if (!handler->default_boot_option) + return; + + pb_log("Cancelling default boot option\n"); + + handler->default_boot_option = NULL; + + status.type = BOOT_STATUS_INFO; + status.progress = -1; + status.detail = NULL; + status.message = "Default boot cancelled"; + + discover_server_notify_boot_status(handler->server, &status); } +#endif