X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fboot.c;h=13dfe0c9781fc5be889e48e34340cbb4e952aecd;hp=a1e20e64914aac26a7dce5af50fa1c8deed99179;hb=dd8fe077022138d1f6aca7e6d6cceec61f56ce95;hpb=4844eaae93e9e32708f02f7e5a43edcc87435699 diff --git a/discover/boot.c b/discover/boot.c index a1e20e6..13dfe0c 100644 --- a/discover/boot.c +++ b/discover/boot.c @@ -15,6 +15,7 @@ #include #include #include +#include #include "device-handler.h" #include "boot.h" @@ -27,25 +28,15 @@ enum { BOOT_HOOK_EXIT_UPDATE = 2, }; -enum boot_process_state { - BOOT_STATE_INITIAL, - BOOT_STATE_IMAGE_LOADING, - BOOT_STATE_INITRD_LOADING, - BOOT_STATE_FINISH, - BOOT_STATE_UNKNOWN, -}; - - struct boot_task { - char *local_image; - char *local_initrd; - char *local_dtb; - char *args; - struct pb_url *image, *initrd, *dtb; + struct load_url_result *image; + struct load_url_result *initrd; + struct load_url_result *dtb; + const char *args; boot_status_fn status_fn; void *status_arg; - enum boot_process_state state; bool dry_run; + bool cancelled; }; /** @@ -64,16 +55,16 @@ static int kexec_load(struct boot_task *boot_task) *p++ = pb_system_apps.kexec; /* 1 */ *p++ = "-l"; /* 2 */ - if (boot_task->local_initrd) { + if (boot_task->initrd) { s_initrd = talloc_asprintf(boot_task, "--initrd=%s", - boot_task->local_initrd); + boot_task->initrd->local); assert(s_initrd); *p++ = s_initrd; /* 3 */ } - if (boot_task->local_dtb) { + if (boot_task->dtb) { s_dtb = talloc_asprintf(boot_task, "--dtb=%s", - boot_task->local_dtb); + boot_task->dtb->local); assert(s_dtb); *p++ = s_dtb; /* 4 */ } @@ -85,7 +76,7 @@ static int kexec_load(struct boot_task *boot_task) *p++ = s_args; /* 5 */ } - *p++ = boot_task->local_image; /* 6 */ + *p++ = boot_task->image->local; /* 6 */ *p++ = NULL; /* 7 */ result = process_run_simple_argv(boot_task, argv); @@ -146,6 +137,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); @@ -156,11 +149,11 @@ 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 }, - { "boot_dtb", &task->local_dtb }, + { "boot_image", &task->image->local }, + { "boot_initrd", &task->initrd->local }, + { "boot_dtb", &task->dtb->local }, { "boot_args", &task->args }, { NULL, NULL }, }; @@ -208,11 +201,11 @@ static void boot_hook_setenv(struct boot_task *task) unsetenv("boot_dtb"); unsetenv("boot_args"); - setenv("boot_image", task->local_image, 1); - if (task->local_initrd) - setenv("boot_initrd", task->local_initrd, 1); - if (task->local_dtb) - setenv("boot_dtb", task->local_dtb, 1); + setenv("boot_image", task->image->local, 1); + if (task->initrd) + setenv("boot_initrd", task->initrd->local, 1); + if (task->dtb) + setenv("boot_dtb", task->dtb->local, 1); if (task->args) setenv("boot_args", task->args, 1); } @@ -287,126 +280,144 @@ static void run_boot_hooks(struct boot_task *task) free(hooks); } -static void boot_process(void *ctx, int *status) +static bool load_pending(struct load_url_result *result) { - struct boot_task *task = ctx; - unsigned int clean_image = 0; - unsigned int clean_initrd = 0; - unsigned int clean_dtb = 0; - int result = -1; + return result && result->status == LOAD_ASYNC; +} - if (task->state == BOOT_STATE_INITIAL) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_INFO, "loading kernel"); - task->local_image = load_url_async(task, task->image, - &clean_image, boot_process); - if (!task->local_image) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "Couldn't load kernel image"); - goto no_load; - } else { - task->state = BOOT_STATE_IMAGE_LOADING; - *status = 0; - return; - } - } +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; +} - if (task->state == BOOT_STATE_IMAGE_LOADING) { - if (task->initrd) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_INFO, "loading initrd"); - task->local_initrd = load_url_async(task, task->initrd, - &clean_initrd, boot_process); - if (!task->local_initrd) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "Couldn't load initrd image"); - goto no_load; - } else { - task->state = BOOT_STATE_INITRD_LOADING; - *status = 0; - return; - } - } else { - task->state = BOOT_STATE_INITRD_LOADING; - } - } +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); +} - if (task->state == BOOT_STATE_INITRD_LOADING) { - if (task->dtb) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_INFO, - "loading device tree"); - task->local_dtb = load_url_async(task, task->dtb, - &clean_dtb, boot_process); - if (!task->local_dtb) { - update_status(task->status_fn, task->status_arg, - BOOT_STATUS_ERROR, - "Couldn't load device tree"); - goto no_load; - } else { - task->state = BOOT_STATE_FINISH; - *status = 0; - return; - } - } else { - task->state = BOOT_STATE_FINISH; +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 (task->state != BOOT_STATE_FINISH) { - task->state = BOOT_STATE_UNKNOWN; - *status = -1; + 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"); - result = kexec_load(task); - - if (result) { + rc = kexec_load(task); + if (rc) { update_status(task->status_fn, task->status_arg, BOOT_STATUS_ERROR, "kexec load failed"); } no_load: - if (clean_image) - unlink(task->local_image); - if (clean_initrd) - unlink(task->local_initrd); - if (clean_dtb) - unlink(task->local_dtb); - - if (!result) { + 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"); - result = kexec_reboot(task); - - if (result) { + rc = kexec_reboot(task); + if (rc) { update_status(task->status_fn, task->status_arg, BOOT_STATUS_ERROR, "kexec reboot failed"); } } +} - talloc_free(task); +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; - *status = result; + *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; } -int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, - int dry_run, boot_status_fn status_fn, void *status_arg) +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 = NULL; const char *boot_desc; - int result; + int rc; if (opt && opt->option->name) boot_desc = opt->option->name; @@ -426,28 +437,26 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, pb_log("%s: no image specified\n", __func__); update_status(status_fn, status_arg, BOOT_STATUS_INFO, "Boot failed: no image specified"); - return -1; + return NULL; } - boot_task = talloc_zero(ctx, struct boot_task); - boot_task->image = image; - boot_task->dry_run = dry_run; - boot_task->status_fn = status_fn; - boot_task->status_arg = status_arg; - boot_task->state = BOOT_STATE_INITIAL; - if (cmd && cmd->initrd_file) { - boot_task->initrd = pb_url_parse(opt, cmd->initrd_file); + initrd = pb_url_parse(opt, cmd->initrd_file); } else if (opt && opt->initrd) { - boot_task->initrd = opt->initrd->url; + initrd = opt->initrd->url; } if (cmd && cmd->dtb_file) { - boot_task->dtb = pb_url_parse(opt, cmd->dtb_file); + dtb = pb_url_parse(opt, cmd->dtb_file); } else if (opt && opt->dtb) { - boot_task->dtb = opt->dtb->url; + 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) { @@ -457,7 +466,28 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, boot_task->args = NULL; } - boot_process(boot_task, &result); + /* 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); - return result; + /* If all URLs are local, we may be done. */ + if (rc) { + talloc_free(boot_task); + return NULL; + } + + boot_process(NULL, boot_task); + + return boot_task; +} + +void boot_cancel(struct boot_task *task) +{ + task->cancelled = true; + + update_status(task->status_fn, task->status_arg, BOOT_STATUS_INFO, + "Boot cancelled"); + + cleanup_cancellations(task, NULL); }