X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=5d9f98892eb792db789de351fb750bb95cd0e3f9;hp=22866e6600e29cb869c6196055447fa74b1619f8;hb=900412ec49f30fbb7872a5ff38538a19c17e20a2;hpb=a81a91f363acefed2f19309383877c02ff6389ef diff --git a/discover/device-handler.c b/discover/device-handler.c index 22866e6..5d9f988 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -16,6 +17,12 @@ #include #include #include +#include + +#include +#include +#include +#include #include "device-handler.h" #include "discover-server.h" @@ -29,6 +36,15 @@ #include "boot.h" #include "udev.h" #include "network.h" +#include "ipmi.h" + +enum default_priority { + DEFAULT_PRIORITY_REMOTE = 1, + DEFAULT_PRIORITY_LOCAL_UUID = 2, + DEFAULT_PRIORITY_LOCAL_FIRST = 3, + DEFAULT_PRIORITY_LOCAL_LAST = 0xfe, + DEFAULT_PRIORITY_DISABLED = 0xff, +}; struct device_handler { struct discover_server *server; @@ -47,6 +63,8 @@ struct device_handler { unsigned int sec_to_boot; struct discover_boot_option *default_boot_option; + int default_boot_option_priority; + struct list unresolved_boot_options; struct boot_task *pending_boot; @@ -59,6 +77,8 @@ static int umount_device(struct discover_device *dev); static int device_handler_init_sources(struct device_handler *handler); static void device_handler_reinit_sources(struct device_handler *handler); +static void device_handler_update_lang(const char *lang); + void discover_context_add_boot_option(struct discover_context *ctx, struct discover_boot_option *boot_option) { @@ -381,7 +401,7 @@ static void countdown_status(struct device_handler *handler, status.progress = -1; status.detail = NULL; status.message = talloc_asprintf(handler, - "Booting in %d sec: %s", sec, opt->option->name); + _("Booting in %d sec: %s"), sec, opt->option->name); discover_server_notify_boot_status(handler->server, &status); @@ -420,75 +440,118 @@ static int default_timeout(void *arg) return 0; } -static bool priority_match(struct boot_priority *prio, +struct { + enum ipmi_bootdev ipmi_type; + enum device_type device_type; +} device_type_map[] = { + { IPMI_BOOTDEV_NETWORK, DEVICE_TYPE_NETWORK }, + { IPMI_BOOTDEV_DISK, DEVICE_TYPE_DISK }, + { IPMI_BOOTDEV_CDROM, DEVICE_TYPE_OPTICAL }, +}; + +static bool ipmi_device_type_matches(enum ipmi_bootdev ipmi_type, + enum device_type device_type) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(device_type_map); i++) { + if (device_type_map[i].device_type == device_type) + return device_type_map[i].ipmi_type == ipmi_type; + } + + return false; +} + +static bool priority_matches(struct boot_priority *prio, struct discover_boot_option *opt) { return prio->type == opt->device->device->type || prio->type == DEVICE_TYPE_ANY; } -static int default_option_priority(struct discover_boot_option *opt) +/* + * We have different priorities to resolve conflicts between boot options that + * report to be the default for their device. This function assigns a priority + * for these options. + */ +static enum default_priority default_option_priority( + struct discover_boot_option *opt) { const struct config *config; - struct boot_priority *prio; + const char *dev_str; unsigned int i; config = config_get(); - for (i = 0; i < config->n_boot_priorities; i++) { - prio = &config->boot_priorities[i]; - if (priority_match(prio, opt)) - return prio->priority; + /* We give highest priority to IPMI-configured boot options. If + * we have an IPMI bootdev configuration set, then we don't allow + * any other defaults */ + if (config->ipmi_bootdev) { + bool ipmi_match = ipmi_device_type_matches(config->ipmi_bootdev, + opt->device->device->type); + if (ipmi_match) + return DEFAULT_PRIORITY_REMOTE; + + pb_debug("handler: disabled default priority due to " + "non-matching IPMI type %x\n", + config->ipmi_bootdev); + return DEFAULT_PRIORITY_DISABLED; } - return 0; -} - -static bool device_allows_default(struct discover_device *dev) -{ - const char *dev_str; - - dev_str = config_get()->boot_device; + /* Next, allow matching by device UUID. If we have one set but it + * doesn't match, disallow the default entirely */ + dev_str = config->boot_device; + if (dev_str && dev_str[0]) { + if (!strcmp(opt->device->uuid, dev_str)) + return DEFAULT_PRIORITY_LOCAL_UUID; - if (!dev_str || !strlen(dev_str)) - return true; + pb_debug("handler: disabled default priority due to " + "non-matching UUID\n"); + return DEFAULT_PRIORITY_DISABLED; + } - /* default devices are specified by UUIDs at present */ - if (strcmp(dev->uuid, dev_str)) - return false; + /* Lastly, use the local priorities */ + for (i = 0; i < config->n_boot_priorities; i++) { + struct boot_priority *prio = &config->boot_priorities[i]; + if (priority_matches(prio, opt)) + return DEFAULT_PRIORITY_LOCAL_FIRST + prio->priority; + } - return true; + return DEFAULT_PRIORITY_DISABLED; } static void set_default(struct device_handler *handler, struct discover_boot_option *opt) { - int new_prio; + enum default_priority cur_prio, new_prio; if (!handler->autoboot_enabled) return; - /* do we allow default-booting from this device? */ - if (!device_allows_default(opt->device)) - return; + pb_debug("handler: new default option: %s\n", opt->option->id); new_prio = default_option_priority(opt); - /* A negative priority indicates that we don't want to boot this device - * by default */ - if (new_prio < 0) + /* Anything outside our range prevents a default boot */ + if (new_prio >= DEFAULT_PRIORITY_DISABLED) return; + pb_debug("handler: calculated priority %d\n", new_prio); + /* Resolve any conflicts: if we have a new default option, it only * replaces the current if it has a higher priority. */ if (handler->default_boot_option) { - int cur_prio; - cur_prio = default_option_priority( - handler->default_boot_option); + cur_prio = handler->default_boot_option_priority; - if (new_prio > cur_prio) { + if (new_prio < cur_prio) { + pb_log("handler: new prio %d beats " + "old prio %d for %s\n", + new_prio, cur_prio, + handler->default_boot_option + ->option->id); handler->default_boot_option = opt; + handler->default_boot_option_priority = new_prio; /* extend the timeout a little, so the user sees some * indication of the change */ handler->sec_to_boot += 2; @@ -499,8 +562,9 @@ static void set_default(struct device_handler *handler, handler->sec_to_boot = config_get()->autoboot_timeout_sec; handler->default_boot_option = opt; + handler->default_boot_option_priority = new_prio; - pb_log("Boot option %s set as default, timeout %u sec.\n", + pb_log("handler: boot option %s set as default, timeout %u sec.\n", opt->option->id, handler->sec_to_boot); default_timeout(handler); @@ -617,6 +681,7 @@ struct discover_context *device_handler_discover_context_create( ctx = talloc_zero(handler, struct discover_context); ctx->device = device; + ctx->network = handler->network; list_init(&ctx->boot_options); return ctx; @@ -777,6 +842,9 @@ void device_handler_boot(struct device_handler *handler, if (handler->pending_boot) boot_cancel(handler->pending_boot); + + platform_pre_boot(); + handler->pending_boot = boot(handler, opt, cmd, handler->dry_run, boot_status, handler); handler->pending_boot_is_default = false; @@ -809,7 +877,7 @@ void device_handler_cancel_default(struct device_handler *handler) status.type = BOOT_STATUS_INFO; status.progress = -1; status.detail = NULL; - status.message = "Default boot cancelled"; + status.message = _("Default boot cancelled"); discover_server_notify_boot_status(handler->server, &status); } @@ -824,11 +892,161 @@ void device_handler_update_config(struct device_handler *handler, return; discover_server_notify_config(handler->server, config); + device_handler_update_lang(config->lang); device_handler_reinit(handler); } +static char *device_from_addr(void *ctx, struct pb_url *url) +{ + char *ipaddr, *buf, *tok, *dev = NULL; + const char *delim = " "; + struct sockaddr_in *ip; + struct sockaddr_in si; + struct addrinfo *res; + struct process *p; + int rc; + + /* Note: IPv4 only */ + rc = inet_pton(AF_INET, url->host, &(si.sin_addr)); + if (rc > 0) { + ipaddr = url->host; + } else { + /* need to turn hostname into a valid IP */ + rc = getaddrinfo(url->host, NULL, NULL, &res); + if (rc) { + pb_debug("%s: Invalid URL\n",__func__); + return NULL; + } + ipaddr = talloc_array(ctx,char,INET_ADDRSTRLEN); + ip = (struct sockaddr_in *) res->ai_addr; + inet_ntop(AF_INET, &(ip->sin_addr), ipaddr, INET_ADDRSTRLEN); + freeaddrinfo(res); + } + + const char *argv[] = { + pb_system_apps.ip, + "route", "show", "to", "match", + ipaddr, + NULL + }; + + p = process_create(ctx); + + p->path = pb_system_apps.ip; + p->argv = argv; + p->keep_stdout = true; + + rc = process_run_sync(p); + + if (rc) { + /* ip has complained for some reason; most likely + * there is no route to the host - bail out */ + pb_debug("%s: No route to %s\n",__func__,url->host); + return NULL; + } + + buf = p->stdout_buf; + /* If a route is found, ip-route output will be of the form + * "... dev DEVNAME ... " */ + tok = strtok(buf, delim); + while (tok) { + if (!strcmp(tok, "dev")) { + tok = strtok(NULL, delim); + dev = talloc_strdup(ctx, tok); + break; + } + tok = strtok(NULL, delim); + } + + process_release(p); + if (dev) + pb_debug("%s: Found interface '%s'\n", __func__,dev); + return dev; +} + + +void device_handler_process_url(struct device_handler *handler, + const char *url) +{ + struct discover_context *ctx; + struct discover_device *dev; + struct boot_status *status; + struct pb_url *pb_url; + struct event *event; + struct param *param; + + status = talloc(handler, struct boot_status); + + status->type = BOOT_STATUS_ERROR; + status->progress = 0; + status->detail = talloc_asprintf(status, + _("Received config URL %s"), url); + + if (!handler->network) { + status->message = talloc_asprintf(handler, + _("No network configured")); + goto msg; + } + + event = talloc(handler, struct event); + event->type = EVENT_TYPE_USER; + event->action = EVENT_ACTION_CONF; + + event->params = talloc_array(event, struct param, 1); + param = &event->params[0]; + param->name = talloc_strdup(event, "pxeconffile"); + param->value = talloc_strdup(event, url); + event->n_params = 1; + + pb_url = pb_url_parse(event, event->params->value); + if (!pb_url || !pb_url->host) { + status->message = talloc_asprintf(handler, + _("Invalid config URL!")); + goto msg; + } + + event->device = device_from_addr(event, pb_url); + if (!event->device) { + status->message = talloc_asprintf(status, + _("Unable to route to host %s"), + pb_url->host); + goto msg; + } + + dev = discover_device_create(handler, event->device); + ctx = device_handler_discover_context_create(handler, dev); + ctx->event = event; + + iterate_parsers(ctx); + + device_handler_discover_context_commit(handler, ctx); + + talloc_free(ctx); + + status->type = BOOT_STATUS_INFO; + status->message = talloc_asprintf(status, _("Config file %s parsed"), + pb_url->file); +msg: + boot_status(handler, status); + talloc_free(status); +} + #ifndef PETITBOOT_TEST +static void device_handler_update_lang(const char *lang) +{ + const char *cur_lang; + + if (!lang) + return; + + cur_lang = setlocale(LC_ALL, NULL); + if (cur_lang && !strcmp(cur_lang, lang)) + return; + + setlocale(LC_ALL, lang); +} + static int device_handler_init_sources(struct device_handler *handler) { /* init our device sources: udev, network and user events */ @@ -1025,6 +1243,10 @@ void device_release_write(struct discover_device *dev, bool release) #else +static void device_handler_update_lang(const char *lang __attribute__((unused))) +{ +} + static int device_handler_init_sources( struct device_handler *handler __attribute__((unused))) {