X-Git-Url: http://git.ozlabs.org/?p=petitboot;a=blobdiff_plain;f=discover%2Fdevice-handler.c;h=f0537134c1a3bc2a517f40b8cc385525940dfe0b;hp=7cf52636e56766db936d3bdb70ff104b17dd7797;hb=6bb1301835dbd6ff54e1becb5b684fedb0e4caaf;hpb=4d5a57a73cbfa29ad2c8672f157294f733726f90 diff --git a/discover/device-handler.c b/discover/device-handler.c index 7cf5263..f053713 100644 --- a/discover/device-handler.c +++ b/discover/device-handler.c @@ -36,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; @@ -54,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; @@ -429,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; @@ -508,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); @@ -626,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; @@ -787,7 +843,7 @@ void device_handler_boot(struct device_handler *handler, if (handler->pending_boot) boot_cancel(handler->pending_boot); - platform_finalise_config(); + platform_pre_boot(); handler->pending_boot = boot(handler, opt, cmd, handler->dry_run, boot_status, handler); @@ -1026,6 +1082,20 @@ static void device_handler_reinit_sources(struct device_handler *handler) handler->dry_run); } +static const char *fs_parameters(unsigned int rw_flags, const char *fstype) +{ + if ((rw_flags | MS_RDONLY) != MS_RDONLY) + return ""; + + /* Avoid writing back to the disk on journaled filesystems */ + if (!strncmp(fstype, "ext4", strlen("ext4"))) + return "norecovery"; + if (!strncmp(fstype, "xfs", strlen("xfs"))) + return "norecovery"; + + return ""; +} + static bool check_existing_mount(struct discover_device *dev) { struct stat devstat, mntstat; @@ -1099,6 +1169,13 @@ static int mount_device(struct discover_device *dev) if (!fstype) return 0; + /* ext3 treats the norecovery option as an error, so mount the device + * as an ext4 filesystem instead */ + if (!strncmp(fstype, "ext3", strlen("ext3"))) { + pb_debug("Mounting ext3 filesystem as ext4\n"); + fstype = talloc_asprintf(dev, "ext4"); + } + dev->mount_path = join_paths(dev, mount_base(), dev->device_path); @@ -1111,7 +1188,8 @@ static int mount_device(struct discover_device *dev) pb_log("mounting device %s read-only\n", dev->device_path); errno = 0; rc = mount(dev->device_path, dev->mount_path, fstype, - MS_RDONLY | MS_SILENT, ""); + MS_RDONLY | MS_SILENT, + fs_parameters(MS_RDONLY, fstype)); if (!rc) { dev->mounted = true; dev->mounted_rw = false; @@ -1153,6 +1231,7 @@ static int umount_device(struct discover_device *dev) int device_request_write(struct discover_device *dev, bool *release) { + const char *fstype; int rc; *release = false; @@ -1163,25 +1242,48 @@ int device_request_write(struct discover_device *dev, bool *release) if (dev->mounted_rw) return 0; + fstype = discover_device_get_param(dev, "ID_FS_TYPE"); + pb_log("remounting device %s read-write\n", dev->device_path); - rc = mount(dev->device_path, dev->mount_path, "", - MS_REMOUNT | MS_SILENT, ""); - if (rc) + + rc = umount(dev->mount_path); + if (rc) { + pb_log("Failed to unmount %s\n", dev->mount_path); return -1; + } + rc = mount(dev->device_path, dev->mount_path, fstype, + MS_SILENT, + fs_parameters(MS_REMOUNT, fstype)); + if (rc) + goto mount_ro; dev->mounted_rw = true; *release = true; return 0; + +mount_ro: + pb_log("Unable to remount device %s read-write\n", dev->device_path); + rc = mount(dev->device_path, dev->mount_path, fstype, + MS_RDONLY | MS_SILENT, + fs_parameters(MS_RDONLY, fstype)); + if (rc) + pb_log("Unable to recover mount for %s\n", dev->device_path); + return -1; } void device_release_write(struct discover_device *dev, bool release) { + const char *fstype; + if (!release) return; + fstype = discover_device_get_param(dev, "ID_FS_TYPE"); + pb_log("remounting device %s read-only\n", dev->device_path); mount(dev->device_path, dev->mount_path, "", - MS_REMOUNT | MS_RDONLY | MS_SILENT, ""); + MS_REMOUNT | MS_RDONLY | MS_SILENT, + fs_parameters(MS_RDONLY, fstype)); dev->mounted_rw = false; }