}
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_boot_status(void *arg, struct status *status)
{
struct device_handler *handler = arg;
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.type = STATUS_INFO;
status.progress = -1;
status.detail = NULL;
status.message = talloc_asprintf(handler,
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;
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",
device_handler_boot_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'.
/* create our context */
ctx = device_handler_discover_context_create(handler, dev);
+ talloc_steal(ctx, event);
ctx->event = event;
iterate_parsers(ctx);
device_handler_boot_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;
}
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.type = STATUS_INFO;
status.progress = -1;
status.detail = NULL;
status.message = _("Default boot cancelled");
{
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 = talloc(handler, struct status);
- status->type = BOOT_STATUS_ERROR;
+ status->type = STATUS_ERROR;
status->progress = 0;
status->detail = talloc_asprintf(status,
_("Received config URL %s"), url);
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:
struct discover_device *dev = ctx->device;
struct discover_boot_option *opt, *tmp;
- if (!device_lookup_by_id(handler, dev->device->id))
+ 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",
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(
{
}
+void device_sync_snapshots(
+ struct device_handler *handler __attribute__((unused)),
+ const char *device __attribute__((unused)))
+{
+}
+
#endif
projects / petitboot / blobdiff