#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;
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;
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;
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);
ctx = talloc_zero(handler, struct discover_context);
ctx->device = device;
+ ctx->network = handler->network;
list_init(&ctx->boot_options);
return ctx;
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);
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;
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);
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;
int device_request_write(struct discover_device *dev, bool *release)
{
+ const char *fstype;
int rc;
*release = false;
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;
}
projects / petitboot / blobdiff