# partitioning.py # Disk partitioning functions. # # Copyright (C) 2009 Red Hat, Inc. # # This copyrighted material is made available to anyone wishing to use, # modify, copy, or redistribute it subject to the terms and conditions of # the GNU General Public License v.2, or (at your option) any later version. # This program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY expressed or implied, including the implied warranties of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. You should have received a copy of the # GNU General Public License along with this program; if not, write to the # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. Any Red Hat trademarks that are incorporated in the # source code or documentation are not subject to the GNU General Public # License and may only be used or replicated with the express permission of # Red Hat, Inc. # # Red Hat Author(s): Dave Lehman # import sys import os from operator import add, sub, gt, lt import parted from pykickstart.constants import * from constants import * from errors import * from deviceaction import * from devices import PartitionDevice, LUKSDevice, devicePathToName from formats import getFormat import gettext _ = lambda x: gettext.ldgettext("anaconda", x) import logging log = logging.getLogger("storage") def _createFreeSpacePartitions(anaconda): # get a list of disks that have at least one free space region of at # least 100MB disks = [] for disk in anaconda.storage.partitioned: if anaconda.storage.clearPartDisks and \ (disk.name not in anaconda.storage.clearPartDisks): continue part = disk.format.firstPartition while part: if not part.type & parted.PARTITION_FREESPACE: part = part.nextPartition() continue if part.getSize(unit="MB") > 100: disks.append(disk) break part = part.nextPartition() # create a separate pv partition for each disk with free space devs = [] for disk in disks: if anaconda.storage.encryptedAutoPart: fmt_type = "luks" fmt_args = {"escrow_cert": anaconda.storage.autoPartEscrowCert, "add_backup_passphrase": anaconda.storage.autoPartAddBackupPassphrase} else: fmt_type = "lvmpv" fmt_args = {} part = anaconda.storage.newPartition(fmt_type=fmt_type, fmt_args=fmt_args, size=1, grow=True, disks=[disk]) anaconda.storage.createDevice(part) devs.append(part) return (disks, devs) def _schedulePartitions(anaconda, disks): # # Convert storage.autoPartitionRequests into Device instances and # schedule them for creation # # First pass is for partitions only. We'll do LVs later. # for request in anaconda.storage.autoPartitionRequests: if request.asVol: continue if request.fstype is None: request.fstype = anaconda.storage.defaultFSType # This is a little unfortunate but let the backend dictate the rootfstype # so that things like live installs can do the right thing if request.mountpoint == "/" and anaconda.backend.rootFsType != None: request.fstype = anaconda.backend.rootFsType dev = anaconda.storage.newPartition(fmt_type=request.fstype, size=request.size, grow=request.grow, maxsize=request.maxSize, mountpoint=request.mountpoint, disks=disks, weight=request.weight) # schedule the device for creation anaconda.storage.createDevice(dev) # make sure preexisting broken lvm/raid configs get out of the way return def _scheduleLVs(anaconda, devs): if anaconda.storage.encryptedAutoPart: pvs = [] for dev in devs: pv = LUKSDevice("luks-%s" % dev.name, format=getFormat("lvmpv", device=dev.path), size=dev.size, parents=dev) pvs.append(pv) anaconda.storage.createDevice(pv) else: pvs = devs # create a vg containing all of the autopart pvs vg = anaconda.storage.newVG(pvs=pvs) anaconda.storage.createDevice(vg) initialVGSize = vg.size # # Convert storage.autoPartitionRequests into Device instances and # schedule them for creation. # # Second pass, for LVs only. for request in anaconda.storage.autoPartitionRequests: if not request.asVol: continue if request.requiredSpace and request.requiredSpace > initialVGSize: continue if request.fstype is None: request.fstype = anaconda.storage.defaultFSType # This is a little unfortunate but let the backend dictate the rootfstype # so that things like live installs can do the right thing if request.mountpoint == "/" and anaconda.backend.rootFsType != None: request.fstype = anaconda.backend.rootFsType # FIXME: move this to a function and handle exceptions dev = anaconda.storage.newLV(vg=vg, fmt_type=request.fstype, mountpoint=request.mountpoint, grow=request.grow, maxsize=request.maxSize, size=request.size) # schedule the device for creation anaconda.storage.createDevice(dev) def doAutoPartition(anaconda): log.debug("doAutoPartition(%s)" % anaconda) log.debug("doAutoPart: %s" % anaconda.storage.doAutoPart) log.debug("clearPartType: %s" % anaconda.storage.clearPartType) log.debug("clearPartDisks: %s" % anaconda.storage.clearPartDisks) log.debug("autoPartitionRequests: %s" % anaconda.storage.autoPartitionRequests) log.debug("storage.disks: %s" % [d.name for d in anaconda.storage.disks]) log.debug("storage.partitioned: %s" % [d.name for d in anaconda.storage.partitioned]) log.debug("all names: %s" % [d.name for d in anaconda.storage.devices]) if anaconda.dir == DISPATCH_BACK: anaconda.storage.reset() return disks = [] devs = [] if anaconda.storage.doAutoPart: clearPartitions(anaconda.storage) if anaconda.storage.doAutoPart: (disks, devs) = _createFreeSpacePartitions(anaconda) if disks == []: if anaconda.ksdata: msg = _("Could not find enough free space for automatic " "partitioning. Press 'OK' to exit the installer.") else: msg = _("Could not find enough free space for automatic " "partitioning, please use another partitioning method.") anaconda.intf.messageWindow(_("Error Partitioning"), msg, custom_icon='error') if anaconda.ksdata: sys.exit(0) anaconda.storage.reset() return DISPATCH_BACK _schedulePartitions(anaconda, disks) # sanity check the individual devices log.warning("not sanity checking devices because I don't know how yet") # run the autopart function to allocate and grow partitions try: doPartitioning(anaconda.storage, exclusiveDisks=anaconda.storage.clearPartDisks) if anaconda.storage.doAutoPart: _scheduleLVs(anaconda, devs) # grow LVs growLVM(anaconda.storage) except PartitioningWarning as msg: if not anaconda.ksdata: anaconda.intf.messageWindow(_("Warnings During Automatic " "Partitioning"), _("Following warnings occurred during automatic " "partitioning:\n\n%s") % (msg,), custom_icon='warning') else: log.warning(msg) except PartitioningError as msg: # restore drives to original state anaconda.storage.reset() if not anaconda.ksdata: extra = "" if anaconda.displayMode != "t": anaconda.dispatch.skipStep("partition", skip = 0) else: extra = _("\n\nPress 'OK' to exit the installer.") anaconda.intf.messageWindow(_("Error Partitioning"), _("Could not allocate requested partitions: \n\n" "%(msg)s.%(extra)s") % {'msg': msg, 'extra': extra}, custom_icon='error') if anaconda.ksdata: sys.exit(0) else: return # sanity check the collection of devices log.warning("not sanity checking storage config because I don't know how yet") # now do a full check of the requests (errors, warnings) = anaconda.storage.sanityCheck() if warnings: for warning in warnings: log.warning(warning) if errors: errortxt = "\n".join(errors) if anaconda.ksdata: extra = _("\n\nPress 'OK' to exit the installer.") else: extra = _("\n\nPress 'OK' to choose a different partitioning option.") anaconda.intf.messageWindow(_("Automatic Partitioning Errors"), _("The following errors occurred with your " "partitioning:\n\n%(errortxt)s\n\n" "This can happen if there is not enough " "space on your hard drive(s) for the " "installation. %(extra)s") % {'errortxt': errortxt, 'extra': extra}, custom_icon='error') # # XXX if in kickstart we reboot # if anaconda.ksdata: anaconda.intf.messageWindow(_("Unrecoverable Error"), _("The system will now reboot.")) sys.exit(0) anaconda.storage.reset() return DISPATCH_BACK def shouldClear(device, clearPartType, clearPartDisks=None): if clearPartType not in [CLEARPART_TYPE_LINUX, CLEARPART_TYPE_ALL]: return False if isinstance(device, PartitionDevice): # Never clear the special first partition on a Mac disk label, as that # holds the partition table itself. if device.disk.format.partedDisk.type == "mac" and \ device.partedPartition.number == 1 and \ device.partedPartition.name == "Apple": return False # If we got a list of disks to clear, make sure this one's on it if clearPartDisks and device.disk.name not in clearPartDisks: return False # We don't want to fool with extended partitions, freespace, &c if device.partType not in [parted.PARTITION_NORMAL, parted.PARTITION_LOGICAL]: return False if clearPartType == CLEARPART_TYPE_LINUX and \ not device.format.linuxNative and \ not device.getFlag(parted.PARTITION_LVM) and \ not device.getFlag(parted.PARTITION_RAID) and \ not device.getFlag(parted.PARTITION_SWAP): return False elif device.isDisk and not device.partitioned: # If we got a list of disks to clear, make sure this one's on it if clearPartDisks and device.name not in clearPartDisks: return False if clearPartType == CLEARPART_TYPE_LINUX and \ not device.format.linuxNative: return False # Don't clear devices holding install media. if device.protected: return False # TODO: do platform-specific checks on ia64, pSeries, iSeries, mac return True def clearPartitions(storage): """ Clear partitions and dependent devices from disks. Arguments: storage -- a storage.Storage instance Keyword arguments: None NOTES: - Needs some error handling, especially for the parted bits. """ if storage.clearPartType is None or storage.clearPartType == CLEARPART_TYPE_NONE: # not much to do return # we are only interested in partitions that physically exist partitions = [p for p in storage.partitions if p.exists] # Sort partitions by descending partition number to minimize confusing # things like multiple "destroy sda5" actions due to parted renumbering # partitions. This can still happen through the UI but it makes sense to # avoid it where possible. partitions.sort(key=lambda p: p.partedPartition.number, reverse=True) for part in partitions: log.debug("clearpart: looking at %s" % part.name) if not shouldClear(part, storage.clearPartType, storage.clearPartDisks): continue log.debug("clearing %s" % part.name) # XXX is there any argument for not removing incomplete devices? # -- maybe some RAID devices devices = storage.deviceDeps(part) while devices: log.debug("devices to remove: %s" % ([d.name for d in devices],)) leaves = [d for d in devices if d.isleaf] log.debug("leaves to remove: %s" % ([d.name for d in leaves],)) for leaf in leaves: storage.destroyDevice(leaf) devices.remove(leaf) log.debug("partitions: %s" % [p.getDeviceNodeName() for p in part.partedPartition.disk.partitions]) storage.destroyDevice(part) # now remove any empty extended partitions removeEmptyExtendedPartitions(storage) def removeEmptyExtendedPartitions(storage): for disk in storage.partitioned: log.debug("checking whether disk %s has an empty extended" % disk.name) extended = disk.format.extendedPartition logical_parts = disk.format.logicalPartitions log.debug("extended is %s ; logicals is %s" % (extended, [p.getDeviceNodeName() for p in logical_parts])) if extended and not logical_parts: log.debug("removing empty extended partition from %s" % disk.name) extended_name = devicePathToName(extended.getDeviceNodeName()) extended = storage.devicetree.getDeviceByName(extended_name) storage.destroyDevice(extended) #disk.partedDisk.removePartition(extended.partedPartition) for disk in [d for d in storage.disks if d not in storage.partitioned]: # clear any whole-disk formats that need clearing if shouldClear(disk, storage.clearPartType, storage.clearPartDisks): log.debug("clearing %s" % disk.name) devices = storage.deviceDeps(disk) while devices: log.debug("devices to remove: %s" % ([d.name for d in devices],)) leaves = [d for d in devices if d.isleaf] log.debug("leaves to remove: %s" % ([d.name for d in leaves],)) for leaf in leaves: storage.destroyDevice(leaf) devices.remove(leaf) destroy_action = ActionDestroyFormat(disk) newLabel = getFormat("disklabel", device=disk.path) create_action = ActionCreateFormat(disk, format=newLabel) storage.devicetree.registerAction(destroy_action) storage.devicetree.registerAction(create_action) def partitionCompare(part1, part2): """ More specifically defined partitions come first. < 1 => x < y 0 => x == y > 1 => x > y """ ret = 0 if part1.req_base_weight: ret -= part1.req_base_weight if part2.req_base_weight: ret += part2.req_base_weight # bootable partitions to the front ret -= cmp(part1.req_bootable, part2.req_bootable) * 1000 # more specific disk specs to the front of the list # req_disks being empty is equivalent to it being an infinitely long list if part1.req_disks and not part2.req_disks: ret -= 500 elif not part1.req_disks and part2.req_disks: ret += 500 else: ret += cmp(len(part1.req_disks), len(part2.req_disks)) * 500 # primary-only to the front of the list ret -= cmp(part1.req_primary, part2.req_primary) * 200 # fixed size requests to the front ret += cmp(part1.req_grow, part2.req_grow) * 100 # larger requests go to the front of the list ret -= cmp(part1.req_base_size, part2.req_base_size) * 50 # potentially larger growable requests go to the front if part1.req_grow and part2.req_grow: if not part1.req_max_size and part2.req_max_size: ret -= 25 elif part1.req_max_size and not part2.req_max_size: ret += 25 else: ret -= cmp(part1.req_max_size, part2.req_max_size) * 25 # give a little bump based on mountpoint if hasattr(part1.format, "mountpoint") and \ hasattr(part2.format, "mountpoint"): ret += cmp(part1.format.mountpoint, part2.format.mountpoint) * 10 if ret > 0: ret = 1 elif ret < 0: ret = -1 return ret def getNextPartitionType(disk, no_primary=None): """ Find the type of partition to create next on a disk. Return a parted partition type value representing the type of the next partition we will create on this disk. If there is only one free primary partition and we can create an extended partition, we do that. If there are free primary slots and an extended partition we will recommend creating a primary partition. This can be overridden with the keyword argument no_primary. Arguments: disk -- a parted.Disk instance representing the disk Keyword arguments: no_primary -- given a choice between primary and logical partitions, prefer logical """ part_type = None extended = disk.getExtendedPartition() supports_extended = disk.supportsFeature(parted.DISK_TYPE_EXTENDED) logical_count = len(disk.getLogicalPartitions()) max_logicals = disk.getMaxLogicalPartitions() primary_count = disk.primaryPartitionCount if primary_count < disk.maxPrimaryPartitionCount: if primary_count == disk.maxPrimaryPartitionCount - 1: # can we make an extended partition? now's our chance. if not extended and supports_extended: part_type = parted.PARTITION_EXTENDED elif not extended: # extended partitions not supported. primary or nothing. if not no_primary: part_type = parted.PARTITION_NORMAL else: # there is an extended and a free primary if not no_primary: part_type = parted.PARTITION_NORMAL elif logical_count < max_logicals: # we have an extended with logical slots, so use one. part_type = parted.PARTITION_LOGICAL else: # there are two or more primary slots left. use one unless we're # not supposed to make primaries. if not no_primary: part_type = parted.PARTITION_NORMAL elif extended and logical_count < max_logicals: part_type = parted.PARTITION_LOGICAL elif extended and logical_count < max_logicals: part_type = parted.PARTITION_LOGICAL return part_type def getBestFreeSpaceRegion(disk, part_type, req_size, boot=None, best_free=None, grow=None): """ Return the "best" free region on the specified disk. For non-boot partitions, we return the largest free region on the disk. For boot partitions, we return the first region that is large enough to hold the partition. Partition type (parted's PARTITION_NORMAL, PARTITION_LOGICAL) is taken into account when locating a suitable free region. For locating the best region from among several disks, the keyword argument best_free allows the specification of a current "best" free region with which to compare the best from this disk. The overall best region is returned. Arguments: disk -- the disk (a parted.Disk instance) part_type -- the type of partition we want to allocate (one of parted's partition type constants) req_size -- the requested size of the partition (in MB) Keyword arguments: boot -- indicates whether this will be a bootable partition (boolean) best_free -- current best free region for this partition grow -- indicates whether this is a growable request """ log.debug("getBestFreeSpaceRegion: disk=%s part_type=%d req_size=%dMB " "boot=%s best=%s grow=%s" % (disk.device.path, part_type, req_size, boot, best_free, grow)) extended = disk.getExtendedPartition() for _range in disk.getFreeSpaceRegions(): if extended: # find out if there is any overlap between this region and the # extended partition log.debug("looking for intersection between extended (%d-%d) and free (%d-%d)" % (extended.geometry.start, extended.geometry.end, _range.start, _range.end)) # parted.Geometry.overlapsWith can handle this try: free_geom = extended.geometry.intersect(_range) except ArithmeticError, e: # this freespace region does not lie within the extended # partition's geometry free_geom = None if (free_geom and part_type == parted.PARTITION_NORMAL) or \ (not free_geom and part_type == parted.PARTITION_LOGICAL): log.debug("free region not suitable for request") continue if part_type == parted.PARTITION_NORMAL: # we're allocating a primary and the region is not within # the extended, so we use the original region free_geom = _range else: free_geom = _range log.debug("current free range is %d-%d (%dMB)" % (free_geom.start, free_geom.end, free_geom.getSize())) free_size = free_geom.getSize() # For boot partitions, we want the first suitable region we find. # For growable or extended partitions, we want the largest possible # free region. # For all others, we want the smallest suitable free region. if grow or part_type == parted.PARTITION_EXTENDED: op = gt else: op = lt if req_size <= free_size: if not best_free or op(free_geom.length, best_free.length): best_free = free_geom if boot: # if this is a bootable partition we want to # use the first freespace region large enough # to satisfy the request break return best_free def sectorsToSize(sectors, sectorSize): """ Convert length in sectors to size in MB. Arguments: sectors - sector count sectorSize - sector size for the device, in bytes """ return (sectors * sectorSize) / (1024.0 * 1024.0) def sizeToSectors(size, sectorSize): """ Convert size in MB to length in sectors. Arguments: size - size in MB sectorSize - sector size for the device, in bytes """ return (size * 1024.0 * 1024.0) / sectorSize def removeNewPartitions(disks, partitions): """ Remove newly added input partitions from input disks. Arguments: disks -- list of StorageDevice instances with DiskLabel format partitions -- list of PartitionDevice instances """ log.debug("removing all non-preexisting partitions %s from disk(s) %s" % (["%s(id %d)" % (p.name, p.id) for p in partitions if not p.exists], [d.name for d in disks])) for part in partitions: if part.partedPartition and part.disk in disks: if part.exists: # we're only removing partitions that don't physically exist continue if part.isExtended: # these get removed last continue part.disk.format.partedDisk.removePartition(part.partedPartition) part.partedPartition = None part.disk = None for disk in disks: # remove empty extended so it doesn't interfere extended = disk.format.extendedPartition if extended and not disk.format.logicalPartitions: log.debug("removing empty extended partition from %s" % disk.name) disk.format.partedDisk.removePartition(extended) def addPartition(disklabel, free, part_type, size): """ Return new partition after adding it to the specified disk. Arguments: disklabel -- disklabel instance to add partition to free -- where to add the partition (parted.Geometry instance) part_type -- partition type (parted.PARTITION_* constant) size -- size (in MB) of the new partition The new partition will be aligned. Return value is a parted.Partition instance. """ start = free.start if not disklabel.alignment.isAligned(free, start): start = disklabel.alignment.alignNearest(free, start) if part_type == parted.PARTITION_LOGICAL: # make room for logical partition's metadata start += disklabel.alignment.grainSize if start != free.start: log.debug("adjusted start sector from %d to %d" % (free.start, start)) if part_type == parted.PARTITION_EXTENDED: end = free.end length = end - start + 1 else: # size is in MB length = sizeToSectors(size, disklabel.partedDevice.sectorSize) end = start + length - 1 if not disklabel.endAlignment.isAligned(free, end): end = disklabel.endAlignment.alignNearest(free, end) log.debug("adjusted length from %d to %d" % (length, end - start + 1)) new_geom = parted.Geometry(device=disklabel.partedDevice, start=start, end=end) max_length = disklabel.partedDisk.maxPartitionLength if max_length and new_geom.length > max_length: raise PartitioningError("requested size exceeds maximum allowed") # create the partition and add it to the disk partition = parted.Partition(disk=disklabel.partedDisk, type=part_type, geometry=new_geom) constraint = parted.Constraint(exactGeom=new_geom) disklabel.partedDisk.addPartition(partition=partition, constraint=constraint) return partition def getFreeRegions(disks): """ Return a list of free regions on the specified disks. Arguments: disks -- list of parted.Disk instances Return value is a list of unaligned parted.Geometry instances. """ free = [] for disk in disks: for f in disk.format.partedDisk.getFreeSpaceRegions(): if f.length > 0: free.append(f) return free def doPartitioning(storage, exclusiveDisks=None): """ Allocate and grow partitions. When this function returns without error, all PartitionDevice instances must have their parents set to the disk they are allocated on, and their partedPartition attribute set to the appropriate parted.Partition instance from their containing disk. All req_xxxx attributes must be unchanged. Arguments: storage - Main anaconda Storage instance Keyword arguments: exclusiveDisks -- list of names of disks to use """ anaconda = storage.anaconda disks = storage.partitioned if exclusiveDisks: disks = [d for d in disks if d.name in exclusiveDisks] for disk in disks: disk.setup() partitions = storage.partitions[:] for part in storage.partitions: part.req_bootable = False if part.exists or \ (storage.deviceImmutable(part) and part.partedPartition): # if the partition is preexisting or part of a complex device # then we shouldn't modify it partitions.remove(part) continue if not part.exists: # start over with flexible-size requests part.req_size = part.req_base_size # FIXME: isn't there a better place for this to happen? try: bootDev = anaconda.platform.bootDevice() except DeviceError: bootDev = None if bootDev: bootDev.req_bootable = True # turn off cylinder alignment for partedDisk in [d.format.partedDisk for d in disks]: if partedDisk.isFlagAvailable(parted.DISK_CYLINDER_ALIGNMENT): partedDisk.unsetFlag(parted.DISK_CYLINDER_ALIGNMENT) removeNewPartitions(disks, partitions) free = getFreeRegions(disks) allocatePartitions(storage, disks, partitions, free) growPartitions(disks, partitions, free) # The number and thus the name of partitions may have changed now, # allocatePartitions() takes care of this for new partitions, but not # for pre-existing ones, so we update the name of all partitions here for part in storage.partitions: # needed because of XXX hack below if part.isExtended: continue part.updateName() # XXX hack -- if we created any extended partitions we need to add # them to the tree now for disk in disks: extended = disk.format.extendedPartition if not extended: # remove any obsolete extended partitions for part in storage.partitions: if part.disk == disk and part.isExtended: storage.devicetree._removeDevice(part, moddisk=False) continue extendedName = devicePathToName(extended.getDeviceNodeName()) # remove any obsolete extended partitions for part in storage.partitions: if part.disk == disk and part.isExtended and \ part.name != extendedName: storage.devicetree._removeDevice(part, moddisk=False) device = storage.devicetree.getDeviceByName(extendedName) if device: if not device.exists: # created by us, update partedPartition device.partedPartition = extended continue # This is a little odd because normally instantiating a partition # that does not exist means leaving self.parents empty and instead # populating self.req_disks. In this case, we need to skip past # that since this partition is already defined. device = PartitionDevice(extendedName, parents=disk) device.parents = [disk] device.partedPartition = extended # just add the device for now -- we'll handle actions at the last # moment to simplify things storage.devicetree._addDevice(device) def allocatePartitions(storage, disks, partitions, freespace): """ Allocate partitions based on requested features. Non-existing partitions are sorted according to their requested attributes, and then allocated. The basic approach to sorting is that the more specifically- defined a request is, the earlier it will be allocated. See the function partitionCompare for details on the sorting criteria. The PartitionDevice instances will have their name and parents attributes set once they have been allocated. """ log.debug("allocatePartitions: disks=%s ; partitions=%s" % ([d.name for d in disks], ["%s(id %d)" % (p.name, p.id) for p in partitions])) new_partitions = [p for p in partitions if not p.exists] new_partitions.sort(cmp=partitionCompare) # the following dicts all use device path strings as keys disklabels = {} # DiskLabel instances for each disk all_disks = {} # StorageDevice for each disk for disk in disks: if disk.path not in disklabels.keys(): disklabels[disk.path] = disk.format all_disks[disk.path] = disk removeNewPartitions(disks, new_partitions) for _part in new_partitions: if _part.partedPartition and _part.isExtended: # ignore new extendeds as they are implicit requests continue # obtain the set of candidate disks req_disks = [] if _part.disk: # we have a already selected a disk for this request req_disks = [_part.disk] elif _part.req_disks: # use the requested disk set req_disks = _part.req_disks else: # no disks specified means any disk will do req_disks = disks req_disks.sort(key=lambda d: d.name, cmp=storage.compareDisks) log.debug("allocating partition: %s ; id: %d ; disks: %s ;\n" "boot: %s ; primary: %s ; size: %dMB ; grow: %s ; " "max_size: %s" % (_part.name, _part.id, req_disks, _part.req_bootable, _part.req_primary, _part.req_size, _part.req_grow, _part.req_max_size)) free = None use_disk = None part_type = None growth = 0 # loop through disks for _disk in req_disks: disklabel = disklabels[_disk.path] sectorSize = disklabel.partedDevice.sectorSize best = None current_free = free # for growable requests, we don't want to pass the current free # geometry to getBestFreeRegion -- this allows us to try the # best region from each disk and choose one based on the total # growth it allows if _part.req_grow: current_free = None log.debug("checking freespace on %s" % _disk.name) new_part_type = getNextPartitionType(disklabel.partedDisk) if new_part_type is None: # can't allocate any more partitions on this disk log.debug("no free partition slots on %s" % _disk.name) continue if _part.req_primary and new_part_type != parted.PARTITION_NORMAL: if (disklabel.partedDisk.primaryPartitionCount < disklabel.partedDisk.maxPrimaryPartitionCount): # don't fail to create a primary if there are only three # primary partitions on the disk (#505269) new_part_type = parted.PARTITION_NORMAL else: # we need a primary slot and none are free on this disk log.debug("no primary slots available on %s" % _disk.name) continue best = getBestFreeSpaceRegion(disklabel.partedDisk, new_part_type, _part.req_size, best_free=current_free, boot=_part.req_bootable, grow=_part.req_grow) if best == free and not _part.req_primary and \ new_part_type == parted.PARTITION_NORMAL: # see if we can do better with a logical partition log.debug("not enough free space for primary -- trying logical") new_part_type = getNextPartitionType(disklabel.partedDisk, no_primary=True) if new_part_type: best = getBestFreeSpaceRegion(disklabel.partedDisk, new_part_type, _part.req_size, best_free=current_free, boot=_part.req_bootable, grow=_part.req_grow) if best and free != best: update = True if _part.req_grow: log.debug("evaluating growth potential for new layout") new_growth = 0 for disk_path in disklabels.keys(): log.debug("calculating growth for disk %s" % disk_path) # Now we check, for growable requests, which of the two # free regions will allow for more growth. # set up chunks representing the disks' layouts temp_parts = [] for _p in new_partitions[:new_partitions.index(_part)]: if _p.disk.path == disk_path: temp_parts.append(_p) # add the current request to the temp disk to set up # its partedPartition attribute with a base geometry if disk_path == _disk.path: temp_part = addPartition(disklabel, best, new_part_type, _part.req_size) _part.partedPartition = temp_part _part.disk = _disk temp_parts.append(_part) chunks = getDiskChunks(all_disks[disk_path], temp_parts, freespace) # grow all growable requests disk_growth = 0 disk_sector_size = disklabels[disk_path].partedDevice.sectorSize for chunk in chunks: chunk.growRequests() # record the growth for this layout new_growth += chunk.growth disk_growth += chunk.growth for req in chunk.requests: log.debug("request %d (%s) growth: %d (%dMB) " "size: %dMB" % (req.partition.id, req.partition.name, req.growth, sectorsToSize(req.growth, disk_sector_size), sectorsToSize(req.growth + req.base, disk_sector_size))) log.debug("disk %s growth: %d (%dMB)" % (disk_path, disk_growth, sectorsToSize(disk_growth, disk_sector_size))) disklabel.partedDisk.removePartition(temp_part) _part.partedPartition = None _part.disk = None log.debug("total growth: %d sectors" % new_growth) # update the chosen free region unless the previous # choice yielded greater total growth if new_growth < growth: log.debug("keeping old free: %d < %d" % (new_growth, growth)) update = False else: growth = new_growth if update: # now we know we are choosing a new free space, # so update the disk and part type log.debug("updating use_disk to %s (%s), type: %s" % (_disk, _disk.name, new_part_type)) part_type = new_part_type use_disk = _disk log.debug("new free: %s (%d-%d / %dMB)" % (best, best.start, best.end, best.getSize())) log.debug("new free allows for %d sectors of growth" % growth) free = best # For platforms with a fake boot partition (like Apple Bootstrap or # PReP) and multiple disks, we need to ensure the /boot partition # ends up on the same disk as the fake one. mountpoint = getattr(_part.format, "mountpoint", "") if not mountpoint: mountpoint = "" if free and (_part.req_bootable or mountpoint.startswith("/boot")): # if this is a bootable partition we want to # use the first freespace region large enough # to satisfy the request log.debug("found free space for bootable request") break if free is None: raise PartitioningError("not enough free space on disks") _disk = use_disk disklabel = _disk.format # create the extended partition if needed if part_type == parted.PARTITION_EXTENDED: log.debug("creating extended partition") addPartition(disklabel, free, part_type, None) # now the extended partition exists, so set type to logical part_type = parted.PARTITION_LOGICAL # recalculate freespace log.debug("recalculating free space") free = getBestFreeSpaceRegion(disklabel.partedDisk, part_type, _part.req_size, boot=_part.req_bootable, grow=_part.req_grow) if not free: raise PartitioningError("not enough free space after " "creating extended partition") partition = addPartition(disklabel, free, part_type, _part.req_size) log.debug("created partition %s of %dMB and added it to %s" % (partition.getDeviceNodeName(), partition.getSize(), disklabel.device)) # this one sets the name _part.partedPartition = partition _part.disk = _disk # parted modifies the partition in the process of adding it to # the disk, so we need to grab the latest version... _part.partedPartition = disklabel.partedDisk.getPartitionByPath(_part.path) class Request(object): """ A partition request. Request instances are used for calculating how much to grow partitions. """ def __init__(self, partition): """ Create a Request instance. Arguments: partition -- a PartitionDevice instance """ self.partition = partition # storage.devices.PartitionDevice self.growth = 0 # growth in sectors self.max_growth = 0 # max growth in sectors self.done = not partition.req_grow # can we grow this request more? self.base = partition.partedPartition.geometry.length # base sectors sector_size = partition.partedPartition.disk.device.sectorSize if partition.req_grow: limits = filter(lambda l: l > 0, [sizeToSectors(partition.req_max_size, sector_size), sizeToSectors(partition.format.maxSize, sector_size), partition.partedPartition.disk.maxPartitionLength]) if limits: max_sectors = min(limits) self.max_growth = max_sectors - self.base @property def growable(self): """ True if this request is growable. """ return self.partition.req_grow @property def id(self): """ The id of the PartitionDevice this request corresponds to. """ return self.partition.id def __str__(self): s = ("%(type)s instance --\n" "id = %(id)s name = %(name)s growable = %(growable)\n" "base = %(base)d growth = %(grow)d max_grow = %(max_grow)d\n" "done = %(done)s" % {"type": self.__class__.__name__, "id": self.id, "name": self.partition.name, "growable": self.growable, "base": self.base, "growth": self.growth, "max_grow": self.max_growth, "done": self.done}) return s class Chunk(object): """ A free region on disk from which partitions will be allocated """ def __init__(self, geometry, requests=None): """ Create a Chunk instance. Arguments: geometry -- parted.Geometry instance describing the free space Keyword Arguments: requests -- list of Request instances allocated from this chunk """ self.geometry = geometry # parted.Geometry self.pool = self.geometry.length # free sector count self.sectorSize = self.geometry.device.sectorSize self.base = 0 # sum of growable requests' base # sizes, in sectors self.requests = [] # list of Request instances if isinstance(requests, list): for req in requests: self.addRequest(req) def __str__(self): s = ("%(type)s instance --\n" "device = %(device)s start = %(start)d end = %(end)d\n" "length = %(length)d size = %(size)d pool = %(pool)d\n" "remaining = %(rem)d sectorSize = %(sectorSize)d" % {"type": self.__class__.__name__, "device": self.geometry.device.path, "start": self.geometry.start, "end": self.geometry.end, "length": self.geometry.length, "size": self.geometry.getSize(), "pool": self.pool, "rem": self.remaining, "sectorSize": self.sectorSize}) return s def addRequest(self, req): """ Add a Request to this chunk. """ log.debug("adding request %d to chunk %s" % (req.partition.id, self)) self.requests.append(req) self.pool -= req.base if not req.done: self.base += req.base def getRequestByID(self, id): """ Retrieve a request from this chunk based on its id. """ for request in self.requests: if request.id == id: return request @property def growth(self): """ Sum of growth in sectors for all requests in this chunk. """ return sum(r.growth for r in self.requests) @property def hasGrowable(self): """ True if this chunk contains at least one growable request. """ for req in self.requests: if req.growable: return True return False @property def remaining(self): """ Number of requests still being grown in this chunk. """ return len([d for d in self.requests if not d.done]) @property def done(self): """ True if we are finished growing all requests in this chunk. """ return self.remaining == 0 def trimOverGrownRequest(self, req, base=None): """ Enforce max growth and return extra sectors to the pool. """ if req.max_growth and req.growth >= req.max_growth: if req.growth > req.max_growth: # we've grown beyond the maximum. put some back. extra = req.growth - req.max_growth log.debug("taking back %d (%dMB) from %d (%s)" % (extra, sectorsToSize(extra, self.sectorSize), req.partition.id, req.partition.name)) self.pool += extra req.growth = req.max_growth # We're done growing this partition, so it no longer # factors into the growable base used to determine # what fraction of the pool each request gets. if base is not None: base -= req.base req.done = True return base def growRequests(self): """ Calculate growth amounts for requests in this chunk. """ log.debug("Chunk.growRequests: %s" % self) # sort the partitions by start sector self.requests.sort(key=lambda r: r.partition.partedPartition.geometry.start) # we use this to hold the base for the next loop through the # chunk's requests since we want the base to be the same for # all requests in any given growth iteration new_base = self.base last_pool = 0 # used to track changes to the pool across iterations while not self.done and self.pool and last_pool != self.pool: last_pool = self.pool # to keep from getting stuck self.base = new_base log.debug("%d partitions and %d (%dMB) left in chunk" % (self.remaining, self.pool, sectorsToSize(self.pool, self.sectorSize))) for p in self.requests: if p.done: continue # Each partition is allocated free sectors from the pool # based on the relative _base_ sizes of the remaining # growable partitions. share = p.base / float(self.base) growth = int(share * last_pool) # truncate, don't round p.growth += growth self.pool -= growth log.debug("adding %d (%dMB) to %d (%s)" % (growth, sectorsToSize(growth, self.sectorSize), p.partition.id, p.partition.name)) new_base = self.trimOverGrownRequest(p, base=new_base) log.debug("new grow amount for partition %d (%s) is %d " "sectors, or %dMB" % (p.partition.id, p.partition.name, p.growth, sectorsToSize(p.growth, self.sectorSize))) if self.pool: # allocate any leftovers in pool to the first partition # that can still grow for p in self.requests: if p.done: continue p.growth += self.pool self.pool = 0 self.trimOverGrownRequest(p) if self.pool == 0: break def getDiskChunks(disk, partitions, free): """ Return a list of Chunk instances representing a disk. Arguments: disk -- a StorageDevice with a DiskLabel format partitions -- list of PartitionDevice instances free -- list of parted.Geometry instances representing free space Partitions and free regions not on the specified disk are ignored. """ # list of all new partitions on this disk disk_parts = [p for p in partitions if p.disk == disk and not p.exists] disk_free = [f for f in free if f.device.path == disk.path] chunks = [Chunk(f) for f in disk_free] for p in disk_parts: if p.isExtended: # handle extended partitions specially since they are # indeed very special continue for i, f in enumerate(disk_free): if f.contains(p.partedPartition.geometry): chunks[i].addRequest(Request(p)) break return chunks def growPartitions(disks, partitions, free): """ Grow all growable partition requests. Partitions have already been allocated from chunks of free space on the disks. This function does not modify the ordering of partitions or the free chunks from which they are allocated. Free space within a given chunk is allocated to each growable partition allocated from that chunk in an amount corresponding to the ratio of that partition's base size to the sum of the base sizes of all growable partitions allocated from the chunk. Arguments: disks -- a list of all usable disks (DiskDevice instances) partitions -- a list of all partitions (PartitionDevice instances) free -- a list of all free regions (parted.Geometry instances) """ log.debug("growPartitions: disks=%s, partitions=%s" % ([d.name for d in disks], ["%s(id %d)" % (p.name, p.id) for p in partitions])) all_growable = [p for p in partitions if p.req_grow] if not all_growable: log.debug("no growable partitions") return log.debug("growable partitions are %s" % [p.name for p in all_growable]) for disk in disks: log.debug("growing partitions on %s" % disk.name) sector_size = disk.format.partedDevice.sectorSize # find any extended partition on this disk extended_geometry = getattr(disk.format.extendedPartition, "geometry", None) # parted.Geometry # list of free space regions on this disk prior to partition allocation disk_free = [f for f in free if f.device.path == disk.path] if not disk_free: log.debug("no free space on %s" % disk.name) continue chunks = getDiskChunks(disk, partitions, disk_free) log.debug("disk %s has %d chunks" % (disk.name, len(chunks))) # grow the partitions in each chunk as a group for chunk in chunks: if not chunk.hasGrowable: # no growable partitions in this chunk continue chunk.growRequests() # recalculate partition geometries disklabel = disk.format start = chunk.geometry.start new_partitions = [] for p in chunk.requests: ptype = p.partition.partedPartition.type log.debug("partition %s (%d): %s" % (p.partition.name, p.partition.id, ptype)) if ptype == parted.PARTITION_EXTENDED: continue # XXX since we need one metadata sector before each # logical partition we burn one logical block to # safely align the start of each logical partition if ptype == parted.PARTITION_LOGICAL: start += disklabel.alignment.grainSize old_geometry = p.partition.partedPartition.geometry new_length = p.base + p.growth end = start + new_length - 1 # align end sector as needed if not disklabel.endAlignment.isAligned(chunk.geometry, end): end = disklabel.endAlignment.alignDown(chunk.geometry, end) new_geometry = parted.Geometry(device=disklabel.partedDevice, start=start, end=end) log.debug("new geometry for %s: %s" % (p.partition.name, new_geometry)) start = end + 1 new_partition = parted.Partition(disk=disklabel.partedDisk, type=ptype, geometry=new_geometry) new_partitions.append((new_partition, p.partition)) # remove all new partitions from this chunk removeNewPartitions([disk], [r.partition for r in chunk.requests]) log.debug("back from removeNewPartitions") # adjust the extended partition as needed # we will ony resize an extended partition that we created log.debug("extended: %s" % extended_geometry) if extended_geometry and \ chunk.geometry.contains(extended_geometry): log.debug("setting up new geometry for extended on %s" % disk.name) ext_start = 0 ext_end = 0 for (partition, device) in new_partitions: if partition.type != parted.PARTITION_LOGICAL: continue if not ext_start or partition.geometry.start < ext_start: # account for the logical block difference in start # sector for the extended -v- first logical # (partition.geometry.start is already aligned) ext_start = partition.geometry.start - disklabel.alignment.grainSize if not ext_end or partition.geometry.end > ext_end: ext_end = partition.geometry.end new_geometry = parted.Geometry(device=disklabel.partedDevice, start=ext_start, end=ext_end) log.debug("new geometry for extended: %s" % new_geometry) new_extended = parted.Partition(disk=disklabel.partedDisk, type=parted.PARTITION_EXTENDED, geometry=new_geometry) ptypes = [p.type for (p, d) in new_partitions] for pt_idx, ptype in enumerate(ptypes): if ptype == parted.PARTITION_LOGICAL: new_partitions.insert(pt_idx, (new_extended, None)) break # add the partitions with their new geometries to the disk for (partition, device) in new_partitions: if device: name = device.name else: # If there was no extended partition on this disk when # doPartitioning was called we won't have a # PartitionDevice instance for it. name = partition.getDeviceNodeName() log.debug("setting %s new geometry: %s" % (name, partition.geometry)) constraint = parted.Constraint(exactGeom=partition.geometry) disklabel.partedDisk.addPartition(partition=partition, constraint=constraint) path = partition.path if device: # set the device's name device.partedPartition = partition # without this, the path attr will be a basename. eek. device.disk = disk # make sure we store the disk's version of the partition newpart = disklabel.partedDisk.getPartitionByPath(path) device.partedPartition = newpart def hasFreeDiskSpace(storage, exclusiveDisks=None): """Returns True if there is at least 100Mb of free usable space in any of the disks. False otherwise. """ # FIXME: This function needs to be implemented. It is used, at least, by # iw/partition_gui.py. It should be implemented after the new # doPartitioning code is commited for fedora 13. Since it returns True # the user will always be able to access the create partition screen. If # no partition can be created, the user will go back to the previous # storage state after seeing a warning message. return True def lvCompare(lv1, lv2): """ More specifically defined lvs come first. < 1 => x < y 0 => x == y > 1 => x > y """ ret = 0 # larger requests go to the front of the list ret -= cmp(lv1.size, lv2.size) * 100 # fixed size requests to the front ret += cmp(lv1.req_grow, lv2.req_grow) * 50 # potentially larger growable requests go to the front if lv1.req_grow and lv2.req_grow: if not lv1.req_max_size and lv2.req_max_size: ret -= 25 elif lv1.req_max_size and not lv2.req_max_size: ret += 25 else: ret -= cmp(lv1.req_max_size, lv2.req_max_size) * 25 if ret > 0: ret = 1 elif ret < 0: ret = -1 return ret def growLVM(storage): """ Grow LVs according to the sizes of the PVs. """ for vg in storage.vgs: total_free = vg.freeSpace if total_free < 0: # by now we have allocated the PVs so if there isn't enough # space in the VG we have a real problem raise PartitioningError("not enough space for LVM requests") elif not total_free: log.debug("vg %s has no free space" % vg.name) continue log.debug("vg %s: %dMB free ; lvs: %s" % (vg.name, vg.freeSpace, [l.lvname for l in vg.lvs])) # figure out how much to grow each LV grow_amounts = {} lv_total = vg.size - total_free log.debug("used: %dMB ; vg.size: %dMB" % (lv_total, vg.size)) # This first loop is to calculate percentage-based growth # amounts. These are based on total free space. lvs = vg.lvs lvs.sort(cmp=lvCompare) for lv in lvs: if not lv.req_grow or not lv.req_percent: continue portion = (lv.req_percent * 0.01) grow = portion * vg.vgFree new_size = lv.req_size + grow if lv.req_max_size and new_size > lv.req_max_size: grow -= (new_size - lv.req_max_size) if lv.format.maxSize and lv.format.maxSize < new_size: grow -= (new_size - lv.format.maxSize) # clamp growth amount to a multiple of vg extent size grow_amounts[lv.name] = vg.align(grow) total_free -= grow lv_total += grow # This second loop is to calculate non-percentage-based growth # amounts. These are based on free space remaining after # calculating percentage-based growth amounts. # keep a tab on space not allocated due to format or requested # maximums -- we'll dole it out to subsequent requests leftover = 0 for lv in lvs: log.debug("checking lv %s: req_grow: %s ; req_percent: %s" % (lv.name, lv.req_grow, lv.req_percent)) if not lv.req_grow or lv.req_percent: continue portion = float(lv.req_size) / float(lv_total) grow = portion * total_free log.debug("grow is %dMB" % grow) todo = lvs[lvs.index(lv):] unallocated = reduce(lambda x,y: x+y, [l.req_size for l in todo if l.req_grow and not l.req_percent]) extra_portion = float(lv.req_size) / float(unallocated) extra = extra_portion * leftover log.debug("%s getting %dMB (%d%%) of %dMB leftover space" % (lv.name, extra, extra_portion * 100, leftover)) leftover -= extra grow += extra log.debug("grow is now %dMB" % grow) max_size = lv.req_size + grow if lv.req_max_size and max_size > lv.req_max_size: max_size = lv.req_max_size if lv.format.maxSize and max_size > lv.format.maxSize: max_size = lv.format.maxSize log.debug("max size is %dMB" % max_size) max_size = max_size leftover += (lv.req_size + grow) - max_size grow = max_size - lv.req_size log.debug("lv %s gets %dMB" % (lv.name, vg.align(grow))) grow_amounts[lv.name] = vg.align(grow) if not grow_amounts: log.debug("no growable lvs in vg %s" % vg.name) continue # now grow the lvs by the amounts we've calculated above for lv in lvs: if lv.name not in grow_amounts.keys(): continue lv.size += grow_amounts[lv.name] # now there shouldn't be any free space left, but if there is we # should allocate it to one of the LVs vg_free = vg.freeSpace log.debug("vg %s has %dMB free" % (vg.name, vg_free)) if vg_free: for lv in lvs: if not lv.req_grow: continue if lv.req_max_size and lv.size == lv.req_max_size: continue if lv.format.maxSize and lv.size == lv.format.maxSize: continue # first come, first served projected = lv.size + vg.freeSpace if lv.req_max_size and projected > lv.req_max_size: projected = lv.req_max_size if lv.format.maxSize and projected > lv.format.maxSize: projected = lv.format.maxSize log.debug("giving leftover %dMB to %s" % (projected - lv.size, lv.name)) lv.size = projected