X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fboot.c;h=f52a91c1c8c18ee405bc0659c4d8847c1280ee99;hp=d054d5d51c24733203fbc0706e0b06c527c8a06a;hb=1247b4bbbbf102c0cc54f6b3a927e249a9368ba4;hpb=375c81a1b9aa8904dfdd0b1195fe99a1e4a2fa9d diff --git a/discover/boot.c b/discover/boot.c index d054d5d..f52a91c 100644 --- a/discover/boot.c +++ b/discover/boot.c @@ -1,8 +1,17 @@ +#define _GNU_SOURCE + +#include +#include #include +#include +#include +#include +#include #include #include +#include #include #include #include @@ -12,49 +21,67 @@ #include "paths.h" #include "resource.h" +static const char *boot_hook_dir = PKG_SYSCONF_DIR "/boot.d"; +enum { + BOOT_HOOK_EXIT_OK = 0, + BOOT_HOOK_EXIT_UPDATE = 2, +}; + + +struct boot_task { + char *local_image; + char *local_initrd; + char *local_dtb; + char *args; + + bool dry_run; +}; + /** * kexec_load - kexec load helper. - * @l_image: The local image file for kexec to execute. - * @l_initrd: Optional local initrd file for kexec --initrd, can be NULL. - * @args: Optional command line args for kexec --append, can be NULL. */ - -static int kexec_load(const char *l_image, const char *l_initrd, - const char *args, int dry_run) +static int kexec_load(struct boot_task *boot_task) { int result; - const char *argv[6]; + const char *argv[7]; const char **p; char *s_initrd = NULL; + char *s_dtb = NULL; char *s_args = NULL; p = argv; *p++ = pb_system_apps.kexec; /* 1 */ *p++ = "-l"; /* 2 */ - if (l_initrd) { - s_initrd = talloc_asprintf(NULL, "--initrd=%s", l_initrd); + if (boot_task->local_initrd) { + s_initrd = talloc_asprintf(boot_task, "--initrd=%s", + boot_task->local_initrd); assert(s_initrd); *p++ = s_initrd; /* 3 */ } - if (args) { - s_args = talloc_asprintf(NULL, "--append=%s", args); + if (boot_task->local_dtb) { + s_dtb = talloc_asprintf(boot_task, "--dtb=%s", + boot_task->local_dtb); + assert(s_dtb); + *p++ = s_dtb; /* 4 */ + } + + if (boot_task->args) { + s_args = talloc_asprintf(boot_task, "--append=%s", + boot_task->args); assert(s_args); - *p++ = s_args; /* 4 */ + *p++ = s_args; /* 5 */ } - *p++ = l_image; /* 5 */ - *p++ = NULL; /* 6 */ + *p++ = boot_task->local_image; /* 6 */ + *p++ = NULL; /* 7 */ - result = pb_run_cmd(argv, 1, dry_run); + result = process_run_simple_argv(boot_task, argv); if (result) pb_log("%s: failed: (%d)\n", __func__, result); - talloc_free(s_initrd); - talloc_free(s_args); - return result; } @@ -64,94 +91,258 @@ static int kexec_load(const char *l_image, const char *l_initrd, * Must only be called after a successful call to kexec_load(). */ -static int kexec_reboot(int dry_run) +static int kexec_reboot(struct boot_task *task) { - int result = 0; - const char *argv[4]; - const char **p; + int result; /* First try running shutdown. Init scripts should run 'exec -e' */ - - p = argv; - *p++ = pb_system_apps.shutdown; /* 1 */ - *p++ = "-r"; /* 2 */ - *p++ = "now"; /* 3 */ - *p++ = NULL; /* 4 */ - - result = pb_run_cmd(argv, 1, dry_run); + result = process_run_simple(task, pb_system_apps.shutdown, "-r", + "now", NULL); /* On error, force a kexec with the -e option */ - if (result) { - p = argv; - *p++ = pb_system_apps.kexec; /* 1 */ - *p++ = "-e"; /* 2 */ - *p++ = NULL; /* 3 */ + result = process_run_simple(task, pb_system_apps.kexec, + "-e", NULL); + } - result = pb_run_cmd(argv, 1, 0); + if (result) + pb_log("%s: failed: (%d)\n", __func__, result); + + /* okay, kexec -e -f */ + if (result) { + result = process_run_simple(task, pb_system_apps.kexec, + "-e", "-f", NULL); } if (result) pb_log("%s: failed: (%d)\n", __func__, result); + return result; } -static void update_status(boot_status_fn fn, void *arg, int type, - char *message) +static void __attribute__((format(__printf__, 4, 5))) update_status( + boot_status_fn fn, void *arg, int type, char *fmt, ...) { struct boot_status status; + va_list ap; + + va_start(ap, fmt); + status.message = talloc_vasprintf(NULL, fmt, ap); + va_end(ap); status.type = type; - status.message = message; status.progress = -1; status.detail = NULL; fn(arg, &status); + + talloc_free(status.message); +} + +static void boot_hook_update_param(void *ctx, struct boot_task *task, + const char *name, const char *value) +{ + struct p { + const char *name; + char **p; + } *param, params[] = { + { "boot_image", &task->local_image }, + { "boot_initrd", &task->local_initrd }, + { "boot_dtb", &task->local_dtb }, + { "boot_args", &task->args }, + { NULL, NULL }, + }; + + for (param = params; param->name; param++) { + if (strcmp(param->name, name)) + continue; + + *param->p = talloc_strdup(ctx, value); + return; + } +} + +static void boot_hook_update(struct boot_task *task, const char *hookname, + char *buf) +{ + char *line, *name, *val, *sep; + char *saveptr; + + for (;; buf = NULL) { + + line = strtok_r(buf, "\n", &saveptr); + if (!line) + break; + + sep = strchr(line, '='); + if (!sep) + continue; + + *sep = '\0'; + name = line; + val = sep + 1; + + boot_hook_update_param(task, task, name, val); + + pb_log("boot hook %s specified %s=%s\n", + hookname, name, val); + } +} + +static void boot_hook_setenv(struct boot_task *task) +{ + unsetenv("boot_image"); + unsetenv("boot_initrd"); + 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); + if (task->args) + setenv("boot_args", task->args, 1); +} + +static int hook_filter(const struct dirent *dirent) +{ + return dirent->d_type == DT_REG || dirent->d_type == DT_LNK; +} + +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) +{ + struct dirent **hooks; + int i, n; + + n = scandir(boot_hook_dir, &hooks, hook_filter, hook_cmp); + if (n < 1) + return; + + update_status(status_fn, status_arg, BOOT_STATUS_INFO, + "running boot hooks"); + + boot_hook_setenv(task); + + for (i = 0; i < n; i++) { + const char *argv[2] = { NULL, NULL }; + struct process *process; + char *path; + int rc; + + path = join_paths(task, boot_hook_dir, hooks[i]->d_name); + + if (access(path, X_OK)) { + talloc_free(path); + continue; + } + + process = process_create(task); + + argv[0] = path; + process->path = path; + process->argv = argv; + process->keep_stdout = true; + + pb_log("running boot hook %s\n", hooks[i]->d_name); + + rc = process_run_sync(process); + if (rc) { + pb_log("boot hook exec failed!\n"); + + } else if (WIFEXITED(process->exit_status) && + WEXITSTATUS(process->exit_status) + == BOOT_HOOK_EXIT_UPDATE) { + /* 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); + } + } + + process_release(process); + talloc_free(path); + } + + 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) { - char *local_image, *local_initrd; + struct boot_task *boot_task; + struct pb_url *image, *initrd, *dtb; unsigned int clean_image = 0; unsigned int clean_initrd = 0; - struct pb_url *image, *initrd; - char *args; + unsigned int clean_dtb = 0; + const char *boot_desc; int result; - local_initrd = NULL; image = NULL; initrd = NULL; - args = NULL; + dtb = NULL; + + 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); - if (cmd->boot_image_file) { + if (cmd && cmd->boot_image_file) { image = pb_url_parse(opt, cmd->boot_image_file); } else if (opt && opt->boot_image) { image = opt->boot_image->url; } else { - pb_log("%s: no image specified", __func__); + pb_log("%s: no image specified\n", __func__); + update_status(status_fn, status_arg, BOOT_STATUS_INFO, + "Boot failed: no image specified"); return -1; } - if (cmd->initrd_file) { + 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) { initrd = opt->initrd->url; } - if (cmd->boot_args) { - args = talloc_strdup(ctx, cmd->boot_args); + if (cmd && cmd->dtb_file) { + dtb = pb_url_parse(opt, cmd->dtb_file); + } else if (opt && opt->dtb) { + dtb = opt->dtb->url; + } + + if (cmd && cmd->boot_args) { + boot_task->args = talloc_strdup(boot_task, cmd->boot_args); } else if (opt && opt->option->boot_args) { - args = talloc_strdup(ctx, opt->option->boot_args); + boot_task->args = talloc_strdup(boot_task, + opt->option->boot_args); + } else { + boot_task->args = NULL; } result = -1; update_status(status_fn, status_arg, BOOT_STATUS_INFO, "loading kernel"); - local_image = load_url(NULL, image, &clean_image); - if (!local_image) { + 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; @@ -160,18 +351,31 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, if (initrd) { update_status(status_fn, status_arg, BOOT_STATUS_INFO, "loading initrd"); - local_initrd = load_url(NULL, initrd, &clean_initrd); - if (!local_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); + update_status(status_fn, status_arg, BOOT_STATUS_INFO, "performing kexec_load"); - result = kexec_load(local_image, local_initrd, args, dry_run); + result = kexec_load(boot_task); if (result) { update_status(status_fn, status_arg, BOOT_STATUS_ERROR, @@ -180,18 +384,17 @@ int boot(void *ctx, struct discover_boot_option *opt, struct boot_command *cmd, no_load: if (clean_image) - unlink(local_image); + unlink(boot_task->local_image); if (clean_initrd) - unlink(local_initrd); - - talloc_free(local_image); - talloc_free(local_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(dry_run); + result = kexec_reboot(boot_task); if (result) { update_status(status_fn, status_arg, BOOT_STATUS_ERROR, @@ -199,5 +402,7 @@ no_load: } } + talloc_free(boot_task); + return result; }