}
struct discover_device *discover_device_create(struct device_handler *handler,
- const char *id)
+ const char *uuid, const char *id)
{
struct discover_device *dev;
- dev = device_lookup_by_id(handler, id);
+ if (uuid)
+ dev = device_lookup_by_uuid(handler, uuid);
+ else
+ dev = device_lookup_by_id(handler, id);
+
if (dev)
return dev;
dev = talloc_zero(handler, struct discover_device);
dev->device = talloc_zero(dev, struct device);
dev->device->id = talloc_strdup(dev->device, id);
+ dev->uuid = talloc_strdup(dev, uuid);
list_init(&dev->params);
list_init(&dev->boot_options);
struct discover_boot_option *opt, *tmp;
unsigned int i;
+ list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
+ if (opt == handler->default_boot_option) {
+ pb_log("Default option %s cancelled since device removed",
+ opt->option->name);
+ device_handler_cancel_default(handler);
+ break;
+ }
+ }
+
for (i = 0; i < handler->n_devices; i++)
if (handler->devices[i] == device)
break;
talloc_free(device);
}
-void device_handler_boot_status(void *arg, struct boot_status *status)
+void device_handler_status(struct device_handler *handler,
+ struct status *status)
{
- struct device_handler *handler = arg;
-
discover_server_notify_boot_status(handler->server, status);
}
+static void _device_handler_vstatus(struct device_handler *handler,
+ enum status_type type, const char *fmt, va_list ap)
+{
+ struct status status;
+
+ status.type = type;
+ status.message = talloc_vasprintf(handler, fmt, ap);
+
+ device_handler_status(handler, &status);
+
+ talloc_free(status.message);
+}
+
+void device_handler_status_info(struct device_handler *handler,
+ const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ _device_handler_vstatus(handler, STATUS_INFO, fmt, ap);
+ va_end(ap);
+}
+
+void device_handler_status_err(struct device_handler *handler,
+ const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ _device_handler_vstatus(handler, STATUS_ERROR, fmt, ap);
+ va_end(ap);
+}
+
+static void device_handler_boot_status_cb(void *arg, struct status *status)
+{
+ device_handler_status(arg, status);
+}
+
static void countdown_status(struct device_handler *handler,
struct discover_boot_option *opt, unsigned int sec)
{
- struct boot_status status;
+ struct status status;
- status.type = BOOT_STATUS_INFO;
- status.progress = -1;
- status.detail = NULL;
+ status.type = STATUS_INFO;
status.message = talloc_asprintf(handler,
_("Booting in %d sec: %s"), sec, opt->option->name);
- discover_server_notify_boot_status(handler->server, &status);
+ device_handler_status(handler, &status);
talloc_free(status.message);
}
platform_pre_boot();
handler->pending_boot = boot(handler, handler->default_boot_option,
- NULL, handler->dry_run, device_handler_boot_status,
+ NULL, handler->dry_run, device_handler_boot_status_cb,
handler);
handler->pending_boot_is_default = true;
return 0;
return resource_is_resolved(opt->boot_image) &&
resource_is_resolved(opt->initrd) &&
resource_is_resolved(opt->dtb) &&
+ resource_is_resolved(opt->args_sig_file) &&
resource_is_resolved(opt->icon);
}
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->args_sig_file, "args_sig_file", opt,
+ handler) &&
resource_resolve(opt->icon, "icon", opt, handler);
}
assert(!opt->option->dtb_file);
assert(!opt->option->icon_file);
assert(!opt->option->device_id);
+ assert(!opt->option->args_sig_file);
if (opt->boot_image)
opt->option->boot_image_file = opt->boot_image->url->full;
opt->option->dtb_file = opt->dtb->url->full;
if (opt->icon)
opt->option->icon_file = opt->icon->url->full;
+ if (opt->args_sig_file)
+ opt->option->args_sig_file = opt->args_sig_file->url->full;
opt->option->device_id = opt->device->device->id;
return ctx;
}
-/**
- * context_commit - Commit a temporary discovery context to the handler,
- * and notify the clients about any new options / devices
- */
-void device_handler_discover_context_commit(struct device_handler *handler,
- struct discover_context *ctx)
-{
- struct discover_device *dev = ctx->device;
- struct discover_boot_option *opt, *tmp;
-
- if (!device_lookup_by_id(handler, dev->device->id))
- device_handler_add_device(handler, 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);
-
- 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);
- notify_boot_option(handler, opt);
- } 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);
- }
- }
- }
-}
-
void device_handler_add_device(struct device_handler *handler,
struct discover_device *device)
{
struct discover_device *dev)
{
struct discover_context *ctx;
- struct boot_status *status;
+ struct status *status;
int rc;
- status = talloc_zero(handler, struct boot_status);
- status->type = BOOT_STATUS_INFO;
+ status = talloc_zero(handler, struct status);
+ status->type = STATUS_INFO;
/*
* TRANSLATORS: this string will be passed the type and identifier
* of the device. For example, the first parameter could be "Disk",
status->message = talloc_asprintf(status, _("Processing %s device %s"),
device_type_display_name(dev->device->type),
dev->device->id);
- device_handler_boot_status(handler, status);
+ device_handler_status(handler, status);
process_boot_option_queue(handler);
*/
status->message = talloc_asprintf(status,_("Processing %s complete"),
dev->device->id);
- device_handler_boot_status(handler, status);
+ device_handler_status(handler, status);
talloc_free(status);
- talloc_free(ctx);
+ talloc_unlink(handler, ctx);
return 0;
}
struct discover_device *dev, struct event *event)
{
struct discover_context *ctx;
- struct boot_status *status;
+ struct status *status;
- status = talloc_zero(handler, struct boot_status);
- status->type = BOOT_STATUS_INFO;
+ status = talloc_zero(handler, struct status);
+ status->type = STATUS_INFO;
/*
* TRANSLATORS: this format specifier will be the name of a network
* device, like 'eth0'.
*/
status->message = talloc_asprintf(status, _("Processing dhcp event on %s"),
dev->device->id);
- device_handler_boot_status(handler, status);
+ device_handler_status(handler, status);
/* create our context */
ctx = device_handler_discover_context_create(handler, dev);
+ talloc_steal(ctx, event);
ctx->event = event;
iterate_parsers(ctx);
*/
status->message = talloc_asprintf(status,_("Processing %s complete"),
dev->device->id);
- device_handler_boot_status(handler, status);
+ device_handler_status(handler, status);
talloc_free(status);
- talloc_free(ctx);
-
- return 0;
-}
-
-/* incoming conf event */
-int device_handler_conf(struct device_handler *handler,
- struct discover_device *dev, struct pb_url *url)
-{
- struct discover_context *ctx;
- struct boot_status *status;
-
- status = talloc_zero(handler, struct boot_status);
- status->type = BOOT_STATUS_INFO;
- status->message = talloc_asprintf(status, _("Processing user config"));
- device_handler_boot_status(handler, status);
-
- /* create our context */
- ctx = device_handler_discover_context_create(handler, dev);
- ctx->conf_url = url;
-
- iterate_parsers(ctx);
-
- device_handler_discover_context_commit(handler, ctx);
-
- status->message = talloc_asprintf(status,
- _("Processing user config complete"));
- device_handler_boot_status(handler, status);
-
- talloc_free(status);
- talloc_free(ctx);
+ talloc_unlink(handler, ctx);
return 0;
}
platform_pre_boot();
handler->pending_boot = boot(handler, opt, cmd, handler->dry_run,
- device_handler_boot_status, handler);
+ device_handler_boot_status_cb, handler);
handler->pending_boot_is_default = false;
}
void device_handler_cancel_default(struct device_handler *handler)
{
- struct boot_status status;
+ struct status status;
if (handler->timeout_waiter)
waiter_remove(handler->timeout_waiter);
handler->default_boot_option = NULL;
- status.type = BOOT_STATUS_INFO;
- status.progress = -1;
- status.detail = NULL;
+ status.type = STATUS_INFO;
status.message = _("Default boot cancelled");
- discover_server_notify_boot_status(handler->server, &status);
+ device_handler_status(handler, &status);
}
void device_handler_update_config(struct device_handler *handler,
{
struct discover_context *ctx;
struct discover_device *dev;
- struct boot_status *status;
+ struct status *status;
struct pb_url *pb_url;
struct event *event;
struct param *param;
- status = talloc(handler, struct boot_status);
-
- status->type = BOOT_STATUS_ERROR;
- status->progress = 0;
- status->detail = talloc_asprintf(status,
- _("Received config URL %s"), url);
+ status = talloc(handler, struct status);
+ status->type = STATUS_ERROR;
if (!handler->network) {
status->message = talloc_asprintf(handler,
event = talloc(handler, struct event);
event->type = EVENT_TYPE_USER;
- event->action = EVENT_ACTION_CONF;
+ event->action = EVENT_ACTION_URL;
if (url[strlen(url) - 1] == '/') {
event->params = talloc_array(event, struct param, 3);
goto msg;
}
- dev = discover_device_create(handler, event->device);
+ dev = discover_device_create(handler, mac, event->device);
if (pb_url->scheme == pb_url_file)
dev->device->type = DEVICE_TYPE_ANY;
ctx = device_handler_discover_context_create(handler, dev);
+ talloc_steal(ctx, event);
ctx->event = event;
iterate_parsers(ctx);
device_handler_discover_context_commit(handler, ctx);
- talloc_free(ctx);
+ talloc_unlink(handler, ctx);
- status->type = BOOT_STATUS_INFO;
+ status->type = STATUS_INFO;
status->message = talloc_asprintf(status, _("Config file %s parsed"),
pb_url->file);
msg:
- device_handler_boot_status(handler, status);
+ device_handler_status(handler, status);
talloc_free(status);
}
#ifndef PETITBOOT_TEST
+/**
+ * context_commit - Commit a temporary discovery context to the handler,
+ * and notify the clients about any new options / devices
+ */
+void device_handler_discover_context_commit(struct device_handler *handler,
+ struct discover_context *ctx)
+{
+ struct discover_device *dev = ctx->device;
+ struct discover_boot_option *opt, *tmp;
+
+ if (!device_lookup_by_uuid(handler, dev->uuid))
+ device_handler_add_device(handler, 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);
+
+ /* All boot options need at least a kernel image */
+ if (!opt->boot_image || !opt->boot_image->url) {
+ pb_log("boot option %s is missing boot image, ignoring\n",
+ opt->option->id);
+ talloc_free(opt);
+ continue;
+ }
+
+ 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);
+ notify_boot_option(handler, opt);
+ } 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 void device_handler_update_lang(const char *lang)
{
const char *cur_lang;
dev->mounted = true;
}
+void device_sync_snapshots(struct device_handler *handler, const char *device)
+{
+ struct discover_device *dev = NULL;
+ unsigned int i;
+
+ if (device) {
+ /* Find matching device and sync */
+ dev = device_lookup_by_name(handler, device);
+ if (!dev) {
+ pb_log("%s: device name '%s' unrecognised\n",
+ __func__, device);
+ return;
+ }
+ if (dev->ramdisk)
+ device_release_write(dev, true);
+ else
+ pb_log("%s has no snapshot to merge, skipping\n",
+ dev->device->id);
+ return;
+ }
+
+ /* Otherwise sync all relevant devices */
+ for (i = 0; i < handler->n_devices; i++) {
+ dev = handler->devices[i];
+ if (dev->device->type != DEVICE_TYPE_DISK &&
+ dev->device->type != DEVICE_TYPE_USB)
+ continue;
+ if (dev->ramdisk)
+ device_release_write(dev, true);
+ else
+ pb_log("%s has no snapshot to merge, skipping\n",
+ dev->device->id);
+ }
+}
+
#else
+void device_handler_discover_context_commit(
+ struct device_handler *handler __attribute__((unused)),
+ struct discover_context *ctx __attribute__((unused)))
+{
+ pb_log("%s stubbed out for test cases\n", __func__);
+}
+
static void device_handler_update_lang(const char *lang __attribute__((unused)))
{
}
{
}
-#endif
+void device_sync_snapshots(
+ struct device_handler *handler __attribute__((unused)),
+ const char *device __attribute__((unused)))
+{
+}
+#endif
projects / petitboot / blobdiff