X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=ee99f2166da870e6fbb1e368b1a1b9311af611b6;hp=9e4c5bb228ebb285b9a905198e69f930e862d8e4;hb=4466139b7bf4573b6b85555bb1ff7e31fbaaa934;hpb=9af0c65fa5ba9ae8527a70dbf0e808d777dfb479 diff --git a/discover/device-handler.c b/discover/device-handler.c index 9e4c5bb..ee99f21 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -7,6 +7,7 @@ #include #include +#include #include #include #include @@ -30,208 +31,187 @@ 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; }; -static bool resource_is_resolved(struct resource *res) +void discover_context_add_boot_option(struct discover_context *ctx, + struct discover_boot_option *boot_option) { - return !res || res->resolved; + boot_option->source = ctx->parser; + list_add_tail(&ctx->boot_options, &boot_option->list); + talloc_steal(ctx, boot_option); } -/* 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) +/** + * device_handler_get_device_count - Get the count of current handler devices. + */ + +int device_handler_get_device_count(const struct device_handler *handler) { - return resource_is_resolved(opt->boot_image) && - resource_is_resolved(opt->initrd) && - resource_is_resolved(opt->icon); + return handler->n_devices; } -static bool resource_resolve(struct resource *res, struct parser *parser, - struct device_handler *handler) +/** + * 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 (resource_is_resolved(res)) - return true; + if (index >= handler->n_devices) { + assert(0 && "bad index"); + return NULL; + } - parser->resolve_resource(handler, res); + return handler->devices[index]; +} - return res->resolved; +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; + + return opt; } -static bool boot_option_resolve(struct discover_boot_option *opt, - struct device_handler *handler) +static int device_match_path(struct discover_device *dev, const char *path) { - return resource_resolve(opt->boot_image, opt->source, handler) && - resource_resolve(opt->initrd, opt->source, handler) && - resource_resolve(opt->icon, opt->source, handler); + return dev->device_path && !strcmp(dev->device_path, path); } -static void boot_option_finalise(struct discover_boot_option *opt) +static int device_match_uuid(struct discover_device *dev, const char *uuid) { - assert(boot_option_is_resolved(opt)); + return dev->uuid && !strcmp(dev->uuid, uuid); +} - /* 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->icon_file); +static int device_match_label(struct discover_device *dev, const char *label) +{ + return dev->label && !strcmp(dev->label, label); +} - 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->icon) - opt->option->icon_file = opt->icon->url->full; +static int device_match_id(struct discover_device *dev, const char *id) +{ + return !strcmp(dev->device->id, id); } -static void process_boot_option_queue(struct device_handler *handler) +static struct discover_device *device_lookup( + struct device_handler *device_handler, + int (match_fn)(struct discover_device *, const char *), + const char *str) { - struct discover_boot_option *opt, *tmp; + struct discover_device *dev; + unsigned int i; - list_for_each_entry_safe(&handler->unresolved_boot_options, - opt, tmp, list) { + if (!str) + return NULL; - if (!boot_option_resolve(opt, handler)) - continue; + for (i = 0; i < device_handler->n_devices; i++) { + dev = device_handler->devices[i]; - list_remove(&opt->list); - list_add(&opt->device->boot_options, &opt->list); - talloc_steal(opt->device, opt); - boot_option_finalise(opt); - discover_server_notify_boot_option_add(handler->server, - opt->option); + if (match_fn(dev, str)) + return dev; } + + return NULL; } -/** - * 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 *device_lookup_by_name(struct device_handler *handler, + const char *name) { - 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; - } - } + struct discover_device *dev; + char *path; - /* 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); + if (strncmp(name, "/dev/", strlen("/dev/"))) + path = talloc_asprintf(NULL, "/dev/%s", name); + else + path = talloc_strdup(NULL, name); - discover_server_notify_device_add(handler->server, dev->device); + dev = device_lookup_by_path(handler, path); - /* this new device might be able to resolve existing boot - * options */ - process_boot_option_queue(handler); - } + talloc_free(path); + return dev; +} - /* move boot options from the context to the device */ - list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) { - list_remove(&opt->list); +struct discover_device *device_lookup_by_path( + struct device_handler *device_handler, + const char *path) +{ + return device_lookup(device_handler, device_match_path, path); +} - if (boot_option_resolve(opt, handler)) { - list_add(&dev->boot_options, &opt->list); - talloc_steal(dev, opt); - boot_option_finalise(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); - } - } - } +struct discover_device *device_lookup_by_uuid( + struct device_handler *device_handler, + const char *uuid) +{ + return device_lookup(device_handler, device_match_uuid, uuid); } -void discover_context_add_boot_option(struct discover_context *ctx, - struct discover_boot_option *boot_option) +struct discover_device *device_lookup_by_label( + struct device_handler *device_handler, + const char *label) { - boot_option->source = ctx->parser; - list_add(&ctx->boot_options, &boot_option->list); - talloc_steal(ctx, boot_option); + return device_lookup(device_handler, device_match_label, label); } -/** - * device_handler_remove - Remove a device from the handler device array. - */ +struct discover_device *device_lookup_by_id( + struct device_handler *device_handler, + const char *id) +{ + return device_lookup(device_handler, device_match_id, id); +} -static void device_handler_remove(struct device_handler *handler, - struct discover_device *device) +void device_handler_destroy(struct device_handler *handler) { - unsigned int i; + talloc_free(handler); +} - for (i = 0; i < handler->n_devices; i++) - if (handler->devices[i] == device) - break; +#ifdef PETITBOOT_TEST - 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); +/* 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; - discover_server_notify_device_remove(handler->server, device->device); + handler = talloc_zero(NULL, struct device_handler); + list_init(&handler->unresolved_boot_options); - talloc_free(device); + return handler; } -/** - * device_handler_get_device_count - Get the count of current handler devices. - */ - -int device_handler_get_device_count(const struct device_handler *handler) +void device_handler_add_device(struct device_handler *handler, + struct discover_device *dev) { - return handler->n_devices; + handler->n_devices++; + handler->devices = talloc_realloc(handler, handler->devices, + struct discover_device *, handler->n_devices); + handler->devices[handler->n_devices - 1] = dev; } -/** - * 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; - } - - return handler->devices[index]; -} +#else static int mount_device(struct discover_device *dev) { const char *argv[6]; + if (!dev->device_path) + return -1; + if (!dev->mount_path) dev->mount_path = join_paths(dev, mount_base(), dev->device_path); @@ -301,70 +281,333 @@ static int umount_device(struct discover_device *dev) return 0; } -static struct discover_device *find_device(struct device_handler *handler, - const char *id) +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) +{ + struct discover_device *dev; + unsigned int i; + + for (i = 0; i < handler->n_devices; i++) { + dev = handler->devices[i]; + if (!strcmp(dev->device->id, id)) + return dev; + } + + return NULL; +} + +static struct discover_device *discover_device_create( + struct device_handler *handler, + struct discover_context *ctx, + struct event *event) +{ + struct discover_device *dev; + const char *devname; + + dev = find_device(handler, event->device); + if (dev) + return dev; + + dev = talloc_zero(ctx, struct discover_device); + dev->device = talloc_zero(dev, struct device); + list_init(&dev->boot_options); + + devname = event_get_param(ctx->event, "DEVNAME"); + if (devname) + dev->device_path = talloc_strdup(dev, devname); + + dev->device->id = talloc_strdup(dev, event->device); + + talloc_set_destructor(dev, destroy_device); + + 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) { - struct discover_device *dev; - unsigned int i; - - for (i = 0; i < handler->n_devices; i++) { - dev = handler->devices[i]; - if (!strcmp(dev->device->id, id)) - return dev; - } - - return NULL; + 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 int destroy_device(void *arg) +static void boot_option_finalise(struct device_handler *handler, + struct discover_boot_option *opt) { - struct discover_device *dev = arg; + assert(boot_option_is_resolved(opt)); - umount_device(dev); + /* 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); - return 0; + 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 struct discover_device *discover_device_create( - struct device_handler *handler, - struct discover_context *ctx, - struct event *event) +static void process_boot_option_queue(struct device_handler *handler) { - struct discover_device *dev; - const char *devname; - - dev = find_device(handler, event->device); - if (dev) - return dev; + struct discover_boot_option *opt, *tmp; - dev = talloc_zero(ctx, struct discover_device); - dev->device = talloc_zero(dev, struct device); - list_init(&dev->boot_options); + list_for_each_entry_safe(&handler->unresolved_boot_options, + opt, tmp, list) { - devname = event_get_param(ctx->event, "DEVNAME"); - if (devname) - dev->device_path = talloc_strdup(dev, devname); + pb_log("queue: attempting resolution for %s\n", + opt->option->id); - dev->device->id = talloc_strdup(dev, event->device); + if (!boot_option_resolve(opt, handler)) + continue; - talloc_set_destructor(dev, destroy_device); + pb_log("\tresolved!\n"); - return dev; + 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); + } } -struct discover_boot_option *discover_boot_option_create( - struct discover_context *ctx, - struct discover_device *device) +/** + * 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_boot_option *opt; + struct discover_device *dev = ctx->device; + struct discover_boot_option *opt, *tmp; + unsigned int i, existing_device = 0; - opt = talloc_zero(ctx, struct discover_boot_option); - opt->option = talloc_zero(opt, struct boot_option); - opt->device = device; + /* do we already have this device? */ + for (i = 0; i < handler->n_devices; i++) { + if (ctx->device == handler->devices[i]) { + existing_device = 1; + break; + } + } - return opt; -} + /* 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) @@ -546,118 +789,6 @@ 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; - list_init(&handler->unresolved_boot_options); - - /* 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 int device_match_path(struct discover_device *dev, const char *path) -{ - return !strcmp(dev->device_path, path); -} - -static int device_match_uuid(struct discover_device *dev, const char *uuid) -{ - return dev->uuid && !strcmp(dev->uuid, uuid); -} - -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; - - if (!str) - return NULL; - - for (i = 0; i < device_handler->n_devices; i++) { - dev = device_handler->devices[i]; - - if (match_fn(dev, str)) - return dev; - } - - return NULL; -} - -struct discover_device *device_lookup_by_name(struct device_handler *handler, - const char *name) -{ - struct discover_device *dev; - char *path; - - if (strncmp(name, "/dev/", strlen("/dev/"))) - path = talloc_asprintf(NULL, "/dev/%s", name); - else - path = talloc_strdup(NULL, name); - - dev = device_lookup_by_path(handler, path); - - talloc_free(path); - - return dev; -} - -struct discover_device *device_lookup_by_path( - struct device_handler *device_handler, - const char *path) -{ - return device_lookup(device_handler, device_match_path, path); -} - -struct discover_device *device_lookup_by_uuid( - struct device_handler *device_handler, - const char *uuid) -{ - return device_lookup(device_handler, device_match_uuid, uuid); -} - -struct discover_device *device_lookup_by_label( - struct device_handler *device_handler, - const char *label) -{ - return device_lookup(device_handler, device_match_label, label); -} - -struct discover_device *device_lookup_by_id( - struct device_handler *device_handler, - const char *id) -{ - return device_lookup(device_handler, device_match_id, id); -} - static struct discover_boot_option *find_boot_option_by_id( struct device_handler *handler, const char *id) { @@ -675,13 +806,6 @@ static struct discover_boot_option *find_boot_option_by_id( return NULL; } -static void boot_status(void *arg, struct boot_status *status) -{ - struct device_handler *handler = arg; - - discover_server_notify_boot_status(handler->server, status); -} - void device_handler_boot(struct device_handler *handler, struct boot_command *cmd) { @@ -691,3 +815,30 @@ void device_handler_boot(struct device_handler *handler, 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