---
dmraid.py | 9 -
partedUtils.py | 917 --------------------------------------------------------
2 files changed, 0 insertions(+), 926 deletions(-)
diff --git a/dmraid.py b/dmraid.py
index 58aa559..8d07116 100644
--- a/dmraid.py
+++ b/dmraid.py
@@ -34,7 +34,6 @@ if not _bdModulePath in oldPath:
block.setBdevidPath(_bdModulePath + oldPath)
del oldPath
-import partedUtils
import raid
from flags import flags
@@ -228,14 +227,6 @@ def register_raid_device(dmname, newdevices, newlevel, newnumActive):
"""Register a new RAID device in the dmlist."""
raise NotImplementedError
-def lookup_raid_device(dmname):
- """Return the requested RAID device information."""
- for rs, parent, devices, level, nrDisks, totalDisks in \
- partedUtils.DiskSet.dmList:
- if dmname == rs.name:
- return (rs.name, devices, level, totalDisks)
- raise KeyError, "dm device not found"
-
def scanForMPath(drives):
log.debug("scanning for multipath on drives %s" % (drives,))
mpaths = []
diff --git a/partedUtils.py b/partedUtils.py
index dde4d0b..dd76336 100644
--- a/partedUtils.py
+++ b/partedUtils.py
@@ -45,79 +45,6 @@ log = logging.getLogger("anaconda")
import gettext
_ = lambda x: gettext.ldgettext("anaconda", x)
-def get_partition_file_system_type(part):
- """Return the file system type of the parted.Partition part.
-
- Arguments:
- part -- parted.Partition object
-
- Return:
- Filesystem object (as defined in fsset.py)
- """
- if part.fileSystem is None and part.getFlag(parted.PARTITION_PREP):
- ptype = fsset.fileSystemTypeGet("PPC PReP Boot")
- elif part.fileSystem is None:
- return None
- elif (part.getFlag(parted.PARTITION_BOOT) and
- part.getSize(unit="MB") <= 1 and part.fileSystem.type == "hfs"):
- ptype = fsset.fileSystemTypeGet("Apple Bootstrap")
- elif part.fileSystem.type == "linux-swap":
- ptype = fsset.fileSystemTypeGet("swap")
- elif isEfiSystemPartition(part):
- ptype = fsset.fileSystemTypeGet("efi")
- elif isEfiSystemPartition(part):
- ptype = fsset.fileSystemTypeGet("efi")
- elif part.fileSystem.type in ("fat16", "fat32"):
- ptype = fsset.fileSystemTypeGet("vfat")
- else:
- try:
- ptype = fsset.fileSystemTypeGet(part.fileSystem.type)
- except:
- ptype = fsset.fileSystemTypeGet("foreign")
-
- return ptype
-
-
-def set_partition_file_system_type(part, fstype):
- """Set partition type of part to PedFileSystemType implied by fstype."""
- if fstype == None:
- return
- try:
- for flag in fstype.getPartedPartitionFlags():
- if not part.isFlagAvailable(flag):
- raise PartitioningError, ("requested file system type needs "
- "a flag that is not available.")
- part.setFlag(flag)
- if isEfiSystemPartition(part):
- part.system = parted.fileSystemType["fat32"]
- else:
- part.system = fstype.getPartedFileSystemType()
- except:
- print("Failed to set partition type to ", fstype.getName())
- pass
-
-def get_partition_drive(partition):
- """Return the device name for disk that PedPartition partition is on."""
- return partition.geometry.device.path[5:]
-
-def map_foreign_to_fsname(part):
- """Return the name associated with a foreign filesystem type."""
- if part._fileSystem:
- return part._fileSystem._type.name
- else:
- return _("None")
-
-def filter_partitions(disk, func):
- rc = []
- for part in disk.partitions:
- if func(part):
- rc.append(part)
- return rc
-
-def hasGptLabel(diskset, device):
- disk = diskset.disks[device]
- return disk.type == "gpt"
-
def isEfiSystemPartition(part):
if not part.active:
return False
@@ -127,162 +54,6 @@ def isEfiSystemPartition(part):
part.fileSystem.type in ("fat16", "fat32") and
isys.readFSLabel(part.getDeviceNodeName()) != "ANACONDA")
-def labelDisk(platform, deviceFile, forceLabelType=None):
- dev = parted.getDevice(deviceFile)
- label = platform.diskType
-
- if not forceLabelType is None:
- label = forceLabelType
- else:
- if label.name == 'msdos' and \
- dev.length > (2L**41) / dev.sectorSize and \
- 'gpt' in parted.archLabels[iutil.getArch()]:
- label = parted.diskType['gpt']
-
- disk = parted.freshDisk(dev, label)
- disk.commit()
- return disk
-
-# this is kind of crappy, but we don't really want to allow LDL formatted
-# dasd to be used during the install
-def checkDasdFmt(disk, intf):
- if not iutil.isS390():
- return 0
-
- if disk.type != "dasd":
- return 0
-
- # FIXME: there has to be a better way to check LDL vs CDL
- # how do I test ldl vs cdl?
- if disk.maxPrimaryPartitionCount > 1:
- return 0
-
- if intf:
- try:
- device = disk.device.path[5:]
- devs = isys.getDasdDevPort()
- dev = "/dev/%s (%s)" %(device, devs[device])
- except Exception, e:
- log.critical("exception getting dasd dev ports: %s" %(e,))
- dev = "/dev/%s" %(disk.device.path[5:],)
-
- rc = intf.messageWindow(_("Warning"),
- _("The device %s is LDL formatted instead of "
- "CDL formatted. LDL formatted DASDs are not "
- "supported for usage during an install of %s. "
- "If you wish to use this disk for installation, "
- "it must be re-initialized causing the loss of "
- "ALL DATA on this drive.\n\n"
- "Would you like to reformat this DASD using CDL "
- "format?")
- %(dev, productName), type = "yesno")
- if rc == 0:
- return 1
- else:
- return -1
- else:
- return 1
-
-
-def checkDiskLabel(disk, intf):
- """Check that the disk label on disk is valid for this machine type."""
- arch = iutil.getArch()
- if arch in parted.archLabels.keys():
- if disk.type in parted.archLabels[arch]:
- # this is kind of a hack since we don't want LDL to be used
- return checkDasdFmt(disk, intf)
- else:
- if disk.type == "msdos":
- return 0
-
- if intf:
- rc = intf.messageWindow(_("Warning"),
- _("/dev/%s currently has a %s partition "
- "layout. To use this drive for "
- "the installation of %s, it must be "
- "re-initialized, causing the loss of "
- "ALL DATA on this drive.\n\n"
- "Would you like to re-initialize this "
- "drive?")
- %(disk.device.path[5:], disk.type,
- productName), type="custom",
- custom_buttons = [ _("_Ignore drive"),
- _("_Re-initialize drive") ],
- custom_icon="question")
-
- if rc == 0:
- return 1
- else:
- return -1
- else:
- return 1
-
-def hasProtectedPartitions(drive, anaconda):
- rc = False
- if anaconda is None:
- return rc
-
- try:
- for protected in anaconda.id.storage.protectedPartitions:
- if protected.startswith(drive):
- part = protected[len(drive):]
- if part[0] == "p":
- part = part[1:]
- if part.isdigit():
- rc = True
- break
- except:
- pass
-
- return rc
-
-# attempt to associate a parted filesystem type on a partition that
-# didn't probe as one type or another.
-def validateFsType(part):
- # we only care about primary and logical partitions
- if not part.type in (parted.PARTITION_NORMAL,
- parted.PARTITION_LOGICAL):
- return
-
- if part.getFlag(parted.PARTITION_LVM) or part.getFlag(parted.PARTITION_RAID):
- return
-
- # if the partition already has a type, no need to search
- if part.fileSystem:
- return
-
- # first fsystem to probe wins, so sort the types into a preferred
- # order.
- fsnames = parted.fileSystemType.keys()
- goodTypes = ['ext3', 'ext2']
- badTypes = ['linux-swap',]
- for fstype in goodTypes:
- fsnames.remove(fstype)
- fsnames = goodTypes + fsnames
- for fstype in badTypes:
- fsnames.remove(fstype)
- fsnames.extend(badTypes)
-
- # now check each type, and set the partition system accordingly.
- for fsname in fsnames:
- fstype = parted.fileSystemType[fsname]
- try:
- parted.probeForSpecificFileSystem(fstype.name, part.geometry)
- # XXX verify that this will not modify system type
- # in the case where a user does not modify partitions
- part.system = fstype
- return
- except (parted.FileSystemException, parted.IOException):
- pass
-
-def isLinuxNative(part):
- """Check if the type is a 'Linux native' filesystem."""
- if part.getFlag(parted.PARTITION_RAID) or part.getFlag(parted.PARTITION_LVM) or \
- part.getFlag(parted.PARTITION_SWAP) or map_foreign_to_fsname(part) in ["ext2", "ext3", "jfs", "reiserfs", "xfs"]:
- return True
- else:
- return False
-
class DiskSet:
"""The disks in the system."""
@@ -300,13 +71,6 @@ class DiskSet:
self.anaconda = anaconda
self.devicesOpen = False
- def onlyPrimaryParts(self):
- for disk in self.disks.values():
- if disk.supportsFeature(parted.DISK_TYPE_EXTENDED):
- return 0
-
- return 1
-
def startMPath(self):
"""Start all of the dm multipath devices associated with the DiskSet."""
@@ -398,689 +162,8 @@ class DiskSet:
while DiskSet.mdList:
DiskSet.mdList.pop()
- def getInfo(self, readFn=lambda d: isys.readFSLabel(d)):
- """Return a dict keyed on device name, storing some sort of data
- about each device. This is typially going to be labels or UUIDs,
- as required by readFstab.
- """
- ret = {}
-
- encryptedDevices = self.anaconda.id.partitions.encryptedDevices
-
- for drive in self.driveList():
- # Don't read labels from drives we cleared using clearpart, as
- # we don't actually remove the existing filesystems so those
- # labels will still be present (#209291).
- if drive in DiskSet.skippedDisks:
- continue
-
- # ignoredisk takes precedence over clearpart (#186438).
- if DiskSet.exclusiveDisks != [] and \
- drive not in DiskSet.exclusiveDisks:
- continue
-
- disk = self.disks[drive]
- func = lambda part: (part.active and
- not (part.getFlag(parted.PARTITION_RAID)
- or part.getFlag(parted.PARTITION_LVM)))
- parts = filter_partitions(disk, func)
- for part in parts:
- node = part.getDeviceNodeName()
- crypto = encryptedDevices.get(node)
- if crypto and not crypto.openDevice():
- node = crypto.getDevice()
-
- val = readFn(node)
- if val:
- ret[node] = val
-
- if crypto:
- crypto.closeDevice()
-
- # not doing this right now, because we should _always_ have a
- # partition table of some kind on dmraid.
- #if False:
- # for rs in DiskSet.dmList or [] + DiskSet.mpList or []:
- # label = isys.readFSLabel(rs.name)
- # if label:
- # labels[rs.name] = label
-
- for dev, devices, level, numActive in DiskSet.mdList:
- crypto = encryptedDevices.get(dev)
- if crypto and not crypto.openDevice():
- dev = crypto.getDevice()
-
- val = readFn(dev)
- if val:
- ret[dev] = val
-
- if crypto:
- crypto.closeDevice()
-
- active = lvm.vgcheckactive()
- if not active:
- lvm.vgscan()
- lvm.vgactivate()
-
- for (vg, lv, size, lvorigin) in lvm.lvlist():
- if lvorigin:
- continue
- node = "%s/%s" % (vg, lv)
- crypto = encryptedDevices.get(node)
- if crypto and not crypto.openDevice():
- node = crypto.getDevice()
-
- val = readFn("/dev/" + node)
- if val:
- ret[node] = val
-
- if crypto:
- crypto.closeDevice()
-
- if not active:
- lvm.vgdeactivate()
-
- return ret
-
- def findExistingRootPartitions(self, upgradeany = 0):
- """Return a list of all of the partitions which look like a root fs."""
- rootparts = []
-
- self.startMPath()
- self.startDmRaid()
- self.startMdRaid()
-
- for dev, crypto in self.anaconda.id.partitions.encryptedDevices.items():
- # FIXME: order these so LVM and RAID always work on the first try
- if crypto.openDevice():
- log.error("failed to open encrypted device %s" % (dev,))
-
- if flags.cmdline.has_key("upgradeany"):
- upgradeany = 1
-
- for dev, devices, level, numActive in self.mdList:
- (errno, msg) = (None, None)
- found = 0
- theDev = dev
- crypto = self.anaconda.id.partitions.encryptedDevices.get(dev)
- if crypto and not crypto.openDevice():
- theDev = "/dev/%s" % (crypto.getDevice(),)
- elif crypto:
- log.error("failed to open encrypted device %s" % dev)
-
- fs = isys.readFSType(theDev)
- if fs is not None:
- try:
- isys.mount(theDev, self.anaconda.rootPath, fs,
- readOnly = True)
- found = 1
- except SystemError:
- pass
-
- if found:
- if os.access (self.anaconda.rootPath + '/etc/fstab', os.R_OK):
- (prod, ver) = getReleaseString(self.anaconda.rootPath)
-
- if upgradeany == 1 or self.anaconda.id.instClass.productUpgradable(prod, ver):
- try:
- label = isys.readFSLabel(theDev)
- except:
- label = None
-
- uuid = isys.readFSUuid(theDev)
- # XXX we could add the "raw" dev and let caller decrypt
- rootparts.append ((theDev, fs, prod+" "+ver, label, uuid))
- isys.umount(self.anaconda.rootPath)
-
- # now, look for candidate lvm roots
- lvm.vgscan()
- lvm.vgactivate()
-
- for dev, crypto in self.anaconda.id.partitions.encryptedDevices.items():
- # FIXME: order these so LVM and RAID always work on the first try
- if crypto.openDevice():
- log.error("failed to open encrypted device %s" % (dev,))
-
- for (vg, lv, size, lvorigin) in lvm.lvlist():
- if lvorigin:
- continue
- dev = "/dev/%s/%s" %(vg, lv)
- found = 0
- theDev = dev
- node = "%s/%s" % (vg, lv)
- dmnode = "mapper/%s-%s" % (vg, lv)
- crypto = self.anaconda.id.partitions.encryptedDevices.get(dmnode)
- if crypto and not crypto.openDevice():
- theDev = "/dev/%s" % (crypto.getDevice(),)
- elif crypto:
- log.error("failed to open encrypted device %s" % dev)
-
- fs = isys.readFSType(theDev)
- if fs is not None:
- try:
- isys.mount(theDev, self.anaconda.rootPath, fs,
- readOnly = True)
- found = 1
- except SystemError:
- pass
-
- if found:
- if os.access (self.anaconda.rootPath + '/etc/fstab', os.R_OK):
- (prod, ver) = getReleaseString(self.anaconda.rootPath)
-
- if upgradeany == 1 or self.anaconda.id.instClass.productUpgradable(prod, ver):
- try:
- label = isys.readFSLabel(theDev)
- except:
- label = None
-
- uuid = isys.readFSUuid(theDev)
- rootparts.append ((theDev, fs, prod+" "+ver, label, uuid))
- isys.umount(self.anaconda.rootPath)
-
- lvm.vgdeactivate()
-
- # don't stop raid until after we've looked for lvm on top of it
- self.stopMdRaid()
-
- drives = self.disks.keys()
- drives.sort()
-
- protected = self.anaconda.id.storage.protectedPartitions
-
- for drive in drives:
- disk = self.disks[drive]
- for part in disk.partitions:
- node = part.getDeviceNodeName()
- crypto = self.anaconda.id.partitions.encryptedDevices.get(node)
- if (part.active
- and (part.getFlag(parted.PARTITION_RAID)
- or part.getFlag(parted.PARTITION_LVM))):
- continue
- elif part.fileSystem or crypto:
- theDev = node
- if part.fileSystem:
- fstype = part.fileSystem.type
- else:
- fstype = None
-
- # parted doesn't tell ext4 from ext3
- if fstype == "ext3":
- fstype = isys.readFSType(theDev)
-
- if crypto and not crypto.openDevice():
- theDev = crypto.getDevice()
- fstype = isys.readFSType("/dev/%s" % theDev)
- elif crypto:
- log.error("failed to open encrypted device %s" % node)
-
- if not fstype or fstype not in fsset.getUsableLinuxFs():
- continue
-
- try:
- isys.mount("/dev/%s" % (theDev,),
- self.anaconda.rootPath, fstype)
- checkRoot = self.anaconda.rootPath
- except SystemError:
- continue
-
- if os.access (checkRoot + '/etc/fstab', os.R_OK):
- (prod, ver) = getReleaseString(checkRoot)
-
- if upgradeany == 1 or self.anaconda.id.instClass.productUpgradable(prod, ver):
- try:
- label = isys.readFSLabel("/dev/%s" % theDev)
- except:
- label = None
-
- uuid = isys.readFSUuid("/dev/%s" % (theDev,))
- rootparts.append (("/dev/%s" % (theDev,),
- fstype, prod+" "+ver, label, uuid))
-
- isys.umount(self.anaconda.rootPath)
-
- return rootparts
-
def driveList (self):
"""Return the list of drives on the system."""
drives = map(lambda x: x.name, self.anaconda.id.storage.disks)
drives.sort (isys.compareDrives)
return drives
-
- def savePartitions (self):
- """Write the partition tables out to the disks."""
- for disk in self.disks.values():
- if disk.device.path[5:].startswith("sd") and disk.lastPartitionNumber > 15:
- log.debug("not saving partition table of disk with > 15 partitions")
- del disk
- continue
-
- log.info("disk.commit() for %s" % (disk.device.path,))
- try:
- disk.commit()
- except:
- # if this fails, remove the disk so we don't use it later
- # Basically if we get here, badness has happened and we want
- # to prevent tracebacks from ruining the day any more.
- del disk
- continue
-
- # FIXME: this belongs in parted itself, but let's do a hack...
- if iutil.isX86() and disk.type == "gpt" and not iutil.isEfi():
- log.debug("syncing gpt to mbr for disk %s" % (disk.device.path,))
- iutil.execWithRedirect("gptsync", [disk.device.path,],
- stdout="/tmp/gptsync.log",
- stderr="/tmp/gptsync.err",
- searchPath = 1)
- del disk
- self.refreshDevices()
-
- def _addDisk(self, drive, disk):
- log.debug("adding drive %s to disk list" % (drive,))
- self.initializedDisks[drive] = True
- self.disks[drive] = disk
-
- def _removeDisk(self, drive, addSkip=True):
- msg = "removing drive %s from disk lists" % (drive,)
- if addSkip:
- msg += "; adding to skip list"
- log.debug(msg)
-
- if self.disks.has_key(drive):
- del self.disks[drive]
- if addSkip:
- if self.initializedDisks.has_key(drive):
- del self.initializedDisks[drive]
- DiskSet.skippedDisks.append(drive)
-
- def refreshDevices (self):
- """Reread the state of the disks as they are on disk."""
- self.closeDevices()
- self.disks = {}
- self.openDevices()
-
- def closeDevices (self):
- """Close all of the disks which are open."""
- self.stopDmRaid()
- self.stopMPath()
- for disk in self.disks.keys():
- #self.disks[disk].close()
- del self.disks[disk]
- self.devicesOpen = False
-
- def isDisciplineFBA (self, drive):
- if not iutil.isS390():
- return False
-
- drive = drive.replace('/dev/', '')
-
- if drive.startswith("dasd"):
- discipline = "/sys/block/%s/device/discipline" % (drive,)
- if os.path.isfile(discipline):
- try:
- fp = open(discipline, "r")
- lines = fp.readlines()
- fp.close()
-
- if len(lines) == 1:
- if lines[0].strip() == "FBA":
- return True
- except:
- log.error("failed to check discipline of %s" % (drive,))
- pass
-
- return False
-
- def dasdFmt (self, drive = None):
- """Format dasd devices (s390)."""
-
- if self.disks.has_key(drive):
- del self.disks[drive]
-
- w = self.anaconda.intf.progressWindow (_("Initializing"),
- _("Please wait while formatting drive %s...\n"
- ) % (drive,), 100)
-
- argList = [ "/sbin/dasdfmt",
- "-y",
- "-b", "4096",
- "-d", "cdl",
- "-F",
- "-P",
- "-f",
- "/dev/%s" % (drive,)]
-
- fd = os.open("/dev/null", os.O_RDWR | os.O_CREAT | os.O_APPEND)
- p = os.pipe()
- childpid = os.fork()
- if not childpid:
- os.close(p[0])
- os.dup2(p[1], 1)
- os.dup2(fd, 2)
- os.close(p[1])
- os.close(fd)
- os.execv(argList[0], argList)
- log.critical("failed to exec %s", argList)
- os._exit(1)
-
- os.close(p[1])
-
- num = ''
- sync = 0
- s = 'a'
- while s:
- try:
- s = os.read(p[0], 1)
- os.write(fd, s)
-
- if s != '\n':
- try:
- num = num + s
- except:
- pass
- else:
- if num:
- val = string.split(num)
- if (val[0] == 'cyl'):
- # printf("cyl %5d of %5d | %3d%%\n",
- val = int(val[5][:-1])
- w and w.set(val)
- # sync every 10%
- if sync + 10 <= val:
- isys.sync()
- sync = val
- num = ''
- except OSError, args:
- (errno, str) = args
- if (errno != 4):
- raise IOError, args
-
- try:
- (pid, status) = os.waitpid(childpid, 0)
- except OSError, (num, msg):
- print(__name__, "waitpid:", msg)
-
- os.close(fd)
-
- w and w.pop()
-
- if os.WIFEXITED(status) and (os.WEXITSTATUS(status) == 0):
- return 0
-
- return 1
-
- def _askForLabelPermission(self, intf, drive, clearDevs, initAll, ks):
- #Do not try to initialize device's part. table in rescue mode
- if self.anaconda.rescue:
- self._removeDisk(drive)
- return False
-
- rc = 0
- if (ks and (drive in clearDevs) and initAll) or \
- self.isDisciplineFBA(drive):
- rc = 1
- elif intf:
- deviceFile = "/dev/" + drive
- dev = parted.getDevice(deviceFile)
-
- msg = _("The partition table on device %s (%s %-0.f MB) was unreadable.\n\n"
- "To create new partitions it must be initialized, "
- "causing the loss of ALL DATA on this drive.\n\n"
- "This operation will override any previous "
- "installation choices about which drives to "
- "ignore.\n\n"
- "Would you like to initialize this drive, "
- "erasing ALL DATA?") % (drive, dev.model, dev.getSize(unit="MB"),)
-
- rc = intf.messageWindow(_("Warning"), msg, type="yesno")
-
- if rc != 0:
- return True
-
- self._removeDisk(drive)
- return False
-
- def _labelDevice(self, drive):
- log.info("Reinitializing label for drive %s" % (drive,))
-
- deviceFile = "/dev/" + drive
-
- try:
- try:
- # FIXME: need the right fix for z/VM formatted dasd
- if iutil.isS390() and drive[:4] == "dasd" and \
- not self.isDisciplineFBA(drive):
- if self.dasdFmt(drive):
- raise LabelError, drive
- dev = parted.getDevice(deviceFile)
- disk = parted.Disk(device=dev)
- else:
- disk = labelDisk(self.anaconda.platform, deviceFile)
- except Exception, msg:
- log.error("parted error: %s" % (msg,))
- raise
- except:
- (type, value, tb) = sys.exc_info()
- stack = inspect.getinnerframes(tb)
- exn = exception.AnacondaExceptionDump(type, value, stack)
- lines = exn.__str__()
- for line in lines:
- log.error(line)
- self._removeDisk(drive)
- raise LabelError, drive
-
- self._addDisk(drive, disk)
- return disk, dev
-
- def openDevices (self):
- """Open the disks on the system and skip unopenable devices."""
-
- if self.disks:
- return
- self.startMPath()
- self.startDmRaid()
-
- intf = self.anaconda.intf
- zeroMbr = self.anaconda.id.partitions.zeroMbr
-
- for drive in self.driveList():
- # ignoredisk takes precedence over clearpart (#186438).
- if drive in DiskSet.skippedDisks:
- continue
-
- if DiskSet.exclusiveDisks != [] and \
- drive not in DiskSet.exclusiveDisks:
- continue
-
- if not isys.mediaPresent(drive):
- DiskSet.skippedDisks.append(drive)
- continue
-
- disk = None
- dev = None
-
- if self.initializedDisks.has_key(drive):
- if not self.disks.has_key(drive):
- try:
- dev = parted.getDevice("/dev/%s" % (drive,))
- disk = parted.Disk(device=dev)
- self._addDisk(drive, disk)
- except:
- self._removeDisk(drive)
- continue
-
- ks = False
- clearDevs = []
- initAll = False
-
- if self.anaconda.isKickstart:
- ks = True
- clearDevs = self.anaconda.id.ksdata.clearpart.drives
- initAll = self.anaconda.id.ksdata.clearpart.initAll
-
- # FIXME: need the right fix for z/VM formatted dasd
- if iutil.isS390() \
- and drive[:4] == "dasd" \
- and isys.getDasdState(drive):
- try:
- if not self._askForLabelPermission(intf, drive, clearDevs,
- initAll, ks):
- raise LabelError, drive
-
- disk, dev = self._labelDevice(drive)
- except:
- continue
-
- if initAll and ((clearDevs is None) or (len(clearDevs) == 0) \
- or (drive in clearDevs)) and not flags.test \
- and not hasProtectedPartitions(drive, self.anaconda):
- try:
- disk, dev = self._labelDevice(drive)
- except:
- continue
-
- try:
- if not dev:
- dev = parted.getDevice("/dev/%s" % (drive,))
- disk = None
- except Exception, msg:
- log.debug("parted error: %s" % (msg,))
- self._removeDisk(drive, disk)
- continue
-
- try:
- if not disk:
- disk = parted.Disk(device=dev)
- self._addDisk(drive, disk)
- except Exception, msg:
- recreate = 0
- if zeroMbr:
- log.error("zeroMBR was set and invalid partition table "
- "found on %s" % (dev.path[5:]))
- recreate = 1
- else:
- if not self._askForLabelPermission(intf, drive, clearDevs,
- initAll, ks):
- continue
-
- recreate = 1
-
- if recreate == 1 and not flags.test:
- try:
- disk, dev = self._labelDevice(drive)
- except:
- continue
-
- filter_partitions(disk, validateFsType)
-
- # check for more than 15 partitions (libata limit)
- if drive.startswith('sd') and disk.lastPartitionNumber > 15:
- str = _("The drive /dev/%s has more than 15 partitions on it. "
- "The SCSI subsystem in the Linux kernel does not "
- "allow for more than 15 partitons at this time. You "
- "will not be able to make changes to the partitioning "
- "of this disk or use any partitions beyond /dev/%s15 "
- "in %s") % (drive, drive, productName)
-
- rc = intf.messageWindow(_("Warning"), str,
- type="custom",
- custom_buttons = [_("_Reboot"),
- _("_Continue")],
- custom_icon="warning")
- if rc == 0:
- sys.exit(0)
-
- # check that their partition table is valid for their architecture
- ret = checkDiskLabel(disk, intf)
- if ret == 1:
- self._removeDisk(drive)
- elif ret == -1:
- try:
- disk, dev = self._labelDevice(drive)
- except:
- pass
- self.devicesOpen = True
-
- def partitionTypes (self):
- """Return list of (partition, partition type) tuples for all parts."""
- rc = []
- drives = self.disks.keys()
- drives.sort()
-
- for drive in drives:
- disk = self.disks[drive]
- for part in disk.partitions:
- if part.type in (parted.PARTITION_NORMAL,
- parted.PARTITION_LOGICAL):
- device = part.getDeviceNodeName()
- if part.fileSystem:
- ptype = part.fileSystem.type
- else:
- ptype = None
- rc.append((device, ptype))
-
- return rc
-
- def diskState (self):
- """Print out current disk state. DEBUG."""
- rc = ""
- for disk in self.disks.values():
- rc = rc + ("%s: %s length %ld, maximum "
- "primary partitions: %d\n" %
- (disk.device.path,
- disk.device.model,
- disk.device.length,
- disk.maxPrimaryPartitionCount))
-
- for part in disk.partitions:
- rc = rc + ("Device Type Filesystem Start "
- "End Length Flags\n")
- rc = rc + ("------ ---- ---------- ----- "
- "--- ------ -----\n")
- if not part.type & parted.PARTITION_METADATA:
- device = ""
- fs_type_name = ""
- if part.number > 0:
- device = part.getDeviceNodeName()
- if part.fileSystem:
- fs_type_name = part.fileSystem.type
- partFlags = part.getFlagsAsString()
- rc = rc + ("%-9s %-12s %-12s %-10ld %-10ld %-10ld %7s\n"
- % (device, part.type.name, fs_type_name,
- part.geometry.start, part.geometry.end,
- part.geometry.length, partFlags))
-
- return rc
-
- def checkNoDisks(self):
- """Check that there are valid disk devices."""
- if len(self.disks.keys()) == 0:
- self.anaconda.intf.messageWindow(_("No Drives Found"),
- _("An error has occurred - no valid devices were "
- "found on which to create new file systems. "
- "Please check your hardware for the cause "
- "of this problem."))
- return True
- return False
-
-
- def exceptionDisks(self, anaconda, probe=True):
- if probe:
- isys.flushDriveDict()
- self.refreshDevices()
-
- drives = []
- for d in isys.removableDriveDict().items():
- func = lambda p: p.active and not p.getFlag(parted.PARTITION_RAID) and not p.getFlag(parted.PARTITION_LVM) and p.fileSystem.type in ["ext3", "ext2", "fat16", "fat32"]
-
- disk = self.disks[d[0]]
- parts = filter_partitions(disk, func)
-
- if len(parts) == 0:
- drives.append(d)
- else:
- for part in parts:
- name = "%s%s" % (part.disk.device.path, part.number)
- drives.append((os.path.basename(name), d[1]))
-
- return drives
--
1.6.1.3
_______________________________________________
Anaconda-devel-list mailing list
Anaconda-devel-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/anaconda-devel-list
