Also adds support for representing the system's nodev filesystem mounts.

The include_nodev flag must be set to True prior to calling Blivet.getActiveMounts, which is called from within Blivet.reset (if flags.installer_mode is False).

There can be multiple mounts of any given nodev filesystem type, which presents a problem in terms of looking up devices by name. The chosen solution is to add a unique identifier to each NoDevice instance's name. --- blivet/__init__.py | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++- blivet/devices.py | 5 +++-- blivet/devicetree.py | 2 ++ blivet/flags.py | 4 ++++ blivet/formats/fs.py | 30 +++++++++++++++++++++------- 5 files changed, 86 insertions(+), 10 deletions(-)

diff --git a/blivet/__init__.py b/blivet/__init__.py index 7958eb1..6456311 100644 --- a/blivet/__init__.py +++ b/blivet/__init__.py @@ -55,6 +55,7 @@ from deviceaction import * from formats import getFormat from formats import get_device_format_class from formats import get_default_filesystem_type +from formats.fs import nodev_filesystems import devicefactory from devicelibs.dm import name_from_dm_node from devicelibs.crypto import generateBackupPassphrase @@ -406,6 +407,9 @@ class Blivet(object): if flags.installer_mode: self.roots = findExistingInstallations(self.devicetree)

+ if not flags.installer_mode: + self.getActiveMounts() + self.dumpState("initial")

self.updateBootLoaderDiskList() @@ -1870,6 +1874,56 @@ class Blivet(object):

return new

+ def getActiveMounts(self): + """ Reflect active mounts in the appropriate devices' formats. """ + log.info("collecting information about active mounts") + for _line in open("/proc/mounts").readlines(): + (line, pound, comment) = _line.partition("#") + try: + (devspec, mountpoint, fstype, options, rest) = line.split(None, 4) + except IndexError: + blivet_log.error("failed to parse /proc/mounts line: %s" % _line) + continue + + if fstype == "btrfs": + # get the subvol name from /proc/self/mountinfo + for line in open("/proc/self/mountinfo").readlines(): + fields = line.split() + _subvol = fields[3] + _mountpoint = fields[4] + _devspec = fields[9] + if _mountpoint == mountpoint and _devspec == devspec: + log.debug("subvol %s" % _subvol) + options += ",subvol=%s" % _subvol[1:] + + if fstype in nodev_filesystems: + if not flags.include_nodev: + continue + + log.info("found nodev %s filesystem mounted at %s" + % (fstype, mountpoint)) + # nodev filesystems require some special handling. + # For now, a lot of this is based on the idea that it's a losing + # battle to require the presence of an FS class for every type + # of nodev filesystem. Based on that idea, we just instantiate + # NoDevFS directly and then hack in the fstype as the device + # attribute. + fmt = getFormat("nodev") + fmt.device = fstype + + # NoDevice also needs some special works since they don't have + # per-instance names in the kernel. + device = NoDevice(format=fmt) + n = len([d for d in self.devices if d.format.type == fstype]) + device._name += ".%d" % n + self.devicetree._addDevice(device) + devspec = device.name + + device = self.devicetree.resolveDevice(devspec, options=options) + if device is not None: + device.format.mountpoint = mountpoint # for future mounts + device.format._mountpoint = mountpoint # active mountpoint +

def mountExistingSystem(fsset, rootDevice, allowDirty=None, dirtyCB=None, @@ -2656,7 +2710,6 @@ class FSSet(object):

return fstab

- def getReleaseString(): relName = None relVer = None diff --git a/blivet/devices.py b/blivet/devices.py index 791084a..19885bf 100644 --- a/blivet/devices.py +++ b/blivet/devices.py @@ -3415,7 +3415,7 @@ class NoDevice(StorageDevice): format -- a DeviceFormat instance """ if format: - name = format.type + name = format.device else: name = "none"

@@ -3424,7 +3424,8 @@ class NoDevice(StorageDevice): @property def path(self): """ Device node representing this device. """ - return self.name + # the name may have a '.%d' suffix to make it unique + return self.name.split(".")[0]

def setup(self, orig=False): """ Open, or set up, a device. """ diff --git a/blivet/devicetree.py b/blivet/devicetree.py index 88ba130..026dda6 100644 --- a/blivet/devicetree.py +++ b/blivet/devicetree.py @@ -2142,6 +2142,8 @@ class DeviceTree(object): if edd_number == spec: device = self.getDeviceByName(edd_name) break + elif options and "nodev" in options.split(","): + device = self.getDeviceByName(devspec) else: if not devspec.startswith("/dev/"): device = self.getDeviceByName(devspec) diff --git a/blivet/flags.py b/blivet/flags.py index ed0e5dc..e892b74 100644 --- a/blivet/flags.py +++ b/blivet/flags.py @@ -54,6 +54,10 @@ class Flags(object):

self.gpt = False

+ # whether to include nodev filesystems in the devicetree (only + # meaningful when flags.installer_mode is False) + self.include_nodev = False + self.boot_cmdline = {}

self.update_from_boot_cmdline() diff --git a/blivet/formats/fs.py b/blivet/formats/fs.py index de94ff4..840adb3 100644 --- a/blivet/formats/fs.py +++ b/blivet/formats/fs.py @@ -57,14 +57,19 @@ mib = 1024 * 1024.0

fs_configs = {}

-def get_kernel_filesystems(): - fs_list = [] +kernel_filesystems = [] +nodev_filesystems = [] + +def update_kernel_filesystems(): + global kernel_filesystems + global nodev_filesystems for line in open("/proc/filesystems").readlines(): - fs_list.append(line.split()[-1]) - return fs_list + fields = line.split() + kernel_filesystems.append(fields[-1]) + if fields[0] == "nodev": + nodev_filesystems.append(fields[-1])

-global kernel_filesystems -kernel_filesystems = get_kernel_filesystems() +update_kernel_filesystems()

def fsConfigFromFile(config_file): """ Generate a set of attribute name/value pairs with which a @@ -485,7 +490,7 @@ class FS(DeviceFormat):

# If we successfully loaded a kernel module, for this filesystem, we # also need to update the list of supported filesystems. - kernel_filesystems = get_kernel_filesystems() + update_kernel_filesystems()

def testMount(self, options=None): """ Try to mount the fs and return True if successful. """ @@ -1370,6 +1375,17 @@ class NoDevFS(FS): def _setDevice(self, devspec): self._device = devspec

+ @property + def type(self): + if self.device != self._type: + return self.device + else: + return self._type + + @property + def mountType(self): + return self.device # this is probably set to the real/specific fstype + def _getExistingSize(self): pass

--- blivet/devicetree.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/blivet/devicetree.py b/blivet/devicetree.py index 834d6fe..b432adc 100644 --- a/blivet/devicetree.py +++ b/blivet/devicetree.py @@ -2214,7 +2214,10 @@ class DeviceTree(object): device = self.getDeviceByName(lv)

# check mount options for btrfs volumes in case it's a subvol - if device and device.type == "btrfs volume" and options: + if device and device.type.startswith("btrfs") and options: + # start with the volume -- not a subvolume + device = getattr(device, "volume", device) + attr = None if "subvol=" in options: attr = "name"

--- blivet/devicefactory.py | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py index 6a1f9d5..3982570 100644 --- a/blivet/devicefactory.py +++ b/blivet/devicefactory.py @@ -674,21 +674,27 @@ class PartitionFactory(DeviceFactory): def set_device_size(self, container, device=None): size = self.size if device: - if size != device.size: + if isinstance(device, LUKSDevice): + use_dev = device.slave + else: + use_dev = device + + if size != use_dev.size: log.info("adjusting device size from %.2f to %.2f" - % (device.size, size)) + % (use_dev.size, size))

+ # use device here since the leaf format is what we're concerned with base_size = max(PartitionFactory.default_size, device.format.minSize) size = max(base_size, size) - device.req_base_size = base_size - device.req_size = base_size - device.req_max_size = size - device.req_grow = size > base_size + use_dev.req_base_size = base_size + use_dev.req_size = base_size + use_dev.req_max_size = size + use_dev.req_grow = size > base_size

# this probably belongs somewhere else but this is our chance to # update the disk set - device.req_disks = self.disks[:] + use_dev.req_disks = self.disks[:]

return size

@@ -769,7 +775,12 @@ class LVMFactory(DeviceFactory): size = self.size free = container.freeSpace if device: - free += device.size + if isinstance(device, LUKSDevice): + use_dev = device.slave + else: + use_dev = device + + free += use_dev.size

if free < size: log.info("adjusting device size from %.2f to %.2f so it fits " @@ -777,11 +788,11 @@ class LVMFactory(DeviceFactory): size = free

if device: - if size != device.size: + if size != use_dev.size: log.info("adjusting device size from %.2f to %.2f" - % (device.size, size)) + % (use_dev.size, size))

- device.size = size + use_dev.size = size

return size

Related: rhbz#906906 Related: rhbz#906908 --- blivet/devicefactory.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)

diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py index 3982570..466fec3 100644 --- a/blivet/devicefactory.py +++ b/blivet/devicefactory.py @@ -150,6 +150,18 @@ class DeviceFactory(object):

return size

+ def handle_no_size(self, device=None, container=None): + """ Set device size so that it grows to the largest size possible. """ + if self.size is not None: + return + + free_info = self.storage.getFreeSpace(disks=self.disks) + free = sum(d[0] for d in free_info.values()) + self.size = int(free.convertTo(spec="mb")) + + if device: + self.size += device.size + @property def device_size(self): """ The total disk space required for this device. """ @@ -451,6 +463,9 @@ class DeviceFactory(object):

container = self.get_container(device=device, name=container_name)

+ # handle special size value of None, which means to grow unbounded + self.handle_no_size(device=device, container=container) + # TODO: striping, mirroring, &c # TODO: non-partition members (pv-on-md)

@@ -753,6 +768,20 @@ class LVMFactory(DeviceFactory): encrypt_members = True encrypt_leaves = False

+ def handle_no_size(self, device=None, container=None): + """ Set device size so that it grows to the largest size possible. """ + if self.size is not None: + return + + if container and container.exists: + self.size = container.freeSpace + + if device: + self.size += device.size + else: + super(LVMFactory, self).handle_no_size(device=device, + container=container) + @property def device_size(self): size_func_kwargs = {}

This is caused by an error in commit e3ceb9b553fb0b69. --- blivet/devicefactory.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/blivet/devicefactory.py b/blivet/devicefactory.py index 466fec3..f548cc5 100644 --- a/blivet/devicefactory.py +++ b/blivet/devicefactory.py @@ -606,7 +606,7 @@ class DeviceFactory(object): self.size = 0 self.disks = container.disks try: - self.set_container_members(container, factory) + self.set_container_members(container) except StorageError as e: log.error("failed to revert container: %s" % e) raise ErrorRecoveryFailure("failed to revert container")

It will still be a DeviceFormat instance, but it will have a type that is not None and will reflect what was requested. --- blivet/formats/__init__.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/blivet/formats/__init__.py b/blivet/formats/__init__.py index c8ddc0b..4a6c416 100644 --- a/blivet/formats/__init__.py +++ b/blivet/formats/__init__.py @@ -91,6 +91,14 @@ def getFormat(fmt_type, *args, **kwargs): className = fmt.__class__.__name__ except AttributeError: className = None + + # this allows us to store the given type for formats we implement as + # DeviceFormat. + if fmt_type and fmt.type is None: + # this should add/set an instance attribute + fmt._type = fmt_type + fmt._name = None + log.debug("getFormat('%s') returning %s instance" % (fmt_type, className)) return fmt

@@ -137,7 +145,7 @@ def get_device_format_class(fmt_type): class DeviceFormat(object): """ Generic device format. """ _type = None - _name = "Unknown" + _name = _("Unknown") _udevTypes = [] partedFlag = None partedSystem = None