X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=9c050293df98cf446a44aa560ad3941dbfa4aa89;hp=8ad885f68225c031efc6de9b0b9f570776a53662;hb=70a58a78c951403ae67c44c839caf0e77d0d84db;hpb=c62ae29ecbc248527a03578fa18e1b6b93506965 diff --git a/discover/device-handler.c b/discover/device-handler.c index 8ad885f..9c05029 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -42,12 +43,15 @@ #include "ipmi.h" enum default_priority { - DEFAULT_PRIORITY_REMOTE = 1, - DEFAULT_PRIORITY_LOCAL_FIRST = 2, + DEFAULT_PRIORITY_TEMP_USER = 1, + DEFAULT_PRIORITY_REMOTE = 2, + DEFAULT_PRIORITY_LOCAL_FIRST = 3, DEFAULT_PRIORITY_LOCAL_LAST = 0xfe, DEFAULT_PRIORITY_DISABLED = 0xff, }; +static int default_rescan_timeout = 5 * 60; /* seconds */ + struct progress_info { unsigned int percentage; unsigned long size; /* size in bytes */ @@ -74,6 +78,7 @@ struct device_handler { struct waiter *timeout_waiter; bool autoboot_enabled; unsigned int sec_to_boot; + struct autoboot_option *temp_autoboot; struct discover_boot_option *default_boot_option; int default_boot_option_priority; @@ -417,10 +422,13 @@ void device_handler_reinit(struct device_handler *handler) /* drop all devices */ for (i = 0; i < handler->n_devices; i++) { + struct discover_device *device = handler->devices[i]; discover_server_notify_device_remove(handler->server, - handler->devices[i]->device); - ramdisk = handler->devices[i]->ramdisk; - talloc_free(handler->devices[i]); + device->device); + ramdisk = device->ramdisk; + if (device->requery_waiter) + waiter_remove(device->requery_waiter); + talloc_free(device); talloc_free(ramdisk); } @@ -450,6 +458,9 @@ void device_handler_reinit(struct device_handler *handler) discover_server_notify_config(handler->server, config); } + /* Force rediscovery on SCSI devices */ + process_run_simple(handler, pb_system_apps.scsi_rescan, NULL); + device_handler_reinit_sources(handler); } @@ -459,6 +470,9 @@ void device_handler_remove(struct device_handler *handler, struct discover_boot_option *opt, *tmp; unsigned int i; + if (device->requery_waiter) + waiter_remove(device->requery_waiter); + list_for_each_entry_safe(&device->boot_options, opt, tmp, list) { if (opt == handler->default_boot_option) { pb_log("Default option %s cancelled since device removed", @@ -508,6 +522,7 @@ void device_handler_remove(struct device_handler *handler, void device_handler_status(struct device_handler *handler, struct status *status) { + pb_debug("%s: %s\n", __func__, status->message); discover_server_notify_boot_status(handler->server, status); } @@ -653,7 +668,7 @@ void device_handler_status_download(struct device_handler *handler, unit++; } update = talloc_asprintf(handler, - _("%u %s downloading: %.0f%% - %lu%cB"), + _("%u %s downloading: %.0f%% - %" PRIu64 "%cB"), handler->n_progress, ngettext("item", "items", handler->n_progress), (current / total) * 100, current_converted, @@ -661,7 +676,7 @@ void device_handler_status_download(struct device_handler *handler, } if (!update) { - pb_log("%s: failed to allocate new status\n", __func__); + pb_log_fn("failed to allocate new status\n"); } else { device_handler_status_info(handler, "%s\n", update); talloc_free(update); @@ -698,7 +713,17 @@ void device_handler_status_download_remove(struct device_handler *handler, static void device_handler_boot_status_cb(void *arg, struct status *status) { - device_handler_status(arg, status); + struct device_handler *handler = arg; + + /* boot had failed; update handler state to allow a new default if one + * is found later + */ + if (status->type == STATUS_ERROR) { + handler->pending_boot = NULL; + handler->default_boot_option = NULL; + } + + device_handler_status(handler, status); } static void countdown_status(struct device_handler *handler, @@ -775,24 +800,31 @@ static bool ipmi_device_type_matches(enum ipmi_bootdev ipmi_type, return false; } +static bool autoboot_option_matches(struct autoboot_option *opt, + struct discover_device *dev) +{ + if (opt->boot_type == BOOT_DEVICE_UUID) + if (!strcmp(opt->uuid, dev->uuid)) + return true; + + if (opt->boot_type == BOOT_DEVICE_TYPE) + if (opt->type == dev->device->type || + opt->type == DEVICE_TYPE_ANY) + return true; + + return false; +} + static int autoboot_option_priority(const struct config *config, struct discover_boot_option *opt) { - enum device_type type = opt->device->device->type; - const char *uuid = opt->device->uuid; struct autoboot_option *auto_opt; unsigned int i; for (i = 0; i < config->n_autoboot_opts; i++) { auto_opt = &config->autoboot_opts[i]; - if (auto_opt->boot_type == BOOT_DEVICE_UUID) - if (!strcmp(auto_opt->uuid, uuid)) - return DEFAULT_PRIORITY_LOCAL_FIRST + i; - - if (auto_opt->boot_type == BOOT_DEVICE_TYPE) - if (auto_opt->type == type || - auto_opt->type == DEVICE_TYPE_ANY) - return DEFAULT_PRIORITY_LOCAL_FIRST + i; + if (autoboot_option_matches(auto_opt, opt->device)) + return DEFAULT_PRIORITY_LOCAL_FIRST + i; } return -1; @@ -804,15 +836,27 @@ static int autoboot_option_priority(const struct config *config, * for these options. */ static enum default_priority default_option_priority( + struct device_handler *handler, struct discover_boot_option *opt) { const struct config *config; + /* Temporary user-provided autoboot options have highest priority */ + if (handler->temp_autoboot) { + if (autoboot_option_matches(handler->temp_autoboot, + opt->device)) + return DEFAULT_PRIORITY_TEMP_USER; + + pb_debug("handler: disabled default priority due to " + "temporary user override\n"); + return DEFAULT_PRIORITY_DISABLED; + } + config = config_get(); - /* 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 */ + /* Next 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); @@ -831,6 +875,9 @@ static enum default_priority default_option_priority( int boot_match = autoboot_option_priority(config, opt); if (boot_match > 0) return boot_match; + } else { + /* If there is no specific boot order, boot any device */ + return DEFAULT_PRIORITY_LOCAL_FIRST; } /* If the option didn't match any entry in the array, it is disabled */ @@ -849,7 +896,7 @@ static void set_default(struct device_handler *handler, pb_debug("handler: new default option: %s\n", opt->option->id); - new_prio = default_option_priority(opt); + new_prio = default_option_priority(handler, opt); /* Anything outside our range prevents a default boot */ if (new_prio >= DEFAULT_PRIORITY_DISABLED) @@ -889,6 +936,68 @@ static void set_default(struct device_handler *handler, default_timeout(handler); } +static char *autoboot_option_desc(void *ctx, const struct autoboot_option *opt) +{ + const char *type, *val; + + if (opt->boot_type == BOOT_DEVICE_TYPE) { + type = _("device type"); + val = device_type_display_name(opt->type); + } else if (opt->boot_type == BOOT_DEVICE_UUID) { + type = _("device UUID"); + val = opt->uuid; + } else { + type = _("unknown specifier"); + val = NULL; + } + + return talloc_asprintf(ctx, "%s = %s", type, val); +} + +void device_handler_apply_temp_autoboot(struct device_handler *handler, + struct autoboot_option *opt) +{ + unsigned int i; + char *desc; + + handler->temp_autoboot = talloc_steal(handler, opt); + + desc = autoboot_option_desc(handler, opt); + device_handler_status_info(handler, + _("Applying temporary autoboot override: %s"), + desc); + talloc_free(desc); + + if (!handler->autoboot_enabled) + return; + + if (!handler->default_boot_option) + return; + + if (autoboot_option_matches(opt, handler->default_boot_option->device)) + return; + + /* cancel the default, and rescan available options */ + device_handler_cancel_default(handler); + + handler->autoboot_enabled = true; + + for (i = 0; i < handler->n_devices; i++) { + struct discover_device *dev = handler->devices[i]; + struct discover_boot_option *boot_opt; + + if (!autoboot_option_matches(opt, dev)) + continue; + + list_for_each_entry(&dev->boot_options, boot_opt, list) { + if (boot_opt->option->is_default) { + set_default(handler, boot_opt); + break; + } + } + } +} + static bool resource_is_resolved(struct resource *res) { return !res || res->resolved; @@ -1158,15 +1267,123 @@ out: return 0; } +struct requery_data { + struct device_handler *handler; + struct discover_device *device; +}; + +static int device_handler_requery_timeout_fn(void *data) +{ + struct discover_boot_option *opt, *tmp; + struct requery_data *rqd = data; + struct device_handler *handler; + struct discover_device *device; + + handler = rqd->handler; + device = rqd->device; + + talloc_free(rqd); + + /* network_requery_device may re-add a timeout, so clear the device + * waiter here, so we can potentially start a new one. */ + device->requery_waiter = NULL; + + /* We keep the device around, but get rid of the parsed boot + * options on that device. That involves delaring out the lists, + * and potentially cancelling a default. + */ + list_for_each_entry_safe(&handler->unresolved_boot_options, + opt, tmp, list) { + if (opt->device != device) + continue; + list_remove(&opt->list); + talloc_free(opt); + } + + list_for_each_entry_safe(&device->boot_options, opt, tmp, list) { + if (opt == handler->default_boot_option) { + pb_log("Default option %s cancelled since device is being requeried", + opt->option->name); + device_handler_cancel_default(handler); + } + list_remove(&opt->list); + talloc_free(opt); + } + + discover_server_notify_device_remove(handler->server, device->device); + device->notified = false; + + network_requery_device(handler->network, device); + + return 0; +} + +/* Schedule a requery in timeout (seconds). + * + * Special values of timeout: + * 0: no requery + * -1: use default + */ +void device_handler_start_requery_timeout( struct device_handler *handler, + struct discover_device *dev, int timeout) +{ + struct requery_data *rqd; + + if (dev->requery_waiter) + return; + + if (timeout == -1) + timeout = default_rescan_timeout; + else if (timeout == 0) + return; + + rqd = talloc(dev, struct requery_data); + rqd->handler = handler; + rqd->device = dev; + + pb_debug("starting requery timeout for device %s, in %d sec\n", + dev->device->id, timeout); + + dev->requery_waiter = waiter_register_timeout(handler->waitset, + timeout * 1000, device_handler_requery_timeout_fn, rqd); +} + +static int event_requery_timeout(struct event *event) +{ + int timeout = -1; + unsigned long x; + const char *str; + char *endp; + + if (!event) + return timeout; + + str = event_get_param(event, "reboottime"); + if (!str) + return timeout; + + x = strtoul(str, &endp, 0); + if (endp != str) + timeout = x; + + return timeout; +} + + /* Incoming dhcp event */ int device_handler_dhcp(struct device_handler *handler, struct discover_device *dev, struct event *event) { struct discover_context *ctx; + const char *ip; + + if (event_get_param(event, "ipv6")) + ip = event_get_param(event, "ipv6"); + else + ip = event_get_param(event, "ip"); device_handler_status_dev_info(handler, dev, - _("Processing DHCP lease response (ip: %s)"), - event_get_param(event, "ip")); + _("Processing DHCP lease response (ip: %s)"), ip); pending_network_jobs_start(); @@ -1175,6 +1392,9 @@ int device_handler_dhcp(struct device_handler *handler, talloc_steal(ctx, event); ctx->event = event; + device_handler_start_requery_timeout(handler, dev, + event_requery_timeout(event)); + iterate_parsers(ctx); device_handler_discover_context_commit(handler, ctx); @@ -1261,32 +1481,44 @@ void device_handler_update_config(struct device_handler *handler, static char *device_from_addr(void *ctx, struct pb_url *url) { char *ipaddr, *buf, *tok, *dev = NULL; + bool ipv6_route; const char *delim = " "; - struct sockaddr_in *ip; - struct sockaddr_in si; + struct sockaddr_in *ipv4; + struct sockaddr_in6 *ipv6; 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; - } + /* Confirm url->host is either a valid hostname, or a + * valid IPv4 or IPv6 address */ + rc = getaddrinfo(url->host, NULL, NULL, &res); + if (rc) { + pb_debug("%s: Invalid URL\n",__func__); + return NULL; + } + + switch (res->ai_family) { + case AF_INET: /* ipv4 */ ipaddr = talloc_array(ctx,char,INET_ADDRSTRLEN); - ip = (struct sockaddr_in *) res->ai_addr; - inet_ntop(AF_INET, &(ip->sin_addr), ipaddr, INET_ADDRSTRLEN); + ipv4 = (struct sockaddr_in *) res->ai_addr; + inet_ntop(AF_INET, &(ipv4->sin_addr), ipaddr, INET_ADDRSTRLEN); + ipv6_route = false; + break; + case AF_INET6: /* ipv6 */ + ipaddr = talloc_array(ctx,char,INET6_ADDRSTRLEN); + ipv6 = (struct sockaddr_in6 *) res->ai_addr; + inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipaddr, INET6_ADDRSTRLEN); + ipv6_route = true; + break; + default: /* error */ freeaddrinfo(res); + return NULL; } + freeaddrinfo(res); const char *argv[] = { pb_system_apps.ip, + ipv6_route ? "-6" : "-4", "route", "show", "to", "match", ipaddr, NULL @@ -1337,7 +1569,7 @@ static void process_url_cb(struct load_url_result *result, void *data) const char *mac; if (result->status != LOAD_OK) { - pb_log("%s: Load failed for %s\n", __func__, result->url->full); + pb_log_fn("Load failed for %s\n", result->url->full); return; } @@ -1356,7 +1588,7 @@ static void process_url_cb(struct load_url_result *result, void *data) mac = event_get_param(event, "mac"); char *url = talloc_asprintf(event, "file://%s", result->local); - event_set_param(event, "pxeconffile", url); + event_set_param(event, "pxeconffile-local", url); dev = discover_device_create(handler, mac, event->device); ctx = device_handler_discover_context_create(handler, dev); @@ -1442,7 +1674,7 @@ static void plugin_install_cb(struct process *process) struct device_handler *handler = process->data; if (!handler) { - pb_log("%s: Missing data!\n", __func__); + pb_log_fn("Missing data!\n"); return; } @@ -1556,8 +1788,7 @@ void device_handler_add_plugin_option(struct device_handler *handler, tmp = handler->plugins[i]; /* If both id and version match, ignore */ if (strncmp(opt->id, tmp->id, strlen(opt->id)) == 0 && - strncmp(opt->version, tmp->version, - strlen(opt->version) == 0)) { + strcmp(opt->version, tmp->version) == 0) { pb_log("discover: Plugin '%s' already exists, ignoring\n", opt->id); return; @@ -1976,7 +2207,7 @@ void device_handler_discover_context_commit( struct device_handler *handler __attribute__((unused)), struct discover_context *ctx __attribute__((unused))) { - pb_log("%s stubbed out for test cases\n", __func__); + pb_log_fn("stubbed out for test cases\n"); } static void device_handler_update_lang(const char *lang __attribute__((unused)))