diff --git a/src/core/lvmdevice.cpp b/src/core/lvmdevice.cpp index 2bda749..be3d4d8 100644 --- a/src/core/lvmdevice.cpp +++ b/src/core/lvmdevice.cpp @@ -1,348 +1,336 @@ /************************************************************************* * Copyright (C) 2016 by Chantara Tith * * * * This program is free software; you can redistribute it and/or * * modify it under the terms of the GNU General Public License as * * published by the Free Software Foundation; either version 3 of * * the License, or (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty 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, see .* *************************************************************************/ #include "core/lvmdevice.h" #include "fs/filesystem.h" #include "fs/filesystemfactory.h" #include "core/partition.h" #include "core/partitiontable.h" #include "util/externalcommand.h" #include "util/helpers.h" #include #include #include #include #include /** Constructs a representation of LVM device with functionning LV as Partition * * @param name Volume Group name */ LvmDevice::LvmDevice(const QString& name, const QString& iconname) : VolumeManagerDevice(name, (QStringLiteral("/dev/") + name), getPeSize(name), getTotalPE(name), iconname, Device::LVM_Device) , m_peSize(getPeSize(name)) , m_totalPE(getTotalPE(name)) , m_allocPE(getAllocatedPE(name)) , m_freePE(getFreePE(name)) , m_UUID(getUUID(name)) { initPartitions(); } void LvmDevice::initPartitions() { qint64 firstUsable = 0; qint64 lastusable = totalPE() - 1; PartitionTable* pTable = new PartitionTable(PartitionTable::vmd, firstUsable, lastusable); foreach (Partition* p, scanPartitions(*this, pTable)) { pTable->append(p); } - // Manually insert unallocated space as Partition. - // TODO: PartitionTable's updateUnallocated seem not to works. - if (freePE()) { - qint64 startUnallocated = lastusable - freePE() + 1; - qint64 endUnallocated = lastusable; - pTable->append(new Partition(pTable, - *this, - PartitionRole(PartitionRole::Unallocated), - FileSystemFactory::create(FileSystem::Unknown,startUnallocated, endUnallocated), - startUnallocated, - endUnallocated, - QString()) - ); - } + pTable->updateUnallocated(*this); + setPartitionTable(pTable); } /** * @returns sorted Partition(LV) Array */ QList LvmDevice::scanPartitions(const LvmDevice& dev, PartitionTable* pTable) const { QList pList; foreach (QString lvPath, lvPathList()) { pList.append(scanPartition(lvPath, dev, pTable)); } return pList; } /** * @returns sorted Partition(LV) Array */ Partition* LvmDevice::scanPartition(const QString& lvpath, const LvmDevice& dev, PartitionTable* pTable) const { /* * NOTE: * LVM partition have 2 different start and end sector value * 1. representing the actual LV start from 0 -> size of LV - 1 * 2. representing abstract LV's sector inside a VG partitionTable * start from size of last Partitions -> size of LV - 1 * Reason for this is for the LV Partition to worrks nicely with other parts of the codebase * without too many special cases. */ qint64 startSector; qint64 endSector; qint64 lvSize; bool mounted = isMounted(lvpath); QString mountPoint = QString(); KMountPoint::List mountPointList = KMountPoint::currentMountPoints(KMountPoint::NeedRealDeviceName); mountPointList.append(KMountPoint::possibleMountPoints(KMountPoint::NeedRealDeviceName)); mountPoint = mountPointList.findByDevice(lvpath) ? mountPointList.findByDevice(lvpath)->mountPoint() : QString(); lvSize = getTotalLE(lvpath); startSector = mappedSector(lvpath,0); endSector = startSector + (lvSize - 1); const KDiskFreeSpaceInfo freeSpaceInfo = KDiskFreeSpaceInfo::freeSpaceInfo(mountPoint); FileSystem* fs = FileSystemFactory::create(FileSystem::detectFileSystem(lvpath), 0, lvSize - 1); if (mounted && freeSpaceInfo.isValid() && mountPoint != QString()) { //TODO: fix used space report. currently incorrect fs->setSectorsUsed(freeSpaceInfo.used() / logicalSize()); } if (fs->supportGetLabel() != FileSystem::cmdSupportNone) { fs->setLabel(fs->readLabel(lvpath)); } Partition* part = new Partition(pTable, dev, PartitionRole(PartitionRole::Lvm_Lv), fs, startSector, endSector, lvpath, PartitionTable::Flag::FlagLvm, mountPoint, mounted); return part; } qint64 LvmDevice::mappedSector(const QString& lvpath, qint64 sector) const { qint64 mSector = 0; QList lvpathList = lvPathList(); qint32 devIndex = lvpathList.indexOf(lvpath); if (devIndex) { for (int i = 0; i < devIndex; i++) { //TODO: currently going over the same LV again and again is wasteful. Could use some more optimization mSector += getTotalLE(lvpathList[i]); } mSector += sector; } return mSector; } QList LvmDevice::deviceNodeList() const { QList devPathList; QString cmdOutput = getField(QStringLiteral("pv_name"), name()); if (cmdOutput.size()) { QList tempPathList = cmdOutput.split(QStringLiteral("\n"), QString::SkipEmptyParts); foreach(QString devPath, tempPathList) { devPathList.append(devPath.trimmed()); } } return devPathList; } QList LvmDevice::lvPathList() const { QList lvPathList; QString cmdOutput = getField(QStringLiteral("lv_path"), name()); if (cmdOutput.size()) { QList tempPathList = cmdOutput.split(QStringLiteral("\n"), QString::SkipEmptyParts); foreach(QString lvPath, tempPathList) { lvPathList.append(lvPath.trimmed()); } } return lvPathList; } qint32 LvmDevice::getPeSize(const QString& vgname) { QString val = getField(QStringLiteral("vg_extent_size"), vgname); return val.isEmpty() ? -1 : val.toInt(); } qint32 LvmDevice::getTotalPE(const QString& vgname) { QString val = getField(QStringLiteral("vg_extent_count"), vgname); return val.isEmpty() ? -1 : val.toInt(); } qint32 LvmDevice::getAllocatedPE(const QString& vgname) { return getTotalPE(vgname) - getFreePE(vgname); } qint32 LvmDevice::getFreePE(const QString& vgname) { QString val = getField(QStringLiteral("vg_free_count"), vgname); return val.isEmpty() ? -1 : val.toInt(); } QString LvmDevice::getUUID(const QString& vgname) { QString val = getField(QStringLiteral("vg_uuid"), vgname); return val.isEmpty() ? QStringLiteral("---") : val; } /** Get LVM vgs command output with field name * * @param fieldName lvm field name * @param vgname * @returns raw output of command output, usully with manay spaces within the returned string * */ QString LvmDevice::getField(const QString& fieldName, const QString& vgname) { ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("vgs"), QStringLiteral("--foreign"), QStringLiteral("--readonly"), QStringLiteral("--noheadings"), QStringLiteral("--units"), QStringLiteral("B"), QStringLiteral("--nosuffix"), QStringLiteral("--options"), fieldName, vgname }); if (cmd.run(-1) && cmd.exitCode() == 0) { return cmd.output().trimmed(); } return QString(); } qint32 LvmDevice::getTotalLE(const QString& lvpath) { ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("lvdisplay"), lvpath}); if (cmd.run(-1) && cmd.exitCode() == 0) { QRegularExpression re(QStringLiteral("Current LE\\h+(\\d+)")); QRegularExpressionMatch match = re.match(cmd.output()); if (match.hasMatch()) { return match.captured(1).toInt(); } } return -1; } bool LvmDevice::removeLV(Report& report, LvmDevice& dev, Partition& part) { ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("lvremove"), QStringLiteral("--yes"), part.partitionPath()}); if (cmd.run(-1) && cmd.exitCode() == 0) { //TODO: remove Partition from PartitionTable and delete from memory ?? dev.partitionTable()->remove(&part); return true; } report.line() << xi18nc("@info/plain", "Failed to add Logical Volume"); return false; } bool LvmDevice::createLV(Report& report, LvmDevice& dev, Partition& part, const QString& lvname) { ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("lvcreate"), QStringLiteral("--yes"), QStringLiteral("--extents"), QString::number(part.length()), QStringLiteral("--name"), lvname, dev.name()}); if (cmd.run(-1) && cmd.exitCode() == 0) { return true; } //report.line() << xi18nc("@info/plain", "Failed to add Logical Volume"); report.line() << cmd.output(); return false; } bool LvmDevice::resizeLv(Report& report, LvmDevice& dev, Partition& part) { Q_UNUSED(dev); //TODO: through tests ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("lvresize"), //QStringLiteral("--yes"), // this command could corrupt user data QStringLiteral("--extents"), QString::number(part.length()), part.partitionPath()}); if (cmd.run(-1) && cmd.exitCode() == 0) { return true; } report.line() << cmd.output(); return false; } bool LvmDevice::removePV(Report& report, LvmDevice& dev, const QString& pvPath) { //TODO: through tests ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("vgreduce"), //QStringLiteral("--yes"), // potentially corrupt user data dev.name(), pvPath}); if (cmd.run(-1) && cmd.exitCode() == 0) { return true; } report.line() << cmd.output(); return false; } bool LvmDevice::insertPV(Report& report, LvmDevice& dev, const QString& pvPath) { //TODO: through tests ExternalCommand cmd(QStringLiteral("lvm"), { QStringLiteral("vgextend"), //QStringLiteral("--yes"), // potentially corrupt user data dev.name(), pvPath}); if (cmd.run(-1) && cmd.exitCode() == 0) { return true; } report.line() << cmd.output(); return false; } diff --git a/src/core/partitiontable.cpp b/src/core/partitiontable.cpp index d39a3c1..54ad76f 100644 --- a/src/core/partitiontable.cpp +++ b/src/core/partitiontable.cpp @@ -1,536 +1,541 @@ /************************************************************************* * Copyright (C) 2008 by Volker Lanz * * Copyright (C) 2016 by Andrius Štikonas * * Copyright (C) 2016 by Teo Mrnjavac * * * * This program is free software; you can redistribute it and/or * * modify it under the terms of the GNU General Public License as * * published by the Free Software Foundation; either version 3 of * * the License, or (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty 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, see .* *************************************************************************/ /** @file */ #include "core/partitiontable.h" #include "core/partition.h" #include "core/device.h" #include "core/diskdevice.h" +#include "core/lvmdevice.h" #include "core/partitionalignment.h" #include "fs/filesystem.h" #include "fs/filesystemfactory.h" #include "util/globallog.h" #include #include #include /** Creates a new PartitionTable object with type MSDOS @param type name of the PartitionTable type (e.g. "msdos" or "gpt") */ PartitionTable::PartitionTable(TableType type, qint64 first_usable, qint64 last_usable) : PartitionNode(), m_Children(), m_MaxPrimaries(maxPrimariesForTableType(type)), m_Type(type), m_FirstUsable(first_usable), m_LastUsable(last_usable) { } /** Destroys a PartitionTable object, destroying all children */ PartitionTable::~PartitionTable() { clearChildren(); } /** Gets the number of free sectors before a given child Partition in this PartitionTable. @param p the Partition for which to get the free sectors before @returns the number of free sectors before the Partition */ qint64 PartitionTable::freeSectorsBefore(const Partition& p) const { const Partition* pred = predecessor(p); // due to the space required for extended boot records the // below is NOT the same as pred->length() if (pred && pred->roles().has(PartitionRole::Unallocated)) return p.firstSector() - pred->firstSector(); return 0; } /** Gets the number of free sectors after a given child Partition in this PartitionTable. @param p the Partition for which to get the free sectors after @returns the number of free sectors after the Partition */ qint64 PartitionTable::freeSectorsAfter(const Partition& p) const { const Partition* succ = successor(p); // due to the space required for extended boot records the // below is NOT the same as succ->length() if (succ && succ->roles().has(PartitionRole::Unallocated)) return succ->lastSector() - p.lastSector(); return 0; } /** @return true if the PartitionTable has an extended Partition */ bool PartitionTable::hasExtended() const { for (int i = 0; i < children().size(); i++) if (children()[i]->roles().has(PartitionRole::Extended)) return true; return false; } /** @return pointer to the PartitionTable's extended Partition or nullptr if none exists */ Partition* PartitionTable::extended() const { for (int i = 0; i < children().size(); i++) if (children()[i]->roles().has(PartitionRole::Extended)) return children()[i]; return nullptr; } /** Gets valid PartitionRoles for a Partition @param p the Partition @return valid roles for the given Partition */ PartitionRole::Roles PartitionTable::childRoles(const Partition& p) const { Q_ASSERT(p.parent()); PartitionRole::Roles r = p.parent()->isRoot() ? PartitionRole::Primary : PartitionRole::Logical; if (r == PartitionRole::Primary && hasExtended() == false && tableTypeSupportsExtended(type())) r |= PartitionRole::Extended; return r; } /** @return the number of primaries in this PartitionTable */ int PartitionTable::numPrimaries() const { int result = 0; foreach(const Partition * p, children()) if (p->roles().has(PartitionRole::Primary) || p->roles().has(PartitionRole::Extended)) result++; return result; } /** Appends a Partition to this PartitionTable @param partition pointer of the partition to append. Must not be nullptr. */ void PartitionTable::append(Partition* partition) { children().append(partition); } /** @param f the flag to get the name for @returns the flags name or an empty QString if the flag is not known */ QString PartitionTable::flagName(Flag f) { switch (f) { case PartitionTable::FlagBoot: return i18nc("@item partition flag", "boot"); case PartitionTable::FlagRoot: return i18nc("@item partition flag", "root"); case PartitionTable::FlagSwap: return i18nc("@item partition flag", "swap"); case PartitionTable::FlagHidden: return i18nc("@item partition flag", "hidden"); case PartitionTable::FlagRaid: return i18nc("@item partition flag", "raid"); case PartitionTable::FlagLvm: return i18nc("@item partition flag", "lvm"); case PartitionTable::FlagLba: return i18nc("@item partition flag", "lba"); case PartitionTable::FlagHpService: return i18nc("@item partition flag", "hpservice"); case PartitionTable::FlagPalo: return i18nc("@item partition flag", "palo"); case PartitionTable::FlagPrep: return i18nc("@item partition flag", "prep"); case PartitionTable::FlagMsftReserved: return i18nc("@item partition flag", "msft-reserved"); case PartitionTable::FlagBiosGrub: return i18nc("@item partition flag", "bios-grub"); case PartitionTable::FlagAppleTvRecovery: return i18nc("@item partition flag", "apple-tv-recovery"); case PartitionTable::FlagDiag: return i18nc("@item partition flag", "diag"); case PartitionTable::FlagLegacyBoot: return i18nc("@item partition flag", "legacy-boot"); case PartitionTable::FlagMsftData: return i18nc("@item partition flag", "msft-data"); case PartitionTable::FlagIrst: return i18nc("@item partition flag", "irst"); case PartitionTable::FlagEsp: return i18nc("@item partition flag", "esp"); default: break; } return QString(); } /** @return list of all flags */ QList PartitionTable::flagList() { QList rval; rval.append(PartitionTable::FlagBoot); rval.append(PartitionTable::FlagRoot); rval.append(PartitionTable::FlagSwap); rval.append(PartitionTable::FlagHidden); rval.append(PartitionTable::FlagRaid); rval.append(PartitionTable::FlagLvm); rval.append(PartitionTable::FlagLba); rval.append(PartitionTable::FlagHpService); rval.append(PartitionTable::FlagPalo); rval.append(PartitionTable::FlagPrep); rval.append(PartitionTable::FlagMsftReserved); rval.append(PartitionTable::FlagBiosGrub); rval.append(PartitionTable::FlagAppleTvRecovery); rval.append(PartitionTable::FlagDiag); rval.append(PartitionTable::FlagLegacyBoot); rval.append(PartitionTable::FlagMsftData); rval.append(PartitionTable::FlagIrst); rval.append(PartitionTable::FlagEsp); return rval; } /** @param flags the flags to get the names for @returns QStringList of the flags' names */ QStringList PartitionTable::flagNames(Flags flags) { QStringList rval; int f = 1; QString s; while (!(s = flagName(static_cast(f))).isEmpty()) { if (flags & f) rval.append(s); f <<= 1; } return rval; } bool PartitionTable::getUnallocatedRange(const Device& d, PartitionNode& parent, qint64& start, qint64& end) { - //TODO: alignment for LVM device if (d.type() == Device::Disk_Device) { const DiskDevice& device = dynamic_cast(d); if (!parent.isRoot()) { Partition* extended = dynamic_cast(&parent); if (extended == nullptr) { qWarning() << "extended is null. start: " << start << ", end: " << end << ", device: " << device.deviceNode(); return false; } // Leave a track (cylinder aligned) or sector alignment sectors (sector based) free at the // start for a new partition's metadata start += device.partitionTable()->type() == PartitionTable::msdos ? device.sectorsPerTrack() : PartitionAlignment::sectorAlignment(device); // .. and also at the end for the metadata for a partition to follow us, if we're not // at the end of the extended partition if (end < extended->lastSector()) end -= device.partitionTable()->type() == PartitionTable::msdos ? device.sectorsPerTrack() : PartitionAlignment::sectorAlignment(device); } return end - start + 1 >= PartitionAlignment::sectorAlignment(device); } else if (d.type() == Device::LVM_Device) { + const LvmDevice& lvm = dynamic_cast(d); + if (lvm.freePE() && start >= lvm.allocatedPE()) { + start = lvm.allocatedPE(); + end = lvm.totalPE() - 1; + return true; + } return false; - //TODO: return range from last LE to last allocated LE } return false; } /** Creates a new unallocated Partition on the given Device. @param device the Device to create the new Partition on @param parent the parent PartitionNode for the new Partition @param start the new Partition's start sector @param end the new Partition's end sector @return pointer to the newly created Partition object or nullptr if the Partition could not be created */ Partition* createUnallocated(const Device& device, PartitionNode& parent, qint64 start, qint64 end) { PartitionRole::Roles r = PartitionRole::Unallocated; if (!parent.isRoot()) r |= PartitionRole::Logical; if (!PartitionTable::getUnallocatedRange(device, parent, start, end)) return nullptr; return new Partition(&parent, device, PartitionRole(r), FileSystemFactory::create(FileSystem::Unknown, start, end), start, end, QString()); } /** Removes all unallocated children from a PartitionNode @param p pointer to the parent to remove unallocated children from */ void PartitionTable::removeUnallocated(PartitionNode* p) { Q_ASSERT(p); qint32 i = 0; while (i < p->children().size()) { Partition* child = p->children()[i]; if (child->roles().has(PartitionRole::Unallocated)) { p->remove(child); delete child; continue; } if (child->roles().has(PartitionRole::Extended)) removeUnallocated(child); i++; } } /** @overload */ void PartitionTable::removeUnallocated() { removeUnallocated(this); } /** Inserts unallocated children for a Device's PartitionTable with the given parent. This method inserts unallocated Partitions for a parent, usually the Device this PartitionTable is on. It will also insert unallocated Partitions in any extended Partitions it finds. @warning This method assumes that no unallocated Partitions exist when it is called. @param d the Device this PartitionTable and @p p are on @param p the parent PartitionNode (may be this or an extended Partition) @param start the first sector to begin looking for free space */ void PartitionTable::insertUnallocated(const Device& d, PartitionNode* p, qint64 start) const { Q_ASSERT(p); qint64 lastEnd = start; foreach(Partition * child, p->children()) { p->insert(createUnallocated(d, *p, lastEnd, child->firstSector() - 1)); if (child->roles().has(PartitionRole::Extended)) insertUnallocated(d, child, child->firstSector()); lastEnd = child->lastSector() + 1; } // Take care of the free space between the end of the last child and the end // of the device or the extended partition. qint64 parentEnd = lastUsable(); if (!p->isRoot()) { Partition* extended = dynamic_cast(p); parentEnd = extended ? extended->lastSector() : -1; Q_ASSERT(extended); } if (parentEnd >= firstUsable()) p->insert(createUnallocated(d, *p, lastEnd, parentEnd)); } /** Updates the unallocated Partitions for this PartitionTable. @param d the Device this PartitionTable is on */ void PartitionTable::updateUnallocated(const Device& d) { removeUnallocated(); insertUnallocated(d, this, firstUsable()); } qint64 PartitionTable::defaultFirstUsable(const Device& d, TableType t) { Q_UNUSED(t) if (d.type() == Device::LVM_Device) { return 0; } else { const DiskDevice& diskDevice = dynamic_cast(d); return PartitionAlignment::sectorAlignment(diskDevice); } } qint64 PartitionTable::defaultLastUsable(const Device& d, TableType t) { if (t == gpt) return d.totalLogical() - 1 - 32 - 1; return d.totalLogical() - 1; } static struct { const QString name; /**< name of partition table type */ quint32 maxPrimaries; /**< max numbers of primary partitions supported */ bool canHaveExtended; /**< does partition table type support extended partitions */ bool isReadOnly; /**< does KDE Partition Manager support this only in read only mode */ PartitionTable::TableType type; /**< enum type */ } tableTypes[] = { { QStringLiteral("aix"), 4, false, true, PartitionTable::aix }, { QStringLiteral("bsd"), 8, false, true, PartitionTable::bsd }, { QStringLiteral("dasd"), 1, false, true, PartitionTable::dasd }, { QStringLiteral("msdos"), 4, true, false, PartitionTable::msdos }, { QStringLiteral("msdos"), 4, true, false, PartitionTable::msdos_sectorbased }, { QStringLiteral("dvh"), 16, true, true, PartitionTable::dvh }, { QStringLiteral("gpt"), 128, false, false, PartitionTable::gpt }, { QStringLiteral("loop"), 1, false, true, PartitionTable::loop }, { QStringLiteral("mac"), 0xffff, false, true, PartitionTable::mac }, { QStringLiteral("pc98"), 16, false, true, PartitionTable::pc98 }, { QStringLiteral("amiga"), 128, false, true, PartitionTable::amiga }, { QStringLiteral("sun"), 8, false, true, PartitionTable::sun } }; PartitionTable::TableType PartitionTable::nameToTableType(const QString& n) { for (size_t i = 0; i < sizeof(tableTypes) / sizeof(tableTypes[0]); i++) if (n == tableTypes[i].name) return tableTypes[i].type; return PartitionTable::unknownTableType; } QString PartitionTable::tableTypeToName(TableType l) { for (size_t i = 0; i < sizeof(tableTypes) / sizeof(tableTypes[0]); i++) if (l == tableTypes[i].type) return tableTypes[i].name; return i18nc("@item partition table name", "unknown"); } qint64 PartitionTable::maxPrimariesForTableType(TableType l) { for (size_t i = 0; i < sizeof(tableTypes) / sizeof(tableTypes[0]); i++) if (l == tableTypes[i].type) return tableTypes[i].maxPrimaries; return 1; } bool PartitionTable::tableTypeSupportsExtended(TableType l) { for (size_t i = 0; i < sizeof(tableTypes) / sizeof(tableTypes[0]); i++) if (l == tableTypes[i].type) return tableTypes[i].canHaveExtended; return false; } bool PartitionTable::tableTypeIsReadOnly(TableType l) { for (size_t i = 0; i < sizeof(tableTypes) / sizeof(tableTypes[0]); i++) if (l == tableTypes[i].type) return tableTypes[i].isReadOnly; return false; } /** Simple heuristic to determine if the PartitionTable is sector aligned (i.e. if its Partitions begin at sectors evenly divisable by PartitionAlignment::sectorAlignment(). @return true if is sector aligned, otherwise false */ bool PartitionTable::isSectorBased(const Device& d) const { if (d.type() == Device::Disk_Device) { const DiskDevice& diskDevice = dynamic_cast(d); if (type() == PartitionTable::msdos) { // the default for empty partition tables is sector based if (numPrimaries() == 0) return true; quint32 numCylinderAligned = 0; quint32 numSectorAligned = 0; // see if we have more cylinder aligned partitions than sector // aligned ones. foreach(const Partition * p, children()) if (p->firstSector() % PartitionAlignment::sectorAlignment(diskDevice) == 0) numSectorAligned++; else if (p->firstSector() % diskDevice.cylinderSize() == 0) numCylinderAligned++; return numSectorAligned >= numCylinderAligned; } return type() == PartitionTable::msdos_sectorbased; } return false; } void PartitionTable::setType(const Device& d, TableType t) { setFirstUsableSector(defaultFirstUsable(d, t)); setLastUsableSector(defaultLastUsable(d, t)); m_Type = t; updateUnallocated(d); } static bool isPartitionLessThan(const Partition* p1, const Partition* p2) { return p1->number() < p2->number(); } QTextStream& operator<<(QTextStream& stream, const PartitionTable& ptable) { stream << "type: \"" << ptable.typeName() << "\"\n" << "align: \"" << (ptable.type() == PartitionTable::msdos ? "cylinder" : "sector") << "\"\n" << "\n# number start end type roles label flags\n"; QList partitions; foreach(const Partition * p, ptable.children()) if (!p->roles().has(PartitionRole::Unallocated)) { partitions.append(p); if (p->roles().has(PartitionRole::Extended)) foreach(const Partition * child, p->children()) if (!child->roles().has(PartitionRole::Unallocated)) partitions.append(child); } qSort(partitions.begin(), partitions.end(), isPartitionLessThan); foreach(const Partition * p, partitions) stream << *p; return stream; } diff --git a/src/jobs/createpartitionjob.cpp b/src/jobs/createpartitionjob.cpp index c28e870..ac2446a 100644 --- a/src/jobs/createpartitionjob.cpp +++ b/src/jobs/createpartitionjob.cpp @@ -1,95 +1,96 @@ /************************************************************************* * Copyright (C) 2008 by Volker Lanz * * Copyright (C) 2016 by Andrius Štikonas * * * * This program is free software; you can redistribute it and/or * * modify it under the terms of the GNU General Public License as * * published by the Free Software Foundation; either version 3 of * * the License, or (at your option) any later version. * * * * This program is distributed in the hope that it will be useful, * * but WITHOUT ANY WARRANTY; without even the implied warranty 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, see .* *************************************************************************/ #include "jobs/createpartitionjob.h" #include "backend/corebackend.h" #include "backend/corebackendmanager.h" #include "backend/corebackenddevice.h" #include "backend/corebackendpartitiontable.h" #include "core/partition.h" #include "core/device.h" #include "core/lvmdevice.h" #include "util/report.h" #include /** Creates a new CreatePartitionJob @param d the Device the Partition to be created will be on @param p the Partition to create */ CreatePartitionJob::CreatePartitionJob(Device& d, Partition& p) : Job(), m_Device(d), m_Partition(p) { } bool CreatePartitionJob::run(Report& parent) { Q_ASSERT(partition().devicePath() == device().deviceNode()); bool rval = false; Report* report = jobStarted(parent); if (device().type() == Device::Disk_Device) { CoreBackendDevice* backendDevice = CoreBackendManager::self()->backend()->openDevice(device().deviceNode()); if (backendDevice) { CoreBackendPartitionTable* backendPartitionTable = backendDevice->openPartitionTable(); if (backendPartitionTable) { QString partitionPath = backendPartitionTable->createPartition(*report, partition()); if (partitionPath != QString()) { rval = true; partition().setPartitionPath(partitionPath); partition().setState(Partition::StateNone); backendPartitionTable->commit(); } else report->line() << xi18nc("@info/plain", "Failed to add partition %1 to device %2.", partition().deviceNode(), device().deviceNode()); delete backendPartitionTable; } else report->line() << xi18nc("@info/plain", "Could not open partition table on device %1 to create new partition %2.", device().deviceNode(), partition().deviceNode()); delete backendDevice; } else report->line() << xi18nc("@info/plain", "Could not open device %1 to create new partition %2.", device().deviceNode(), partition().deviceNode()); } else if (device().type() == Device::LVM_Device) { + //TODO: take lvname from createDialog LvmDevice& dev = dynamic_cast(device()); rval = LvmDevice::createLV(*report, dev, partition(), QStringLiteral("randomLV")); partition().setPartitionPath(dev.deviceNode() + QStringLiteral("/randomLV")); partition().setState(Partition::StateNone); } jobFinished(*report, rval); return rval; } QString CreatePartitionJob::description() const { if (partition().number() > 0) return xi18nc("@info/plain", "Create new partition %1", partition().deviceNode()); return xi18nc("@info/plain", "Create new partition on device %1", device().deviceNode()); }