+static int check_load(struct boot_task *task, const char *name,
+ struct load_url_result *result)
+{
+ if (!result)
+ return 0;
+ if (result->status != LOAD_ERROR)
+ return 0;
+
+ update_status(task->status_fn, task->status_arg,
+ BOOT_STATUS_ERROR,
+ "Couldn't load %s", name);
+ return -1;
+}
+
+static void cleanup_load(struct load_url_result *result)
+{
+ if (!result)
+ return;
+ if (result->status != LOAD_OK)
+ return;
+ if (!result->cleanup_local)
+ return;
+ unlink(result->local);
+}
+
+static void cleanup_cancellations(struct boot_task *task,
+ struct load_url_result *cur_result)
+{
+ struct load_url_result *result, **results[] = {
+ &task->image, &task->initrd, &task->dtb,
+ };
+ bool pending = false;
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(results); i++) {
+ result = *results[i];
+
+ if (!result)
+ continue;
+
+ /* We need to cleanup and free any completed loads */
+ if (result == cur_result || result->status == LOAD_OK
+ || result->status == LOAD_ERROR) {
+ cleanup_load(result);
+ talloc_free(result);
+ *results[i] = NULL;
+
+ /* ... and cancel any pending loads, which we'll free in
+ * the completion callback */
+ } else if (result->status == LOAD_ASYNC) {
+ load_url_async_cancel(result);
+ pending = true;
+ }
+ }
+
+ if (!pending)
+ talloc_free(task);
+}
+
+static void boot_process(struct load_url_result *result, void *data)
+{
+ struct boot_task *task = data;
+ int rc = -1;
+
+ if (task->cancelled) {
+ cleanup_cancellations(task, result);
+ return;
+ }
+
+ if (load_pending(task->image) ||
+ load_pending(task->initrd) ||
+ load_pending(task->dtb))
+ return;
+
+ if (check_load(task, "kernel image", task->image) ||
+ check_load(task, "initrd", task->initrd) ||
+ check_load(task, "dtb", task->dtb))
+ goto no_load;
+
+ run_boot_hooks(task);
+
+ update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO,
+ "performing kexec_load");
+
+ rc = kexec_load(task);
+ if (rc) {
+ update_status(task->status_fn, task->status_arg,
+ BOOT_STATUS_ERROR, "kexec load failed");
+ }
+
+no_load:
+ cleanup_load(task->image);
+ cleanup_load(task->initrd);
+ cleanup_load(task->dtb);
+
+ if (!rc) {
+ update_status(task->status_fn, task->status_arg,
+ BOOT_STATUS_INFO,
+ "performing kexec reboot");
+
+ rc = kexec_reboot(task);
+ if (rc) {
+ update_status(task->status_fn, task->status_arg,
+ BOOT_STATUS_ERROR,
+ "kexec reboot failed");
+ }
+ }
+}
+
+static int start_url_load(struct boot_task *task, const char *name,
+ struct pb_url *url, struct load_url_result **result)
+{
+ if (!url)
+ return 0;
+
+ *result = load_url_async(task, url, boot_process, task);
+ if (!*result) {
+ update_status(task->status_fn, task->status_arg,
+ BOOT_STATUS_ERROR,
+ "Error loading %s", name);
+ return -1;
+ }
+ return 0;
+}
+
+struct boot_task *boot(void *ctx, struct discover_boot_option *opt,
+ struct boot_command *cmd, int dry_run,
+ boot_status_fn status_fn, void *status_arg)
+{
+ struct pb_url *image = NULL, *initrd = NULL, *dtb = NULL;
+ struct boot_task *boot_task;
+ const char *boot_desc;
+ int rc;
+
+ if (opt && opt->option->name)
+ boot_desc = opt->option->name;
+ else if (cmd && cmd->boot_image_file)
+ boot_desc = cmd->boot_image_file;
+ else
+ boot_desc = "(unknown)";
+
+ update_status(status_fn, status_arg, BOOT_STATUS_INFO,
+ "Booting %s.", boot_desc);