diff --git a/src/core/raid/softwareraid.cpp b/src/core/raid/softwareraid.cpp
index 4baf1d8..e30fd02 100644
--- a/src/core/raid/softwareraid.cpp
+++ b/src/core/raid/softwareraid.cpp
@@ -1,381 +1,392 @@
 /*************************************************************************
  *  Copyright (C) 2018 by Caio Carvalho <caiojcarvalho@gmail.com>        *
  *                                                                       *
  *  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 <http://www.gnu.org/licenses/>.*
  *************************************************************************/
 
 #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 <KLocalizedString>
 #include <QRegularExpression>
 
 #define d_ptr std::static_pointer_cast<SoftwareRAIDPrivate>(d)
 
 class SoftwareRAIDPrivate : public VolumeManagerDevicePrivate
 {
 public:
     qint32 m_raidLevel;
     qint64 m_chunkSize;
     qint64 m_totalChunk;
     qint64 m_arraySize;
     QString m_UUID;
     QStringList m_devicePathList;
-    bool m_active;
+    SoftwareRAID::Status m_status;
 };
 
-SoftwareRAID::SoftwareRAID(const QString& name, bool active, const QString& iconName)
+SoftwareRAID::SoftwareRAID(const QString& name, SoftwareRAID::Status status, const QString& iconName)
     : VolumeManagerDevice(std::make_shared<SoftwareRAIDPrivate>(),
                           name,
                           (QStringLiteral("/dev/") + name),
                           getChunkSize(QStringLiteral("/dev/") + name),
                           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_active = active;
+    d_ptr->m_status = status;
 
     initPartitions();
 }
 
 const QStringList SoftwareRAID::deviceNodes() const
 {
     return d_ptr->m_devicePathList;
 }
 
 const QStringList& SoftwareRAID::partitionNodes() const
 {
     return {};
 }
 
 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
 {
-    return VolumeManagerDevice::prettyName() +
-            (isActive() ? xi18nc("@item:inlistbox [RAID level]", " [RAID %1]", raidLevel()) :
-                          QStringLiteral(" [RAID]"));
+    QString raidInfo;
+
+    if (status() != SoftwareRAID::Status::Inactive)
+        raidInfo = xi18nc("@item:inlistbox [RAID level]", " [RAID %1]", 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<const SoftwareRAID&>(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;
 }
 
-bool SoftwareRAID::isActive() const
+SoftwareRAID::Status SoftwareRAID::status() const
 {
-    return d_ptr->m_active;
+    return d_ptr->m_status;
 }
 
-void SoftwareRAID::setActive(bool active)
+void SoftwareRAID::setStatus(SoftwareRAID::Status status)
 {
-    d_ptr->m_active = active;
+    d_ptr->m_status = status;
 }
 
 void SoftwareRAID::scanSoftwareRAID(QList<Device*>& devices)
 {
     QList<Device *> scannedRaid;
 
     // TODO: Support custom config files.
     QString config = getRAIDConfiguration(QStringLiteral("/etc/mdadm.conf"));
 
     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();
 
-            SoftwareRAID *raidDevice = new SoftwareRAID(deviceName, false);
+            SoftwareRAID *raidDevice = new SoftwareRAID(deviceName,
+                                                        SoftwareRAID::Status::Inactive);
 
             scannedRaid << raidDevice;
         }
     }
 
     ExternalCommand scanRaid(QStringLiteral("cat"), { QStringLiteral("/proc/mdstat") });
 
     if (scanRaid.run(-1) && scanRaid.exitCode() == 0) {
         QRegularExpression re(QStringLiteral("md([\\/\\w]+)\\s+:\\s+([\\w]+)"));
         QRegularExpressionMatchIterator i  = re.globalMatch(scanRaid.output());
         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<SoftwareRAID *>(CoreBackendManager::self()->backend()->scanDevice(deviceNode));
 
             if (scannedRaid.contains(d)) {
-                d->setActive(status.toLower() == QStringLiteral("active"));
+                if (status == QStringLiteral("inactive"))
+                    d->setStatus(SoftwareRAID::Status::Inactive);
+            }
+            else
+                scannedRaid << d;
 
-                if (d->raidLevel() > 0) {
-                    QRegularExpression reMirrorStatus(QStringLiteral("\\[[=>.]+\\]\\s+(resync|recovery)"));
+            if (d->raidLevel() > 0) {
+                QRegularExpression reMirrorStatus(QStringLiteral("\\[[=>.]+\\]\\s+(resync|recovery)"));
 
-                    QRegularExpressionMatch reMirrorStatusMatch = reMirrorStatus.match(scanRaid.output());
+                QRegularExpressionMatch reMirrorStatusMatch = reMirrorStatus.match(scanRaid.output());
 
-                    if (reMirrorStatusMatch.hasMatch())
-                        d->setActive(false);
+                if (reMirrorStatusMatch.hasMatch()) {
+                    if (reMirrorStatusMatch.captured(1) == QStringLiteral("resync"))
+                        d->setStatus(SoftwareRAID::Status::Resync);
+                    else if (reMirrorStatusMatch.captured(1) == QStringLiteral("recovery"))
+                        d->setStatus(SoftwareRAID::Status::Recovery);
                 }
             }
-            else
-                scannedRaid << d;
         }
     }
 
     devices << scannedRaid;
 }
 
 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).toLongLong();
     }
 
     return -1;
 }
 
 qint64 SoftwareRAID::getChunkSize(const QString &path)
 {
     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(QStringLiteral("/etc/mdadm.conf"));
 
     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)
 {
     Q_UNUSED(path)
     return {};
 }
 
 bool SoftwareRAID::isRaidPath(const QString &path)
 {
     return !getDetail(path).isEmpty();
 }
 
 bool SoftwareRAID::createSoftwareRAID(Report &report,
                                       const QString &name,
                                       const QStringList devicePathList,
                                       const qint32 raidLevel,
                                       const qint32 chunkSize)
 {
     return false;
 }
 
 bool SoftwareRAID::deleteSoftwareRAID(Report &report,
                                       SoftwareRAID &raidDevice)
 {
     Q_UNUSED(report)
     Q_UNUSED(raidDevice)
     return false;
 }
 
 bool SoftwareRAID::assembleSoftwareRAID(const QString& deviceNode)
 {
     if (!isRaidPath(deviceNode))
         return false;
 
     ExternalCommand cmd(QStringLiteral("mdadm"),
                         { QStringLiteral("--assemble"), QStringLiteral("--scan"), deviceNode });
 
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool SoftwareRAID::stopSoftwareRAID(const QString& deviceNode)
 {
     if (!isRaidPath(deviceNode))
         return false;
 
     ExternalCommand cmd(QStringLiteral("mdadm"),
                         { QStringLiteral("--manage"), QStringLiteral("--stop"), deviceNode });
 
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool SoftwareRAID::reassembleSoftwareRAID(const QString &deviceNode)
 {
     return stopSoftwareRAID(deviceNode) && assembleSoftwareRAID(deviceNode);
 }
 
 void SoftwareRAID::initPartitions()
 {
 
 }
 
 qint64 SoftwareRAID::mappedSector(const QString &partitionPath, qint64 sector) const
 {
     return -1;
 }
 
 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(const QString &configurationPath)
 {
     ExternalCommand cmd(QStringLiteral("cat"), { configurationPath });
 
     return (cmd.run(-1) && cmd.exitCode() == 0) ? cmd.output() : QString();
 }
diff --git a/src/core/raid/softwareraid.h b/src/core/raid/softwareraid.h
index 6fd56ee..a33c5d3 100644
--- a/src/core/raid/softwareraid.h
+++ b/src/core/raid/softwareraid.h
@@ -1,92 +1,101 @@
 /*************************************************************************
  *  Copyright (C) 2018 by Caio Carvalho <caiojcarvalho@gmail.com>        *
  *                                                                       *
  *  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 <http://www.gnu.org/licenses/>.*
  *************************************************************************/
 
 #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:
-    SoftwareRAID(const QString& name, bool active = true, const QString& iconName = QString());
+    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;
-    bool isActive() const;
+    SoftwareRAID::Status status() const;
 
-    void setActive(bool active);
+    void setStatus(SoftwareRAID::Status status);
 
 public:
     static void scanSoftwareRAID(QList<Device*>& 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& path);
 
     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(const QString& deviceNode);
 
     static bool reassembleSoftwareRAID(const QString& deviceNode);
 
 protected:
     void initPartitions() override;
 
     qint64 mappedSector(const QString &partitionPath, qint64 sector) const override;
 
 private:
     static QString getDetail(const QString& path);
 
     static QString getRAIDConfiguration(const QString& configurationPath);
 };
 
 #endif // SOFTWARERAID_H
diff --git a/src/ops/createpartitiontableoperation.cpp b/src/ops/createpartitiontableoperation.cpp
index 57b5738..f68b122 100644
--- a/src/ops/createpartitiontableoperation.cpp
+++ b/src/ops/createpartitiontableoperation.cpp
@@ -1,114 +1,114 @@
 /*************************************************************************
  *  Copyright (C) 2008, 2010 by Volker Lanz <vl@fidra.de>                *
  *  Copyright (C) 2016 by Andrius Štikonas <andrius@stikonas.eu>         *
  *                                                                       *
  *  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 <http://www.gnu.org/licenses/>.*
  *************************************************************************/
 
 #include "ops/createpartitiontableoperation.h"
 
 #include "core/device.h"
 #include "core/partitiontable.h"
 #include "core/partition.h"
 #include "core/raid/softwareraid.h"
 
 #include "jobs/createpartitiontablejob.h"
 
 #include <QString>
 
 #include <KLocalizedString>
 
 /** Creates a new CreatePartitionTableOperation.
     @param d the Device to create the new PartitionTable on
     @param t the type for the new PartitionTable
 */
 CreatePartitionTableOperation::CreatePartitionTableOperation(Device& d, PartitionTable::TableType t) :
     Operation(),
     m_TargetDevice(d),
     m_OldPartitionTable(targetDevice().partitionTable()),
     m_PartitionTable(new PartitionTable(t, PartitionTable::defaultFirstUsable(d, t), PartitionTable::defaultLastUsable(d, t))),
     m_CreatePartitionTableJob(new CreatePartitionTableJob(targetDevice()))
 {
     addJob(createPartitionTableJob());
 }
 
 /** Creates a new CreatePartitionTableOperation.
     @param d the Device to create the new PartitionTable on
     @param ptable pointer to the new partition table object. the operation takes ownership.
 */
 CreatePartitionTableOperation::CreatePartitionTableOperation(Device& d, PartitionTable* ptable) :
     Operation(),
     m_TargetDevice(d),
     m_OldPartitionTable(targetDevice().partitionTable()),
     m_PartitionTable(ptable),
     m_CreatePartitionTableJob(new CreatePartitionTableJob(targetDevice()))
 {
     addJob(createPartitionTableJob());
 }
 
 CreatePartitionTableOperation::~CreatePartitionTableOperation()
 {
     if (status() == StatusPending)
         delete m_PartitionTable;
 }
 
 bool CreatePartitionTableOperation::targets(const Device& d) const
 {
     return d == targetDevice();
 }
 
 void CreatePartitionTableOperation::preview()
 {
     targetDevice().setPartitionTable(partitionTable());
     targetDevice().partitionTable()->updateUnallocated(targetDevice());
 }
 
 void CreatePartitionTableOperation::undo()
 {
     targetDevice().setPartitionTable(oldPartitionTable());
 
     if (targetDevice().partitionTable())
         targetDevice().partitionTable()->updateUnallocated(targetDevice());
 }
 
 bool CreatePartitionTableOperation::execute(Report& parent)
 {
     targetDevice().setPartitionTable(partitionTable());
     return Operation::execute(parent);
 }
 
 /** Can a new partition table be created on a device?
     @param device pointer to the device, can be nullptr
     @return true if a new partition table can be created on @p device
 */
 bool CreatePartitionTableOperation::canCreate(const Device* device)
 {
     if (device == nullptr)
         return false;
 
     if (device->type() == Device::Type::SoftwareRAID_Device) {
         const SoftwareRAID* raid = static_cast<const SoftwareRAID *>(device);
 
-        if (!raid->isActive())
+        if (raid->status() == SoftwareRAID::Status::Inactive)
             return false;
     }
 
     return (device->partitionTable() == nullptr || !device->partitionTable()->isChildMounted())
             && (device->type() != Device::Type::LVM_Device);
 }
 
 QString CreatePartitionTableOperation::description() const
 {
     return xi18nc("@info:status", "Create a new partition table (type: %1) on <filename>%2</filename>", partitionTable()->typeName(), targetDevice().deviceNode());
 }
diff --git a/src/plugins/sfdisk/sfdiskbackend.cpp b/src/plugins/sfdisk/sfdiskbackend.cpp
index bd454b9..de78602 100644
--- a/src/plugins/sfdisk/sfdiskbackend.cpp
+++ b/src/plugins/sfdisk/sfdiskbackend.cpp
@@ -1,497 +1,495 @@
 /*************************************************************************
   *  Copyright (C) 2017 by Andrius Štikonas <andrius@stikonas.eu>        *
  *                                                                       *
  *  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 <http://www.gnu.org/licenses/>.*
  *************************************************************************/
 
 /** @file
 */
 
 #include "plugins/sfdisk/sfdiskbackend.h"
 #include "plugins/sfdisk/sfdiskdevice.h"
 
 #include "core/diskdevice.h"
 #include "core/lvmdevice.h"
 #include "core/partitiontable.h"
 #include "core/partitionalignment.h"
 #include "core/raid/softwareraid.h"
 
 #include "fs/filesystemfactory.h"
 #include "fs/luks.h"
 #include "fs/luks2.h"
 
 #include "util/globallog.h"
 #include "util/externalcommand.h"
 #include "util/helpers.h"
 
 #include <QDataStream>
 #include <QDebug>
 #include <QFile>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QRegularExpression>
 #include <QStorageInfo>
 #include <QString>
 #include <QStringList>
 
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 K_PLUGIN_FACTORY_WITH_JSON(SfdiskBackendFactory, "pmsfdiskbackendplugin.json", registerPlugin<SfdiskBackend>();)
 
 SfdiskBackend::SfdiskBackend(QObject*, const QList<QVariant>&) :
     CoreBackend()
 {
 }
 
 void SfdiskBackend::initFSSupport()
 {
 }
 
 QList<Device*> SfdiskBackend::scanDevices(bool excludeReadOnly)
 {
 //  TODO: add another bool option for loopDevices
     QList<Device*> result;
     QStringList deviceNodes;
 
     ExternalCommand cmd(QStringLiteral("lsblk"),
                         { QStringLiteral("--nodeps"),
                           QStringLiteral("--paths"),
                           QStringLiteral("--sort"), QStringLiteral("name"),
                           QStringLiteral("--json"),
                           QStringLiteral("--output"),
                           QStringLiteral("type,name") });
 
     if (cmd.run(-1) && cmd.exitCode() == 0) {
         const QJsonDocument jsonDocument = QJsonDocument::fromJson(cmd.rawOutput());
         const QJsonObject jsonObject = jsonDocument.object();
         const QJsonArray jsonArray = jsonObject[QLatin1String("blockdevices")].toArray();
         for (const auto &deviceLine : jsonArray) {
             QJsonObject deviceObject = deviceLine.toObject();
             if (deviceObject[QLatin1String("type")].toString() != QLatin1String("disk"))
                 continue;
 
             const QString deviceNode = deviceObject[QLatin1String("name")].toString();
             if (excludeReadOnly) {
                 QString deviceName = deviceNode;
                 deviceName.remove(QStringLiteral("/dev/"));
                 QFile f(QStringLiteral("/sys/block/%1/ro").arg(deviceName));
                 if (f.open(QIODevice::ReadOnly))
                     if (f.readLine().trimmed().toInt() == 1)
                         continue;
             }
             deviceNodes << deviceNode;
         }
 
         int totalDevices = deviceNodes.length();
         for (int i = 0; i < totalDevices; ++i) {
             const QString deviceNode = deviceNodes[i];
 
             emitScanProgress(deviceNode, i * 100 / totalDevices);
             Device* device = scanDevice(deviceNode);
             if (device != nullptr) {
                 result.append(device);
             }
         }
 
         SoftwareRAID::scanSoftwareRAID(result);
         LvmDevice::scanSystemLVM(result); // LVM scanner needs all other devices, so should be last
     }
 
     return result;
 }
 
 /** Create a Device for the given device_node and scan it for partitions.
     @param deviceNode the device node (e.g. "/dev/sda")
     @return the created Device object. callers need to free this.
 */
 Device* SfdiskBackend::scanDevice(const QString& deviceNode)
 {
     ExternalCommand modelCommand(QStringLiteral("lsblk"),
                         { QStringLiteral("--nodeps"),
                           QStringLiteral("--noheadings"),
                           QStringLiteral("--output"), QStringLiteral("model"),
                           deviceNode });
     ExternalCommand sizeCommand(QStringLiteral("blockdev"), { QStringLiteral("--getsize64"), deviceNode });
     ExternalCommand sizeCommand2(QStringLiteral("blockdev"), { QStringLiteral("--getss"), deviceNode });
     ExternalCommand jsonCommand(QStringLiteral("sfdisk"), { QStringLiteral("--json"), deviceNode } );
 
     if ( sizeCommand.run(-1) && sizeCommand.exitCode() == 0
          && sizeCommand2.run(-1) && sizeCommand2.exitCode() == 0
          && jsonCommand.run(-1) )
     {
         Device* d = nullptr;
         qint64 deviceSize = sizeCommand.output().trimmed().toLongLong();
         int logicalSectorSize = sizeCommand2.output().trimmed().toLongLong();
 
-        if ( modelCommand.run(-1) && modelCommand.exitCode() == 0 )
+        ExternalCommand softwareRaidCommand(QStringLiteral("mdadm"), { QStringLiteral("--detail"), deviceNode });
+
+        if ( softwareRaidCommand.run(-1) && softwareRaidCommand.exitCode() == 0 )
         {
-            QString modelName = modelCommand.output();
-            modelName = modelName.left(modelName.length() - 1);
+            Log(Log::Level::information) << xi18nc("@info:status", "Software RAID Device found: %1", deviceNode);
 
-            Log(Log::Level::information) << xi18nc("@info:status", "Disk Device found: %1", modelName);
+            QString deviceName = deviceNode.mid(5);
 
-            d = new DiskDevice(modelName, deviceNode, 255, 63, deviceSize / logicalSectorSize / 255 / 63, logicalSectorSize);
+            d = new SoftwareRAID( deviceName, SoftwareRAID::Status::Active );
         }
-        else // check for software raid
-        {
-            ExternalCommand softwareRaidCommand(QStringLiteral("mdadm"), { QStringLiteral("--detail"), deviceNode });
 
-            if ( softwareRaidCommand.run(-1) && softwareRaidCommand.exitCode() == 0 )
-            {
-                Log(Log::Level::information) << xi18nc("@info:status", "Software RAID Device found: %1", deviceNode);
+        if ( d == nullptr && modelCommand.run(-1) && modelCommand.exitCode() == 0 )
+        {
+            QString modelName = modelCommand.output();
+            modelName = modelName.left(modelName.length() - 1);
 
-                QString deviceName = deviceNode.mid(5);
+            Log(Log::Level::information) << xi18nc("@info:status", "Disk Device found: %1", modelName);
 
-                d = new SoftwareRAID( deviceName );
-            }
+            d = new DiskDevice(modelName, deviceNode, 255, 63, deviceSize / logicalSectorSize / 255 / 63, logicalSectorSize);
         }
 
         if ( d )
         {
             if (jsonCommand.exitCode() != 0)
                 return d;
 
             const QJsonObject jsonObject = QJsonDocument::fromJson(jsonCommand.rawOutput()).object();
             const QJsonObject partitionTable = jsonObject[QLatin1String("partitiontable")].toObject();
 
             if (!updateDevicePartitionTable(*d, partitionTable))
                 return nullptr;
 
             return d;
         }
     }
     else
     {
         // Look if this device is a LVM VG
         ExternalCommand checkVG(QStringLiteral("lvm"), { QStringLiteral("vgdisplay"), deviceNode });
 
         if (checkVG.run(-1) && checkVG.exitCode() == 0)
         {
             qDebug() << "Trying to find LVM VG";
             QList<Device *> availableDevices = scanDevices();
 
             LvmDevice::scanSystemLVM(availableDevices);
 
             for (Device *device : qAsConst(availableDevices))
                 if (device->deviceNode() == deviceNode)
                     return device;
         }
     }
     return nullptr;
 }
 
 /** Scans a Device for Partitions.
 
     This method  will scan a Device for all Partitions on it, detect the FileSystem for each Partition,
     try to determine the FileSystem usage, read the FileSystem label and store it all in newly created
     objects that are in the end added to the Device's PartitionTable.
 */
 void SfdiskBackend::scanDevicePartitions(Device& d, const QJsonArray& jsonPartitions)
 {
     Q_ASSERT(d.partitionTable());
 
     QList<Partition*> partitions;
     for (const auto &partition : jsonPartitions) {
         const QJsonObject partitionObject = partition.toObject();
         const QString partitionNode = partitionObject[QLatin1String("node")].toString();
         const qint64 start = partitionObject[QLatin1String("start")].toVariant().toLongLong();
         const qint64 size = partitionObject[QLatin1String("size")].toVariant().toLongLong();
         const QString partitionType = partitionObject[QLatin1String("type")].toString();
         PartitionTable::Flag activeFlags = partitionObject[QLatin1String("bootable")].toBool() ? PartitionTable::FlagBoot : PartitionTable::FlagNone;
 
         if (partitionType == QStringLiteral("C12A7328-F81F-11D2-BA4B-00A0C93EC93B"))
             activeFlags = PartitionTable::FlagEsp;
         else if (partitionType == QStringLiteral("21686148-6449-6E6F-744E-656564454649"))
             activeFlags = PartitionTable::FlagBiosGrub;
 
         FileSystem::Type type = FileSystem::Type::Unknown;
         type = detectFileSystem(partitionNode);
         PartitionRole::Roles r = PartitionRole::Primary;
 
         if ( (d.partitionTable()->type() == PartitionTable::msdos || d.partitionTable()->type() == PartitionTable::msdos_sectorbased) && partitionType.toInt() == 5 ) {
             r = PartitionRole::Extended;
             type = FileSystem::Type::Extended;
         }
 
         // Find an extended partition this partition is in.
         PartitionNode* parent = d.partitionTable()->findPartitionBySector(start, PartitionRole(PartitionRole::Extended));
 
         // None found, so it's a primary in the device's partition table.
         if (parent == nullptr)
             parent = d.partitionTable();
         else
             r = PartitionRole::Logical;
 
         FileSystem* fs = FileSystemFactory::create(type, start, start + size - 1, d.logicalSize());
         fs->scan(partitionNode);
 
         QString mountPoint;
         bool mounted;
         // sfdisk does not handle LUKS partitions
         if (fs->type() == FileSystem::Type::Luks || fs->type() == FileSystem::Type::Luks2) {
             r |= PartitionRole::Luks;
             FS::luks* luksFs = static_cast<FS::luks*>(fs);
             luksFs->initLUKS();
             QString mapperNode = luksFs->mapperName();
             mountPoint = FileSystem::detectMountPoint(fs, mapperNode);
             mounted    = FileSystem::detectMountStatus(fs, mapperNode);
         } else {
             mountPoint = FileSystem::detectMountPoint(fs, partitionNode);
             mounted = FileSystem::detectMountStatus(fs, partitionNode);
         }
 
         Partition* part = new Partition(parent, d, PartitionRole(r), fs, start, start + size - 1, partitionNode, availableFlags(d.partitionTable()->type()), mountPoint, mounted, activeFlags);
 
         if (!part->roles().has(PartitionRole::Luks))
             readSectorsUsed(d, *part, mountPoint);
 
         if (fs->supportGetLabel() != FileSystem::cmdSupportNone)
             fs->setLabel(fs->readLabel(part->deviceNode()));
 
         if (d.partitionTable()->type() == PartitionTable::TableType::gpt) {
             part->setLabel(partitionObject[QLatin1String("name")].toString());
             part->setUUID(partitionObject[QLatin1String("uuid")].toString());
         }
 
         if (fs->supportGetUUID() != FileSystem::cmdSupportNone)
             fs->setUUID(fs->readUUID(part->deviceNode()));
 
         parent->append(part);
         partitions.append(part);
     }
 
     d.partitionTable()->updateUnallocated(d);
 
     if (d.partitionTable()->isSectorBased(d))
         d.partitionTable()->setType(d, PartitionTable::msdos_sectorbased);
 
     for (const Partition * part : qAsConst(partitions))
         PartitionAlignment::isAligned(d, *part);
 }
 
 bool SfdiskBackend::updateDevicePartitionTable(Device &d, const QJsonObject &jsonPartitionTable)
 {
     QString tableType = jsonPartitionTable[QLatin1String("label")].toString();
     const PartitionTable::TableType type = PartitionTable::nameToTableType(tableType);
 
     qint64 firstUsableSector = 0, lastUsableSector;
 
     if ( d.type() == Device::Type::Disk_Device )
     {
         const DiskDevice* diskDevice = static_cast<const DiskDevice*>(&d);
 
         lastUsableSector = diskDevice->totalSectors();
     }
     else if ( d.type() == Device::Type::SoftwareRAID_Device )
     {
         const SoftwareRAID* raidDevice = static_cast<const SoftwareRAID*>(&d);
 
         lastUsableSector = raidDevice->totalLogical() - 1;
     }
 
     if (type == PartitionTable::gpt) {
         firstUsableSector = jsonPartitionTable[QLatin1String("firstlba")].toVariant().toLongLong();
         lastUsableSector = jsonPartitionTable[QLatin1String("lastlba")].toVariant().toLongLong();
     }
 
     if (lastUsableSector < firstUsableSector) {
         return false;
     }
 
     setPartitionTableForDevice(d, new PartitionTable(type, firstUsableSector, lastUsableSector));
     switch (type) {
     case PartitionTable::gpt:
     {
         // Read the maximum number of GPT partitions
         qint32 maxEntries;
         ExternalCommand ddCommand(QStringLiteral("dd"),
                                  { QStringLiteral("skip=1"), QStringLiteral("count=1"), (QStringLiteral("if=") + d.deviceNode()) },
                                   QProcess::SeparateChannels);
         if (ddCommand.run(-1) && ddCommand.exitCode() == 0 ) {
             QByteArray gptHeader = ddCommand.rawOutput();
             QByteArray gptMaxEntries = gptHeader.mid(80, 4);
             QDataStream stream(&gptMaxEntries, QIODevice::ReadOnly);
             stream.setByteOrder(QDataStream::LittleEndian);
             stream >> maxEntries;
         }
         else
             maxEntries = 128;
         CoreBackend::setPartitionTableMaxPrimaries(*d.partitionTable(), maxEntries);
     }
     default:
         break;
     }
 
     scanDevicePartitions(d, jsonPartitionTable[QLatin1String("partitions")].toArray());
 
     return true;
 }
 
 /** Reads the sectors used in a FileSystem and stores the result in the Partition's FileSystem object.
     @param p the Partition the FileSystem is on
     @param mountPoint mount point of the partition in question
 */
 void SfdiskBackend::readSectorsUsed(const Device& d, Partition& p, const QString& mountPoint)
 {
     if (!mountPoint.isEmpty() && p.fileSystem().type() != FileSystem::Type::LinuxSwap && p.fileSystem().type() != FileSystem::Type::Lvm2_PV) {
         const QStorageInfo storage = QStorageInfo(mountPoint);
         if (p.isMounted() && storage.isValid())
             p.fileSystem().setSectorsUsed( (storage.bytesTotal() - storage.bytesFree()) / d.logicalSize());
     }
     else if (p.fileSystem().supportGetUsed() == FileSystem::cmdSupportFileSystem)
         p.fileSystem().setSectorsUsed(p.fileSystem().readUsedCapacity(p.deviceNode()) / d.logicalSize());
 }
 
 FileSystem::Type SfdiskBackend::detectFileSystem(const QString& partitionPath)
 {
     FileSystem::Type rval = FileSystem::Type::Unknown;
 
     ExternalCommand udevCommand(QStringLiteral("udevadm"), {
                                  QStringLiteral("info"),
                                  QStringLiteral("--query=property"),
                                  partitionPath });
 
     if (udevCommand.run(-1) && udevCommand.exitCode() == 0) {
         QRegularExpression re(QStringLiteral("ID_FS_TYPE=(\\w+)"));
         QRegularExpression re2(QStringLiteral("ID_FS_VERSION=(\\w+)"));
         QRegularExpressionMatch reFileSystemType = re.match(udevCommand.output());
         QRegularExpressionMatch reFileSystemVersion = re2.match(udevCommand.output());
 
         QString s;
         if (reFileSystemType.hasMatch()) {
             s = reFileSystemType.captured(1);
         }
 
         QString version;
         if (reFileSystemVersion.hasMatch()) {
             version = reFileSystemVersion.captured(1);
         }
 
         if (s == QStringLiteral("ext2")) rval = FileSystem::Type::Ext2;
         else if (s == QStringLiteral("ext3")) rval = FileSystem::Type::Ext3;
         else if (s.startsWith(QStringLiteral("ext4"))) rval = FileSystem::Type::Ext4;
         else if (s == QStringLiteral("swap")) rval = FileSystem::Type::LinuxSwap;
         else if (s == QStringLiteral("ntfs-3g")) rval = FileSystem::Type::Ntfs;
         else if (s == QStringLiteral("reiserfs")) rval = FileSystem::Type::ReiserFS;
         else if (s == QStringLiteral("reiser4")) rval = FileSystem::Type::Reiser4;
         else if (s == QStringLiteral("xfs")) rval = FileSystem::Type::Xfs;
         else if (s == QStringLiteral("jfs")) rval = FileSystem::Type::Jfs;
         else if (s == QStringLiteral("hfs")) rval = FileSystem::Type::Hfs;
         else if (s == QStringLiteral("hfsplus")) rval = FileSystem::Type::HfsPlus;
         else if (s == QStringLiteral("ufs")) rval = FileSystem::Type::Ufs;
         else if (s == QStringLiteral("vfat")) {
             if (version == QStringLiteral("FAT32"))
                 rval = FileSystem::Type::Fat32;
             else if (version == QStringLiteral("FAT16"))
                 rval = FileSystem::Type::Fat16;
             else if (version == QStringLiteral("FAT12"))
                 rval = FileSystem::Type::Fat12;
         }
         else if (s == QStringLiteral("btrfs")) rval = FileSystem::Type::Btrfs;
         else if (s == QStringLiteral("ocfs2")) rval = FileSystem::Type::Ocfs2;
         else if (s == QStringLiteral("zfs_member")) rval = FileSystem::Type::Zfs;
         else if (s == QStringLiteral("hpfs")) rval = FileSystem::Type::Hpfs;
         else if (s == QStringLiteral("crypto_LUKS")) {
             if (version == QStringLiteral("1"))
                 rval = FileSystem::Type::Luks;
             else if (version == QStringLiteral("2")) {
                 rval = FileSystem::Type::Luks2;
             }
         }
         else if (s == QStringLiteral("exfat")) rval = FileSystem::Type::Exfat;
         else if (s == QStringLiteral("nilfs2")) rval = FileSystem::Type::Nilfs2;
         else if (s == QStringLiteral("LVM2_member")) rval = FileSystem::Type::Lvm2_PV;
         else if (s == QStringLiteral("f2fs")) rval = FileSystem::Type::F2fs;
         else if (s == QStringLiteral("udf")) rval = FileSystem::Type::Udf;
         else if (s == QStringLiteral("iso9660")) rval = FileSystem::Type::Iso9660;
         else
             qWarning() << "unknown file system type " << s << " on " << partitionPath;
     }
 
     return rval;
 }
 
 QString SfdiskBackend::readLabel(const QString& deviceNode) const
 {
     ExternalCommand udevCommand(QStringLiteral("udevadm"), {
                                  QStringLiteral("info"),
                                  QStringLiteral("--query=property"),
                                  deviceNode });
     udevCommand.run();
     QRegularExpression re(QStringLiteral("ID_FS_LABEL=(.*)"));
     QRegularExpressionMatch reFileSystemLabel = re.match(udevCommand.output());
     if (reFileSystemLabel.hasMatch())
         return reFileSystemLabel.captured(1);
 
     return QString();
 }
 
 QString SfdiskBackend::readUUID(const QString& deviceNode) const
 {
     ExternalCommand udevCommand(QStringLiteral("udevadm"), {
                                  QStringLiteral("info"),
                                  QStringLiteral("--query=property"),
                                  deviceNode });
     udevCommand.run();
     QRegularExpression re(QStringLiteral("ID_FS_UUID=(.*)"));
     QRegularExpressionMatch reFileSystemUUID = re.match(udevCommand.output());
     if (reFileSystemUUID.hasMatch())
         return reFileSystemUUID.captured(1);
 
     return QString();
 }
 
 PartitionTable::Flags SfdiskBackend::availableFlags(PartitionTable::TableType type)
 {
     PartitionTable::Flags flags;
     if (type == PartitionTable::gpt) {
         // These are not really flags but for now keep them for compatibility
         // We should implement changing partition type
         flags = PartitionTable::FlagBiosGrub |
                 PartitionTable::FlagEsp;
     }
     else if (type == PartitionTable::msdos || type == PartitionTable::msdos_sectorbased)
         flags = PartitionTable::FlagBoot;
 
     return flags;
 }
 
 std::unique_ptr<CoreBackendDevice> SfdiskBackend::openDevice(const Device& d)
 {
     std::unique_ptr<SfdiskDevice> device = std::make_unique<SfdiskDevice>(d);
 
     if (!device->open())
         device = nullptr;
 
     return device;
 }
 
 std::unique_ptr<CoreBackendDevice> SfdiskBackend::openDeviceExclusive(const Device& d)
 {
     std::unique_ptr<SfdiskDevice> device = std::make_unique<SfdiskDevice>(d);
 
     if (!device->openExclusive())
         device = nullptr;
 
     return device;
 }
 
 bool SfdiskBackend::closeDevice(std::unique_ptr<CoreBackendDevice> coreDevice)
 {
     return coreDevice->close();
 }
 
 #include "sfdiskbackend.moc"