diff --git a/src/core/raid/softwareraid.cpp b/src/core/raid/softwareraid.cpp index 858bd34..3100b72 100644 --- a/src/core/raid/softwareraid.cpp +++ b/src/core/raid/softwareraid.cpp @@ -1,542 +1,561 @@ /************************************************************************* * Copyright (C) 2018 by Caio Carvalho * * * * 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 "softwareraid.h" #include "backend/corebackend.h" #include "backend/corebackendmanager.h" #include "core/partition.h" #include "core/volumemanagerdevice_p.h" #include "fs/filesystem.h" #include "fs/filesystemfactory.h" #include "util/externalcommand.h" #include #include #include #define d_ptr std::static_pointer_cast(d) QString SoftwareRAID::s_raidConfigurationFile = QString(); class SoftwareRAIDPrivate : public VolumeManagerDevicePrivate { public: qint32 m_raidLevel; qint64 m_chunkSize; qint64 m_totalChunk; qint64 m_arraySize; QString m_UUID; QStringList m_devicePathList; + QStringList m_partitionPathList; SoftwareRAID::Status m_status; }; SoftwareRAID::SoftwareRAID(const QString& name, SoftwareRAID::Status status, const QString& iconName) : VolumeManagerDevice(std::make_shared(), name, (QStringLiteral("/dev/") + name), status == SoftwareRAID::Status::Inactive ? 0 : getChunkSize(QStringLiteral("/dev/") + name), status == SoftwareRAID::Status::Inactive ? 0 : getTotalChunk(QStringLiteral("/dev/") + name), iconName, Device::Type::SoftwareRAID_Device) { d_ptr->m_raidLevel = getRaidLevel(deviceNode()); d_ptr->m_chunkSize = logicalSize(); d_ptr->m_totalChunk = totalLogical(); d_ptr->m_arraySize = getArraySize(deviceNode()); d_ptr->m_UUID = getUUID(deviceNode()); d_ptr->m_devicePathList = getDevicePathList(deviceNode()); d_ptr->m_status = status; initPartitions(); } const QStringList SoftwareRAID::deviceNodes() const { return d_ptr->m_devicePathList; } const QStringList& SoftwareRAID::partitionNodes() const { - return {}; + return d_ptr->m_partitionPathList; } qint64 SoftwareRAID::partitionSize(QString &partitionPath) const { Q_UNUSED(partitionPath) return 0; } bool SoftwareRAID::growArray(Report &report, const QStringList &devices) { Q_UNUSED(report) Q_UNUSED(devices) return false; } bool SoftwareRAID::shrinkArray(Report &report, const QStringList &devices) { Q_UNUSED(report) Q_UNUSED(devices) return false; } QString SoftwareRAID::prettyName() const { QString raidInfo; if (status() == SoftwareRAID::Status::Active) raidInfo = xi18nc("@item:inlistbox [RAID level]", " [RAID %1]", raidLevel()); else if (status() == SoftwareRAID::Status::Recovery) raidInfo = xi18nc("@item:inlistbox [RAID level - Recovering]", " [RAID %1 - Recovering]", raidLevel()); else if (status() == SoftwareRAID::Status::Resync) raidInfo = xi18nc("@item:inlistbox [RAID level - Resyncing]", " [RAID %1 - Resyncing]", raidLevel()); else raidInfo = QStringLiteral(" [RAID]"); return VolumeManagerDevice::prettyName() + raidInfo; } bool SoftwareRAID::operator ==(const Device& other) const { bool equalDeviceNode = Device::operator ==(other); if (other.type() == Device::Type::SoftwareRAID_Device) { const SoftwareRAID& raid = static_cast(other); if (!equalDeviceNode) return raid.uuid() == uuid(); } return equalDeviceNode; } qint32 SoftwareRAID::raidLevel() const { return d_ptr->m_raidLevel; } qint64 SoftwareRAID::chunkSize() const { return d_ptr->m_chunkSize; } qint64 SoftwareRAID::totalChunk() const { return d_ptr->m_totalChunk; } qint64 SoftwareRAID::arraySize() const { return d_ptr->m_arraySize; } QString SoftwareRAID::uuid() const { return d_ptr->m_UUID; } -QStringList SoftwareRAID::devicePathList() const -{ - return d_ptr->m_devicePathList; -} - SoftwareRAID::Status SoftwareRAID::status() const { return d_ptr->m_status; } void SoftwareRAID::setStatus(SoftwareRAID::Status status) { d_ptr->m_status = status; } void SoftwareRAID::scanSoftwareRAID(QList& devices) { QStringList availableInConf; - // TODO: Support custom config files. QString config = getRAIDConfiguration(); if (!config.isEmpty()) { QRegularExpression re(QStringLiteral("([\\t\\r\\n\\f\\s]|INACTIVE-)ARRAY \\/dev\\/([\\/\\w-]+)")); QRegularExpressionMatchIterator i = re.globalMatch(config); while (i.hasNext()) { QRegularExpressionMatch reMatch = i.next(); QString deviceName = reMatch.captured(2).trimmed(); availableInConf << deviceName; } } QFile mdstat(QStringLiteral("/proc/mdstat")); if (mdstat.open(QIODevice::ReadOnly)) { QTextStream stream(&mdstat); QString content = stream.readAll(); mdstat.close(); QRegularExpression re(QStringLiteral("md([\\/\\w]+)\\s+:\\s+([\\w]+)")); QRegularExpressionMatchIterator i = re.globalMatch(content); while (i.hasNext()) { QRegularExpressionMatch reMatch = i.next(); QString deviceNode = QStringLiteral("/dev/md") + reMatch.captured(1).trimmed(); QString status = reMatch.captured(2).trimmed(); SoftwareRAID* d = static_cast(CoreBackendManager::self()->backend()->scanDevice(deviceNode)); // Just to prevent segfault in some case if (d == nullptr) continue; const QStringList constAvailableInConf = availableInConf; for (const QString& path : constAvailableInConf) if (getUUID(QStringLiteral("/dev/") + path) == d->uuid()) availableInConf.removeAll(path); + QStringList partitionNodes; + + for (const Partition *p : d->partitionTable()->children()) + partitionNodes << p->partitionPath(); + + d->setPartitionNodes(partitionNodes); + devices << d; if (status == QStringLiteral("inactive")) d->setStatus(SoftwareRAID::Status::Inactive); if (d->raidLevel() > 0) { QRegularExpression reMirrorStatus(d->name() + QStringLiteral("\\s+:\\s+(.*\\n\\s+)+\\[[=>.]+\\]\\s+(resync|recovery)")); QRegularExpressionMatch reMirrorStatusMatch = reMirrorStatus.match(content); if (reMirrorStatusMatch.hasMatch()) { if (reMirrorStatusMatch.captured(2) == QStringLiteral("resync")) d->setStatus(SoftwareRAID::Status::Resync); else if (reMirrorStatusMatch.captured(2) == QStringLiteral("recovery")) d->setStatus(SoftwareRAID::Status::Recovery); } } } } for (const QString& name : qAsConst(availableInConf)) { SoftwareRAID *raidDevice = new SoftwareRAID(name, SoftwareRAID::Status::Inactive); devices << raidDevice; } } qint32 SoftwareRAID::getRaidLevel(const QString &path) { QString output = getDetail(path); if (!output.isEmpty()) { QRegularExpression re(QStringLiteral("Raid Level :\\s+\\w+(\\d+)")); QRegularExpressionMatch reMatch = re.match(output); if (reMatch.hasMatch()) return reMatch.captured(1).toInt(); } return -1; } qint64 SoftwareRAID::getChunkSize(const QString &path) { if (getRaidLevel(path) == 1) { QStringList devices = getDevicePathList(path); if (!devices.isEmpty()) { QString device = devices[0]; // Look sector size for the first device/partition on the list, as RAID 1 is composed by mirrored devices ExternalCommand sectorSize(QStringLiteral("blockdev"), { QStringLiteral("--getss"), device }); if (sectorSize.run(-1) && sectorSize.exitCode() == 0) return sectorSize.output().trimmed().toLongLong(); } } else { QString output = getDetail(path); if (!output.isEmpty()) { QRegularExpression re(QStringLiteral("Chunk Size :\\s+(\\d+)")); QRegularExpressionMatch reMatch = re.match(output); if (reMatch.hasMatch()) return reMatch.captured(1).toLongLong(); } } return -1; } qint64 SoftwareRAID::getTotalChunk(const QString &path) { return getArraySize(path) / getChunkSize(path); } qint64 SoftwareRAID::getArraySize(const QString &path) { QString output = getDetail(path); if (!output.isEmpty()) { QRegularExpression re(QStringLiteral("Array Size :\\s+(\\d+)")); QRegularExpressionMatch reMatch = re.match(output); if (reMatch.hasMatch()) return reMatch.captured(1).toLongLong() * 1024; } return -1; } QString SoftwareRAID::getUUID(const QString &path) { QString output = getDetail(path); if (!output.isEmpty()) { QRegularExpression re(QStringLiteral("UUID :\\s+([\\w:]+)")); QRegularExpressionMatch reMatch = re.match(output); if (reMatch.hasMatch()) return reMatch.captured(1); } // If UUID was not found in detail output, it should be searched in config file - // TODO: Support custom config files. QString config = getRAIDConfiguration(); if (!config.isEmpty()) { QRegularExpression re(QStringLiteral("([\\t\\r\\n\\f\\s]|INACTIVE-)ARRAY \\/dev\\/md([\\/\\w-]+)(.*)")); QRegularExpressionMatchIterator i = re.globalMatch(config); while (i.hasNext()) { QRegularExpressionMatch reMatch = i.next(); QString deviceNode = QStringLiteral("/dev/md") + reMatch.captured(2).trimmed(); QString otherInfo = reMatch.captured(3).trimmed(); // Consider device node as name=host:deviceNode when the captured device node string has '-' character // It happens when user have included the device to config file using 'mdadm --examine --scan' if (deviceNode.contains(QLatin1Char('-'))) { QRegularExpression reName(QStringLiteral("name=[\\w:]+\\/dev\\/md\\/([\\/\\w]+)")); QRegularExpressionMatch nameMatch = reName.match(otherInfo); if (nameMatch.hasMatch()) deviceNode = nameMatch.captured(1); } if (deviceNode == path) { QRegularExpression reUUID(QStringLiteral("(UUID=|uuid=)([\\w:]+)")); QRegularExpressionMatch uuidMatch = reUUID.match(otherInfo); if (uuidMatch.hasMatch()) return uuidMatch.captured(2); } } } return QString(); } QStringList SoftwareRAID::getDevicePathList(const QString &path) { QStringList result; QString detail = getDetail(path); if (!detail.isEmpty()) { QRegularExpression re(QStringLiteral("\\s+\\/dev\\/(\\w+)")); QRegularExpressionMatchIterator i = re.globalMatch(detail); while (i.hasNext()) { QRegularExpressionMatch match = i.next(); QString device = QStringLiteral("/dev/") + match.captured(1); if (device != path) result << device; } } return result; } bool SoftwareRAID::isRaidPath(const QString &devicePath) { return !getDetail(devicePath).isEmpty(); } bool SoftwareRAID::createSoftwareRAID(Report &report, const QString &name, const QStringList devicePathList, const qint32 raidLevel, const qint32 chunkSize) { QString path = QStringLiteral("/dev/") + name; QStringList args = { QStringLiteral("--create"), path, QStringLiteral("--level=") + QString::number(raidLevel), QStringLiteral("--chunk=") + QString::number(chunkSize), QStringLiteral("--raid-devices=") + QString::number(devicePathList.size()) }; for (const QString &p : qAsConst(devicePathList)) { eraseDeviceMDSuperblock(p); args << p; } ExternalCommand cmd(report, QStringLiteral("mdadm"), args); if (!cmd.run(-1) || cmd.exitCode() != 0) return false; if (updateConfigurationFile(path)) qDebug() << QStringLiteral("Updated RAID config: ") + path; return true; } bool SoftwareRAID::deleteSoftwareRAID(Report &report, SoftwareRAID &raidDevice) { - Q_UNUSED(report) - Q_UNUSED(raidDevice) + if (raidDevice.status() == SoftwareRAID::Status::Active) + stopSoftwareRAID(report, raidDevice.deviceNode()); - // TODO: Need to stop and remove it from config file - // Erase md superblock for every physical partition of it - // The device should be removed from config file - // according to its UID, not by name + for (const QString& path : raidDevice.deviceNodes()) + eraseDeviceMDSuperblock(path); - return false; + QString config = getRAIDConfiguration(); + + QStringList lines = config.split(QLatin1Char('\n')); + + QString contentUpdated = QStringLiteral("\""); + + for (const QString line : lines) + if (!line.isEmpty() && !line.contains(raidDevice.uuid())) + contentUpdated += line + QLatin1Char('\n'); + + contentUpdated += QLatin1Char('\"'); + + ExternalCommand cmd(QStringLiteral("/usr/") + QStringLiteral(LIBEXECDIRPATH) + QStringLiteral("/kpmcore_mdadmupdateconf"), + { QStringLiteral("--write"), contentUpdated, raidConfigurationFilePath() }); + + return cmd.run(-1) && cmd.exitCode() == 0; } bool SoftwareRAID::assembleSoftwareRAID(const QString& deviceNode) { ExternalCommand cmd(QStringLiteral("mdadm"), { QStringLiteral("--assemble"), QStringLiteral("--scan"), deviceNode, QStringLiteral("--config=") + raidConfigurationFilePath() }); return cmd.run(-1) && cmd.exitCode() == 0; } bool SoftwareRAID::stopSoftwareRAID(Report& report, const QString& deviceNode) { if (!isRaidPath(deviceNode)) return false; ExternalCommand cmd(report, QStringLiteral("mdadm"), { QStringLiteral("--manage"), QStringLiteral("--stop"), deviceNode }); return cmd.run(-1) && cmd.exitCode() == 0; } bool SoftwareRAID::reassembleSoftwareRAID(Report& report, const QString &deviceNode) { // TODO: Include report return stopSoftwareRAID(report, deviceNode) && assembleSoftwareRAID(deviceNode); } QString SoftwareRAID::getRaidArrayName(const QString &partitionPath) { ExternalCommand cmd(QStringLiteral("mdadm"), { QStringLiteral("--misc"), QStringLiteral("--query"), partitionPath }); if (cmd.run(-1) && cmd.exitCode() == 0) { QRegularExpression ex(QStringLiteral("device active raid\\d+\\s([\\/\\w]+).")); QRegularExpressionMatch match = ex.match(cmd.output()); if (match.hasMatch()) return match.captured(1); } return QString(); } void SoftwareRAID::initPartitions() { } qint64 SoftwareRAID::mappedSector(const QString &partitionPath, qint64 sector) const { Q_UNUSED(partitionPath); Q_UNUSED(sector); return -1; } bool SoftwareRAID::eraseDeviceMDSuperblock(const QString &path) { ExternalCommand cmd(QStringLiteral("mdadm"), { QStringLiteral("--misc"), QStringLiteral("--zero-superblock"), path}); return cmd.run(-1) && cmd.exitCode() == 0; } bool SoftwareRAID::updateConfigurationFile(const QString &path) { ExternalCommand cmd(QStringLiteral("/usr/") + QStringLiteral(LIBEXECDIRPATH) + QStringLiteral("/kpmcore_mdadmupdateconf"), - { path, raidConfigurationFilePath() }); + { QStringLiteral("--append"), path, raidConfigurationFilePath() }); return cmd.run(-1) && cmd.exitCode() == 0; } QString SoftwareRAID::getDetail(const QString &path) { ExternalCommand cmd(QStringLiteral("mdadm"), { QStringLiteral("--misc"), QStringLiteral("--detail"), path }); return (cmd.run(-1) && cmd.exitCode() == 0) ? cmd.output() : QString(); } QString SoftwareRAID::getRAIDConfiguration() { QFile config(raidConfigurationFilePath()); if (!config.open(QIODevice::ReadOnly)) return QString(); QTextStream stream(&config); QString result = stream.readAll(); config.close(); return result; } QString SoftwareRAID::getDeviceInformation(const QString &deviceName) { ExternalCommand cmd(QStringLiteral("mdadm"), { QStringLiteral("--misc"), QStringLiteral("--detail"), QStringLiteral("--scan"), deviceName }); // TODO: Get only information about the device line. // Because if there is any error on config file, it will print more information than needed. return (cmd.run(-1) && cmd.exitCode() == 0) ? cmd.output() : QString(); } void SoftwareRAID::setRaidConfigurationFilePath(const QString &filePath) { s_raidConfigurationFile = filePath; } QString SoftwareRAID::raidConfigurationFilePath() { if (s_raidConfigurationFile.isEmpty()) s_raidConfigurationFile = getDefaultRaidConfigFile(); return s_raidConfigurationFile; } QString SoftwareRAID::getDefaultRaidConfigFile() { if (QFile::exists(QStringLiteral("/etc/mdadm.conf"))) return QStringLiteral("/etc/mdadm.conf"); else if (QFile::exists(QStringLiteral("/etc/mdadm/mdadm.conf"))) return QStringLiteral("/etc/mdadm/mdadm.conf"); return QString(); } + +void SoftwareRAID::setPartitionNodes(const QStringList& partitionNodes) +{ + d_ptr->m_partitionPathList = partitionNodes; +} diff --git a/src/core/raid/softwareraid.h b/src/core/raid/softwareraid.h index 8fec188..7e9b58d 100644 --- a/src/core/raid/softwareraid.h +++ b/src/core/raid/softwareraid.h @@ -1,118 +1,119 @@ /************************************************************************* * Copyright (C) 2018 by Caio Carvalho * * * * 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 .* *************************************************************************/ #if !defined(KPMCORE_SOFTWARERAID_H) #define KPMCORE_SOFTWARERAID_H #include "core/volumemanagerdevice.h" #include "util/libpartitionmanagerexport.h" #include "util/report.h" class LIBKPMCORE_EXPORT SoftwareRAID : public VolumeManagerDevice { Q_DISABLE_COPY(SoftwareRAID) public: enum class Status { Active, Inactive, Resync, Recovery, }; SoftwareRAID(const QString& name, SoftwareRAID::Status status = SoftwareRAID::Status::Active, const QString& iconName = QString()); const QStringList deviceNodes() const override; const QStringList& partitionNodes() const override; qint64 partitionSize(QString &partitionPath) const override; virtual bool growArray(Report& report, const QStringList& devices); virtual bool shrinkArray(Report& report, const QStringList& devices); virtual QString prettyName() const override; virtual bool operator==(const Device& other) const override; qint32 raidLevel() const; qint64 chunkSize() const; qint64 totalChunk() const; qint64 arraySize() const; QString uuid() const; - QStringList devicePathList() const; SoftwareRAID::Status status() const; void setStatus(SoftwareRAID::Status status); public: static void scanSoftwareRAID(QList& devices); static qint32 getRaidLevel(const QString& path); static qint64 getChunkSize(const QString& path); static qint64 getTotalChunk(const QString& path); static qint64 getArraySize(const QString& path); static QString getUUID(const QString& path); static QStringList getDevicePathList(const QString& path); static bool isRaidPath(const QString& devicePath); static bool createSoftwareRAID(Report& report, const QString& name, const QStringList devicePathList, const qint32 raidLevel, const qint32 chunkSize); static bool deleteSoftwareRAID(Report& report, SoftwareRAID& raidDevice); static bool assembleSoftwareRAID(const QString& deviceNode); static bool stopSoftwareRAID(Report& report, const QString& deviceNode); static bool reassembleSoftwareRAID(Report& report, const QString& deviceNode); static QString getRaidArrayName(const QString& partitionPath); static void setRaidConfigurationFilePath(const QString& filePath); static QString raidConfigurationFilePath(); static QString getDefaultRaidConfigFile(); protected: void initPartitions() override; qint64 mappedSector(const QString &partitionPath, qint64 sector) const override; private: static bool eraseDeviceMDSuperblock(const QString& path); static bool updateConfigurationFile(const QString& path); static QString getDetail(const QString& path); static QString getRAIDConfiguration(); static QString getDeviceInformation(const QString& deviceName); + void setPartitionNodes(const QStringList& partitionNodes); + private: static QString s_raidConfigurationFile; }; #endif // SOFTWARERAID_H diff --git a/src/jobs/removevolumegroupjob.cpp b/src/jobs/removevolumegroupjob.cpp index 97792f7..7d92065 100644 --- a/src/jobs/removevolumegroupjob.cpp +++ b/src/jobs/removevolumegroupjob.cpp @@ -1,52 +1,55 @@ /************************************************************************* * Copyright (C) 2016 by Chantara Tith * + * Copyright (C) 2018 by Caio Carvalho * * * * 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/removevolumegroupjob.h" #include "core/lvmdevice.h" +#include "core/raid/softwareraid.h" #include "util/report.h" #include /** Creates a new RemoveVolumeGroupJob */ RemoveVolumeGroupJob::RemoveVolumeGroupJob(VolumeManagerDevice& d) : Job(), m_Device(d) { } bool RemoveVolumeGroupJob::run(Report& parent) { bool rval = false; Report* report = jobStarted(parent); - if (device().type() == Device::Type::LVM_Device) { + if (device().type() == Device::Type::LVM_Device) rval = LvmDevice::removeVG(*report, dynamic_cast(device())); - } + else if (device().type() == Device::Type::SoftwareRAID_Device) + rval = SoftwareRAID::deleteSoftwareRAID(*report, dynamic_cast(device())); jobFinished(*report, rval); return rval; } QString RemoveVolumeGroupJob::description() const { - return xi18nc("@info/plain", "Remove Volume Group: %1", device().name()); + return xi18nc("@info/plain", "Remove %1 Volume Group: %2", (device().type() == Device::Type::SoftwareRAID_Device ? QStringLiteral("RAID") : QStringLiteral("LVM")), device().name()); } diff --git a/src/ops/removevolumegroupoperation.cpp b/src/ops/removevolumegroupoperation.cpp index 1c16433..49cf312 100644 --- a/src/ops/removevolumegroupoperation.cpp +++ b/src/ops/removevolumegroupoperation.cpp @@ -1,93 +1,98 @@ /************************************************************************* * 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 "ops/removevolumegroupoperation.h" #include "jobs/removevolumegroupjob.h" #include "core/lvmdevice.h" #include "core/partition.h" #include "core/partitiontable.h" #include "core/volumemanagerdevice.h" +#include "core/raid/softwareraid.h" #include #include /** Creates a new RemoveVolumeGroupOperation. */ RemoveVolumeGroupOperation::RemoveVolumeGroupOperation(VolumeManagerDevice& d) : Operation(), m_RemoveVolumeGroupJob(new RemoveVolumeGroupJob(d)), m_Device(d), m_PartitionTable(nullptr) { addJob(removeVolumeGroupJob()); } QString RemoveVolumeGroupOperation::description() const { - return xi18nc("@info/plain", "Remove a LVM volume group."); + return xi18nc("@info/plain", "Remove a %1 volume group.", (device().type() == Device::Type::SoftwareRAID_Device ? QStringLiteral("RAID") : QStringLiteral("LVM"))); } void RemoveVolumeGroupOperation::preview() { m_PartitionTable = device().partitionTable(); if (device().type() == Device::Type::LVM_Device) { LvmDevice& lvm = static_cast(device()); LvmDevice::s_OrphanPVs << lvm.physicalVolumes(); } device().setPartitionTable(new PartitionTable(PartitionTable::vmd, 0, device().totalLogical() - 1)); } void RemoveVolumeGroupOperation::undo() { if (device().type() == Device::Type::LVM_Device) { LvmDevice& lvm = static_cast(device()); const QVector constOrphanList = LvmDevice::s_OrphanPVs; for (const Partition* p : constOrphanList) if (lvm.physicalVolumes().contains(p)) LvmDevice::s_OrphanPVs.removeAll(p); } device().setPartitionTable(m_PartitionTable); } /** Check if Volume Group can be safely removed * * @param dev VolumeManagerDevice with initialized partitions * @return true if there are no LVM partitions. */ bool RemoveVolumeGroupOperation::isRemovable(const VolumeManagerDevice* dev) { // TODO: allow removal when LVs are inactive. if (dev->type() == Device::Type::LVM_Device) { if (dev->partitionTable()->children().count() == 0) // This is necessary to prevent a crash during applying of operations return true; else if (dev->partitionTable()->children().count() > 1) return false; else if (dev->partitionTable()->children().first()->fileSystem().type() == FileSystem::Type::Unknown) return true; } + else if (dev->type() == Device::Type::SoftwareRAID_Device) { + const SoftwareRAID* raid = static_cast(dev); + return raid->status() == SoftwareRAID::Status::Inactive; + } return false; } diff --git a/src/ops/removevolumegroupoperation.h b/src/ops/removevolumegroupoperation.h index 12e78a1..c20fb5d 100644 --- a/src/ops/removevolumegroupoperation.h +++ b/src/ops/removevolumegroupoperation.h @@ -1,76 +1,77 @@ /************************************************************************* * 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 .* *************************************************************************/ #if !defined(KPMCORE_REMOVEVOLUMEGROUPOPERATION_H) #define KPMCORE_REMOVEVOLUMEGROUPOPERATION_H #include "util/libpartitionmanagerexport.h" #include "ops/operation.h" #include class PartitionTable; class RemoveVolumeGroupJob; class VolumeManagerDevice; class OperationStack; class LIBKPMCORE_EXPORT RemoveVolumeGroupOperation : public Operation { Q_DISABLE_COPY(RemoveVolumeGroupOperation) friend class OperationStack; public: RemoveVolumeGroupOperation(VolumeManagerDevice& d); public: QString iconName() const override { return QStringLiteral("edit-delete"); } QString description() const override; virtual bool targets(const Device&) const override { return true; } + virtual bool targets(const Partition&) const override { return false; } virtual void preview() override; virtual void undo() override; static bool isRemovable(const VolumeManagerDevice* dev); protected: - RemoveVolumeGroupJob* removeVolumeGroupJob() { + RemoveVolumeGroupJob* removeVolumeGroupJob() const { return m_RemoveVolumeGroupJob; } - VolumeManagerDevice& device() { + VolumeManagerDevice& device() const { return m_Device; } private: RemoveVolumeGroupJob* m_RemoveVolumeGroupJob; VolumeManagerDevice& m_Device; PartitionTable* m_PartitionTable; }; #endif diff --git a/src/util/mdadmupdateconf.cpp b/src/util/mdadmupdateconf.cpp index 783a562..a8fce70 100644 --- a/src/util/mdadmupdateconf.cpp +++ b/src/util/mdadmupdateconf.cpp @@ -1,16 +1,26 @@ #include #include +#include + +using namespace std; using std::string; int main(int argc, char *argv[]) { - if (argc != 3) + if (argc != 4) return 1; - string command = "mdadm --detail --scan " + string(argv[1]) + " >> " + string(argv[2]); + if (string(argv[1]) == "--append") { + string command = "mdadm --detail --scan " + string(argv[2]) + " >> " + string(argv[3]); + + system(command.c_str()); + } + else if (string(argv[1]) == "--write") { + string command = "echo " + string(argv[2]) + " > " + string(argv[3]); - system(command.c_str()); + system(command.c_str()); + } return 0; }