X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fboot.c;h=e5803a76dcf0fbc228f2c426b19c415c28d382ef;hp=6095cd8d865f8e02cc350b7665371b9771472e50;hb=37bff93c8b0a71432613f41f2319dc073ca64619;hpb=748bd3f1bd8ffff60653f7a54f51cc5f63696c68 diff --git a/discover/boot.c b/discover/boot.c index 6095cd8..e5803a7 100644 --- a/discover/boot.c +++ b/discover/boot.c @@ -1,5 +1,7 @@ -#define _GNU_SOURCE +#if defined(HAVE_CONFIG_H) +#include "config.h" +#endif #include #include @@ -15,6 +17,7 @@ #include #include #include +#include #include "device-handler.h" #include "boot.h" @@ -27,14 +30,18 @@ enum { BOOT_HOOK_EXIT_UPDATE = 2, }; - struct boot_task { - char *local_image; - char *local_initrd; - char *local_dtb; - char *args; - + struct load_url_result *image; + struct load_url_result *initrd; + struct load_url_result *dtb; + const char *local_image; + const char *local_initrd; + const char *local_dtb; + const char *args; + boot_status_fn status_fn; + void *status_arg; bool dry_run; + bool cancelled; }; /** @@ -135,6 +142,8 @@ static void __attribute__((format(__printf__, 4, 5))) update_status( status.progress = -1; status.detail = NULL; + pb_debug("boot status: [%d] %s\n", type, status.message); + fn(arg, &status); talloc_free(status.message); @@ -145,7 +154,7 @@ static void boot_hook_update_param(void *ctx, struct boot_task *task, { struct p { const char *name; - char **p; + const char **p; } *param, params[] = { { "boot_image", &task->local_image }, { "boot_initrd", &task->local_initrd }, @@ -216,8 +225,7 @@ static int hook_cmp(const struct dirent **a, const struct dirent **b) return strcmp((*a)->d_name, (*b)->d_name); } -static void run_boot_hooks(struct boot_task *task, boot_status_fn status_fn, - void *status_arg) +static void run_boot_hooks(struct boot_task *task) { struct dirent **hooks; int i, n; @@ -226,7 +234,7 @@ static void run_boot_hooks(struct boot_task *task, boot_status_fn status_fn, if (n < 1) return; - update_status(status_fn, status_arg, BOOT_STATUS_INFO, + update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, "running boot hooks"); boot_hook_setenv(task); @@ -263,11 +271,9 @@ static void run_boot_hooks(struct boot_task *task, boot_status_fn status_fn, /* if the hook returned with BOOT_HOOK_EXIT_UPDATE, * then we process stdout to look for updated params */ - if (rc == BOOT_HOOK_EXIT_UPDATE) { - boot_hook_update(task, hooks[i]->d_name, - process->stdout_buf); - boot_hook_setenv(task); - } + boot_hook_update(task, hooks[i]->d_name, + process->stdout_buf); + boot_hook_setenv(task); } process_release(process); @@ -277,19 +283,160 @@ static void run_boot_hooks(struct boot_task *task, boot_status_fn status_fn, free(hooks); } -int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, - int dry_run, boot_status_fn status_fn, void *status_arg) +static bool load_pending(struct load_url_result *result) +{ + return result && result->status == LOAD_ASYNC; +} + +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; + + /* we make a copy of the local paths, as the boot hooks might update + * and/or create these */ + task->local_image = task->image ? task->image->local : NULL; + task->local_initrd = task->initrd ? task->initrd->local : NULL; + task->local_dtb = task->dtb ? task->dtb->local : NULL; + + 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; - struct pb_url *image, *initrd, *dtb; - unsigned int clean_image = 0; - unsigned int clean_initrd = 0; - unsigned int clean_dtb = 0; - int result; + 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)"; - image = NULL; - initrd = NULL; - dtb = NULL; + update_status(status_fn, status_arg, BOOT_STATUS_INFO, + "Booting %s.", boot_desc); if (cmd && cmd->boot_image_file) { image = pb_url_parse(opt, cmd->boot_image_file); @@ -297,12 +444,11 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, image = opt->boot_image->url; } else { pb_log("%s: no image specified\n", __func__); - return -1; + update_status(status_fn, status_arg, BOOT_STATUS_INFO, + "Boot failed: no image specified"); + return NULL; } - boot_task = talloc_zero(ctx, struct boot_task); - boot_task->dry_run = dry_run; - if (cmd && cmd->initrd_file) { initrd = pb_url_parse(opt, cmd->initrd_file); } else if (opt && opt->initrd) { @@ -315,6 +461,11 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, dtb = opt->dtb->url; } + boot_task = talloc_zero(ctx, struct boot_task); + boot_task->dry_run = dry_run; + boot_task->status_fn = status_fn; + boot_task->status_arg = status_arg; + if (cmd && cmd->boot_args) { boot_task->args = talloc_strdup(boot_task, cmd->boot_args); } else if (opt && opt->option->boot_args) { @@ -324,72 +475,28 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, boot_task->args = NULL; } - result = -1; + /* start async loads for boot resources */ + rc = start_url_load(boot_task, "kernel image", image, &boot_task->image) + || start_url_load(boot_task, "initrd", initrd, &boot_task->initrd) + || start_url_load(boot_task, "dtb", dtb, &boot_task->dtb); - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "loading kernel"); - boot_task->local_image = load_url(NULL, image, &clean_image); - if (!boot_task->local_image) { - update_status(status_fn, status_arg, BOOT_STATUS_ERROR, - "Couldn't load kernel image"); - goto no_load; + /* If all URLs are local, we may be done. */ + if (rc) { + talloc_free(boot_task); + return NULL; } - if (initrd) { - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "loading initrd"); - boot_task->local_initrd = load_url(NULL, initrd, &clean_initrd); - if (!boot_task->local_initrd) { - update_status(status_fn, status_arg, BOOT_STATUS_ERROR, - "Couldn't load initrd image"); - goto no_load; - } - } - - if (dtb) { - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "loading device tree"); - boot_task->local_dtb = load_url(NULL, dtb, &clean_dtb); - if (!boot_task->local_dtb) { - update_status(status_fn, status_arg, BOOT_STATUS_ERROR, - "Couldn't load device tree"); - goto no_load; - } - } - - run_boot_hooks(boot_task, status_fn, status_arg); + boot_process(NULL, boot_task); - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "performing kexec_load"); - - result = kexec_load(boot_task); - - if (result) { - update_status(status_fn, status_arg, BOOT_STATUS_ERROR, - "kexec load failed"); - } - -no_load: - if (clean_image) - unlink(boot_task->local_image); - if (clean_initrd) - unlink(boot_task->local_initrd); - if (clean_dtb) - unlink(boot_task->local_dtb); - - if (!result) { - update_status(status_fn, status_arg, BOOT_STATUS_INFO, - "performing kexec reboot"); - - result = kexec_reboot(boot_task); + return boot_task; +} - if (result) { - update_status(status_fn, status_arg, BOOT_STATUS_ERROR, - "kexec reboot failed"); - } - } +void boot_cancel(struct boot_task *task) +{ + task->cancelled = true; - talloc_free(boot_task); + update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, + "Boot cancelled"); - return result; + cleanup_cancellations(task, NULL); }