diff --git a/src/backend/corebackendpartitiontable.h b/src/backend/corebackendpartitiontable.h
index 7335fd4..37b56f0 100644
--- a/src/backend/corebackendpartitiontable.h
+++ b/src/backend/corebackendpartitiontable.h
@@ -1,136 +1,157 @@
 /*************************************************************************
  *  Copyright (C) 2010,2011 by Volker Lanz <vl@fidra.de>                 *
  *                                                                       *
  *  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_COREBACKENDPARTITIONTABLE_H)
 
 #define KPMCORE_COREBACKENDPARTITIONTABLE_H
 
 #include "core/partitiontable.h"
 #include "fs/filesystem.h"
 
 #include <QtGlobal>
 
 class CoreBackendPartition;
 class Report;
 class Partition;
 
 /**
   * Interface class to represent a partition table in the backend.
   * @author Volker Lanz <vl@fidra.de>
   */
 class CoreBackendPartitionTable
 {
 public:
     virtual ~CoreBackendPartitionTable() {}
 
 public:
     /**
       * Open the partition table
       * @return true on success
       */
     virtual bool open() = 0;
 
     /**
       * Commit changes to the partition table to disk and to the OS.
       * @param timeout timeout in seconds to wait for the commit to succeed
       * @return true on success
     */
     virtual bool commit(quint32 timeout = 10) = 0;
 
     /**
       * Delete a partition.
       * @param report the report to write information to
       * @param partition the Partition to delete
       * @return true on success
       */
     virtual bool deletePartition(Report& report, const Partition& partition) = 0;
 
     /**
       * Delete a file system on disk so it cannot be detected anymore.
       * @param report the report to write information to
       * @param partition the Partition for which to clobber the file system
       * @return true on success
       */
     virtual bool clobberFileSystem(Report& report, const Partition& partition) = 0;
 
     /**
       * Resize a file system to a new length.
       * @param report the report to write information to
       * @param partition the partition the FileSystem to resize is on
       * @param newLength the new length for the FileSystem in sectors
       * @return true on success
       */
     virtual bool resizeFileSystem(Report& report, const Partition& partition, qint64 newLength) = 0;
 
     /**
       * Detect which FileSystem is present at a given start sector.
       * @param report the report to write information to
       * @param device the Device on which the FileSystem resides
       * @param sector the sector where to look for a FileSystem
       * @return the detected FileSystem::Type
       */
     virtual FileSystem::Type detectFileSystemBySector(Report& report, const Device& device, qint64 sector) = 0;
 
     /**
       * Create a new partition.
       * @param report the report to write information to
       * @param partition the new partition to create on disk
       * @return the new number the OS sees the partition under (e.g. 7 for "/dev/sda7") or -1 on failure
       */
     virtual QString createPartition(Report& report, const Partition& partition) = 0;
 
     /**
       * Update the geometry for a partition in the partition table.
       * @param report the report to write information to
       * @param partition the partition to update the geometry for
       * @param sector_start the new start sector for the partition
       * @param sector_end the new last sector for the partition
       * @return true on success
       */
     virtual bool updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end) = 0;
 
+    /**
+     * Get the UUID of a partition in the partition table (GPT only).
+     * The partition UUID is known as PARTUUID by several utilities. The device-manager links
+     * the device under /dev/disk/by-partuuid/<uuid>.
+     * @param report the report to write information to
+     * @param partition the partition to get the UUID for
+     * @return the partition UUID
+     */
+    virtual QString getPartitionUUID(Report& report, const Partition& partition) = 0;
+
     /**
      * Set the label of a partition in the partition table (GPT only).
      * The label is set in the GPT partition name entry. The partition name is known as PARTLABEL by
      * several utilities. The device-manager links the device under /dev/disk/by-partlabel/<label>.
      * @param report the report to write information to
      * @param partition the partition to set the label for
      * @param label the new label for the partition
      * @return true on success
      */
     virtual bool setPartitionLabel(Report& report, const Partition& partition, const QString& label) = 0;
 
+    /**
+     * Set the UUID of a partition in the partition table (GPT only).
+     * The partition UUID is known as PARTUUID by several utilities. The device-manager links
+     * the device under /dev/disk/by-partuuid/<uuid>.
+     * @param report the report to write information to
+     * @param partition the partition to set the UUID for
+     * @param uuid the new UUID for the partition
+     * @return true on success
+     */
+    virtual bool setPartitionUUID(Report& report, const Partition& partition, const QString& uuid) = 0;
+
     /**
      * Set the system type (e.g. 83 for Linux) of a partition. The type to set is taken from
      * the partition's file system.
      * @param report the report to write information to
      * @param partition the partition to set the system type for
      * @return true on success
      */
     virtual bool setPartitionSystemType(Report& report, const Partition& partition) = 0;
 
     /**
       * Set a flag for the partition
       * @param report the Report to write information to
       * @param flag the flag to set
       * @param state the state to set the flag to (i.e., on or off)
       * @return true on success
       */
     virtual bool setFlag(Report& report, const Partition& partition, PartitionTable::Flag flag, bool state) = 0;
 };
 
 #endif
diff --git a/src/jobs/CMakeLists.txt b/src/jobs/CMakeLists.txt
index aa2665a..2aa58b7 100644
--- a/src/jobs/CMakeLists.txt
+++ b/src/jobs/CMakeLists.txt
@@ -1,29 +1,30 @@
 set(JOBS_SRC
     jobs/resizefilesystemjob.cpp
     jobs/createfilesystemjob.cpp
     jobs/job.cpp
     jobs/checkfilesystemjob.cpp
     jobs/shredfilesystemjob.cpp
     jobs/createpartitionjob.cpp
     jobs/createpartitiontablejob.cpp
     jobs/setpartitionlabeljob.cpp
+    jobs/setpartitionuuidjob.cpp
     jobs/createvolumegroupjob.cpp
     jobs/removevolumegroupjob.cpp
     jobs/deactivatevolumegroupjob.cpp
     jobs/deactivatelogicalvolumejob.cpp
     jobs/resizevolumegroupjob.cpp
     jobs/movephysicalvolumejob.cpp
     jobs/setfilesystemlabeljob.cpp
     jobs/deletepartitionjob.cpp
     jobs/restorefilesystemjob.cpp
     jobs/setpartgeometryjob.cpp
     jobs/deletefilesystemjob.cpp
     jobs/backupfilesystemjob.cpp
     jobs/setpartflagsjob.cpp
     jobs/copyfilesystemjob.cpp
     jobs/movefilesystemjob.cpp
 )
 
 set(JOBS_LIB_HDRS
     jobs/job.h
 )
diff --git a/src/jobs/createpartitionjob.cpp b/src/jobs/createpartitionjob.cpp
index 6f20ecd..96b1eb3 100644
--- a/src/jobs/createpartitionjob.cpp
+++ b/src/jobs/createpartitionjob.cpp
@@ -1,93 +1,97 @@
 /*************************************************************************
  *  Copyright (C) 2008 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 "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 <KLocalizedString>
 
 /** 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::Type::Disk_Device || device().type() == Device::Type::SoftwareRAID_Device) {
         std::unique_ptr<CoreBackendDevice> backendDevice = CoreBackendManager::self()->backend()->openDevice(device());
 
         if (backendDevice) {
             std::unique_ptr<CoreBackendPartitionTable> backendPartitionTable = backendDevice->openPartitionTable();
 
             if (backendPartitionTable) {
                 QString partitionPath = backendPartitionTable->createPartition(*report, partition());
 
                 if (!partitionPath.isEmpty()) {
                     rval = true;
                     partition().setPartitionPath(partitionPath);
                     partition().setState(Partition::State::None);
                     backendPartitionTable->commit();
+                    // The UUID is supported by GPT only; it is generated automatically once the creation of a partition.
+                    // Store the generated UUID to the partition object if no UUID is set.
+                    if (m_Device.partitionTable()->type() == PartitionTable::gpt && partition().uuid().isEmpty())
+                        partition().setUUID(backendPartitionTable->getPartitionUUID(*report, partition()));
                 } else
                     report->line() << xi18nc("@info/plain", "Failed to add partition <filename>%1</filename> to device <filename>%2</filename>.", partition().deviceNode(), device().deviceNode());
             } else
                 report->line() << xi18nc("@info:progress", "Could not open partition table on device <filename>%1</filename> to create new partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
         } else
             report->line() << xi18nc("@info:progress", "Could not open device <filename>%1</filename> to create new partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
     } else if (device().type() == Device::Type::LVM_Device) {
         LvmDevice& dev = dynamic_cast<LvmDevice&>(device());
         partition().setState(Partition::State::None);
 
         QString partPath = partition().partitionPath();
         QString lvname   = partPath.right(partPath.length() - partPath.lastIndexOf(QStringLiteral("/")) - 1);
         rval = LvmDevice::createLV(*report, dev, partition(), lvname);
     }
 
     jobFinished(*report, rval);
 
     return rval;
 }
 
 QString CreatePartitionJob::description() const
 {
     if (partition().number() > 0)
         return xi18nc("@info:progress", "Create new partition <filename>%1</filename>", partition().deviceNode());
 
     return xi18nc("@info:progress", "Create new partition on device <filename>%1</filename>", device().deviceNode());
 }
diff --git a/src/jobs/createpartitionjob.cpp b/src/jobs/setpartitionuuidjob.cpp
similarity index 50%
copy from src/jobs/createpartitionjob.cpp
copy to src/jobs/setpartitionuuidjob.cpp
index 6f20ecd..11c5ee6 100644
--- a/src/jobs/createpartitionjob.cpp
+++ b/src/jobs/setpartitionuuidjob.cpp
@@ -1,93 +1,86 @@
 /*************************************************************************
- *  Copyright (C) 2008 by Volker Lanz <vl@fidra.de>                      *
- *  Copyright (C) 2016 by Andrius Štikonas <andrius@stikonas.eu>         *
+ *  Copyright (C) 2020 by Gaël PORTAY <gael.portay@collabora.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 "jobs/createpartitionjob.h"
+#include "jobs/setpartitionuuidjob.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 <KLocalizedString>
+#include <memory>
 
-/** Creates a new CreatePartitionJob
+/** Creates a new SetPartitionUUIDJob (GPT only)
     @param d the Device the Partition to be created will be on
-    @param p the Partition to create
+    @param p the Partition whose UUID is to be set is on
+    @param newUUID the new UUID
 */
-CreatePartitionJob::CreatePartitionJob(Device& d, Partition& p) :
+SetPartitionUUIDJob::SetPartitionUUIDJob(Device& d, Partition& p, const QString& newUUID) :
     Job(),
     m_Device(d),
-    m_Partition(p)
+    m_Partition(p),
+    m_UUID(newUUID)
 {
 }
 
-bool CreatePartitionJob::run(Report& parent)
+bool SetPartitionUUIDJob::run(Report& parent)
 {
     Q_ASSERT(partition().devicePath() == device().deviceNode());
 
-    bool rval = false;
+    bool rval = true;
 
     Report* report = jobStarted(parent);
 
-    if (device().type() == Device::Type::Disk_Device || device().type() == Device::Type::SoftwareRAID_Device) {
-        std::unique_ptr<CoreBackendDevice> backendDevice = CoreBackendManager::self()->backend()->openDevice(device());
-
+    // The UUID is supported by GPT only, if the partition table is not GPT, just ignore the
+    // request and say all is well. This helps in operations because we don't have to check for
+    // support to avoid having a failed job.
+    if (m_Device.partitionTable()->type() != PartitionTable::gpt)
+        report->line() << xi18nc("@info:progress", "Partition table of partition <filename>%1</filename> does not support setting UUIDs. Job ignored.", partition().deviceNode());
+    else {
+        std::unique_ptr<CoreBackendDevice> backendDevice = CoreBackendManager::self()->backend()->openDevice(m_Device);
         if (backendDevice) {
             std::unique_ptr<CoreBackendPartitionTable> backendPartitionTable = backendDevice->openPartitionTable();
 
             if (backendPartitionTable) {
-                QString partitionPath = backendPartitionTable->createPartition(*report, partition());
-
-                if (!partitionPath.isEmpty()) {
+                if (backendPartitionTable->setPartitionUUID(*report, partition(), m_UUID)) {
                     rval = true;
-                    partition().setPartitionPath(partitionPath);
-                    partition().setState(Partition::State::None);
+                    partition().setUUID(m_UUID);
                     backendPartitionTable->commit();
                 } else
-                    report->line() << xi18nc("@info/plain", "Failed to add partition <filename>%1</filename> to device <filename>%2</filename>.", partition().deviceNode(), device().deviceNode());
+                    report->line() << xi18nc("@info:progress", "Failed to set the UUID for the partition <filename>%1</filename>.", partition().deviceNode());
             } else
-                report->line() << xi18nc("@info:progress", "Could not open partition table on device <filename>%1</filename> to create new partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
+                report->line() << xi18nc("@info:progress", "Could not open partition table on device <filename>%1</filename> to set the UUID for the partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
         } else
-            report->line() << xi18nc("@info:progress", "Could not open device <filename>%1</filename> to create new partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
-    } else if (device().type() == Device::Type::LVM_Device) {
-        LvmDevice& dev = dynamic_cast<LvmDevice&>(device());
-        partition().setState(Partition::State::None);
+                report->line() << xi18nc("@info:progress", "Could not open device <filename>%1</filename> to set the UUID for partition <filename>%2</filename>.", device().deviceNode(), partition().deviceNode());
 
-        QString partPath = partition().partitionPath();
-        QString lvname   = partPath.right(partPath.length() - partPath.lastIndexOf(QStringLiteral("/")) - 1);
-        rval = LvmDevice::createLV(*report, dev, partition(), lvname);
     }
 
     jobFinished(*report, rval);
 
     return rval;
 }
 
-QString CreatePartitionJob::description() const
+QString SetPartitionUUIDJob::description() const
 {
-    if (partition().number() > 0)
-        return xi18nc("@info:progress", "Create new partition <filename>%1</filename>", partition().deviceNode());
-
-    return xi18nc("@info:progress", "Create new partition on device <filename>%1</filename>", device().deviceNode());
+    return xi18nc("@info:progress", "Set the UUID on partition <filename>%1</filename> to \"%2\"", partition().deviceNode(), uuid());
 }
diff --git a/src/jobs/setpartitionuuidjob.h b/src/jobs/setpartitionuuidjob.h
new file mode 100644
index 0000000..d0e8ba1
--- /dev/null
+++ b/src/jobs/setpartitionuuidjob.h
@@ -0,0 +1,70 @@
+/*************************************************************************
+ *  Copyright (C) 2020 by Gaël PORTAY <gael.portay@collabora.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_SETPARTITIONUUIDJOB_H)
+
+#define KPMCORE_SETPARTITIONUUIDJOB_H
+
+#include "jobs/job.h"
+
+class Partition;
+class Device;
+class Report;
+
+class QString;
+
+/** Set a Partition UUID (GPT only).
+    @author Gaël PORTAY <gael.portay@collabora.com>
+*/
+class SetPartitionUUIDJob : public Job
+{
+public:
+    SetPartitionUUIDJob(Device& d, Partition& p, const QString& newUUID);
+
+public:
+    bool run(Report& parent) override;
+    QString description() const override;
+
+protected:
+    Partition& partition() {
+        return m_Partition;
+    }
+    const Partition& partition() const {
+        return m_Partition;
+    }
+
+    Device& device() {
+        return m_Device;
+    }
+    const Device& device() const {
+        return m_Device;
+    }
+
+    const QString& uuid() const {
+        return m_UUID;
+    }
+    void setUUID(const QString& u) {
+        m_UUID = u;
+    }
+
+private:
+    Device& m_Device;
+    Partition& m_Partition;
+    QString m_UUID;
+};
+
+#endif
diff --git a/src/ops/newoperation.cpp b/src/ops/newoperation.cpp
index c5debd5..e8de081 100644
--- a/src/ops/newoperation.cpp
+++ b/src/ops/newoperation.cpp
@@ -1,142 +1,149 @@
 /*************************************************************************
  *  Copyright (C) 2008 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/newoperation.h"
 
 #include "core/partition.h"
 #include "core/device.h"
 #include "core/partitionnode.h"
 
 #include "jobs/createpartitionjob.h"
 #include "jobs/createfilesystemjob.h"
 #include "jobs/setpartitionlabeljob.h"
+#include "jobs/setpartitionuuidjob.h"
 #include "jobs/setfilesystemlabeljob.h"
 #include "jobs/setpartflagsjob.h"
 #include "jobs/checkfilesystemjob.h"
 
 #include "fs/filesystem.h"
 #include "fs/filesystemfactory.h"
 
 #include "util/capacity.h"
 
 #include <QString>
 
 #include <KLocalizedString>
 
 /** Creates a new NewOperation.
     @param d the Device to create a new Partition on
     @param p pointer to the new Partition to create. May not be nullptr.
 */
 NewOperation::NewOperation(Device& d, Partition* p) :
     Operation(),
     m_TargetDevice(d),
     m_NewPartition(p),
     m_CreatePartitionJob(new CreatePartitionJob(targetDevice(), newPartition())),
     m_SetPartitionLabelJob(nullptr),
+    m_SetPartitionUUIDJob(nullptr),
     m_CreateFileSystemJob(nullptr),
     m_SetPartFlagsJob(nullptr),
     m_SetFileSystemLabelJob(nullptr),
     m_CheckFileSystemJob(nullptr)
 {
     addJob(createPartitionJob());
 
     if (!p->label().isEmpty()) {
         m_SetPartitionLabelJob = new SetPartitionLabelJob(targetDevice(), newPartition(), p->label());
         addJob(setPartitionLabelJob());
     }
 
+    if (!p->uuid().isEmpty()) {
+        m_SetPartitionUUIDJob = new SetPartitionUUIDJob(targetDevice(), newPartition(), p->uuid());
+        addJob(setPartitionUUIDJob());
+    }
+
     const FileSystem& fs = newPartition().fileSystem();
 
     if (fs.type() != FileSystem::Type::Extended) {
         // It would seem tempting to skip the CreateFileSystemJob or the
         // SetFileSystemLabelJob if either has nothing to do (unformatted FS or
         // empty label). However, the user might later on decide to change FS or
         // label. The operation stack will merge these operations with this one here
         // and if the jobs don't exist things will break.
 
         m_CreateFileSystemJob = new CreateFileSystemJob(targetDevice(), newPartition(), fs.label());
         addJob(createFileSystemJob());
 
         if (fs.type() == FileSystem::Type::Lvm2_PV) {
             m_SetPartFlagsJob = new SetPartFlagsJob(targetDevice(), newPartition(), PartitionTable::Flag::Lvm);
             addJob(setPartFlagsJob());
         }
 
         m_SetFileSystemLabelJob = new SetFileSystemLabelJob(newPartition(), fs.label());
         addJob(setLabelJob());
 
         m_CheckFileSystemJob = new CheckFileSystemJob(newPartition());
         addJob(checkJob());
     }
 }
 
 NewOperation::~NewOperation()
 {
     if (status() == StatusPending)
         delete m_NewPartition;
 }
 
 bool NewOperation::targets(const Device& d) const
 {
     return d == targetDevice();
 }
 
 bool NewOperation::targets(const Partition& p) const
 {
     return p == newPartition();
 }
 
 void NewOperation::preview()
 {
     insertPreviewPartition(targetDevice(), newPartition());
 }
 
 void NewOperation::undo()
 {
     removePreviewPartition(targetDevice(), newPartition());
 }
 
 QString NewOperation::description() const
 {
     return xi18nc("@info:status", "Create a new partition (%1, %2) on <filename>%3</filename>", Capacity::formatByteSize(newPartition().capacity()), newPartition().fileSystem().name(), targetDevice().deviceNode());
 }
 
 /** Can a Partition be created somewhere?
     @param p the Partition where a new Partition is to be created, may be nullptr
     @return true if a new Partition can be created in @p p
  */
 bool NewOperation::canCreateNew(const Partition* p)
 {
     return p != nullptr && p->roles().has(PartitionRole::Unallocated);
 }
 
 Partition* NewOperation::createNew(const Partition& cloneFrom,
                                    FileSystem::Type type)
 {
     Partition* p = new Partition(cloneFrom);
 
     p->deleteFileSystem();
     p->setFileSystem(FileSystemFactory::create(type,
                      p->firstSector(),
                      p->lastSector(),
                      p->sectorSize()));
     p->setState(Partition::State::New);
     p->setPartitionPath(QString());
 
     return p;
 }
diff --git a/src/ops/newoperation.h b/src/ops/newoperation.h
index 8f774ba..247999f 100644
--- a/src/ops/newoperation.h
+++ b/src/ops/newoperation.h
@@ -1,114 +1,119 @@
 /*************************************************************************
  *  Copyright (C) 2008 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/>.*
  *************************************************************************/
 
 #if !defined(KPMCORE_NEWOPERATION_H)
 
 #define KPMCORE_NEWOPERATION_H
 
 #include "fs/filesystem.h"
 #include "ops/operation.h"
 #include "util/libpartitionmanagerexport.h"
 
 #include <QString>
 
 class Device;
 class OperationStack;
 
 class CreatePartitionJob;
 class SetPartitionLabelJob;
+class SetPartitionUUIDJob;
 class CreateFileSystemJob;
 class SetFileSystemLabelJob;
 class SetPartFlagsJob;
 class CheckFileSystemJob;
 
 /** Create a Partition.
 
     Creates the given Partition on the given Device.
 
     @author Volker Lanz <vl@fidra.de>
 */
 class LIBKPMCORE_EXPORT NewOperation : public Operation
 {
     friend class OperationStack;
 
     Q_DISABLE_COPY(NewOperation)
 
 public:
     NewOperation(Device& d, Partition* p);
     ~NewOperation();
 
 public:
     QString iconName() const override {
         return QStringLiteral("document-new");
     }
     QString description() const override;
     void preview() override;
     void undo() override;
 
     bool targets(const Device& d) const override;
     bool targets(const Partition& p) const override;
 
     static bool canCreateNew(const Partition* p);
     static Partition* createNew(const Partition& cloneFrom, FileSystem::Type type);
 
 protected:
     Partition& newPartition() {
         return *m_NewPartition;
     }
     const Partition& newPartition() const {
         return *m_NewPartition;
     }
 
     Device& targetDevice() {
         return m_TargetDevice;
     }
     const Device& targetDevice() const {
         return m_TargetDevice;
     }
 
     CreatePartitionJob* createPartitionJob() {
         return m_CreatePartitionJob;
     }
     SetPartitionLabelJob* setPartitionLabelJob() {
         return m_SetPartitionLabelJob;
     }
+    SetPartitionUUIDJob* setPartitionUUIDJob() {
+        return m_SetPartitionUUIDJob;
+    }
     CreateFileSystemJob* createFileSystemJob() {
         return m_CreateFileSystemJob;
     }
     SetPartFlagsJob* setPartFlagsJob() {
         return m_SetPartFlagsJob;
     }
     SetFileSystemLabelJob* setLabelJob() {
         return m_SetFileSystemLabelJob;
     }
     CheckFileSystemJob* checkJob() {
         return m_CheckFileSystemJob;
     }
 
 private:
     Device& m_TargetDevice;
     Partition* m_NewPartition;
     CreatePartitionJob* m_CreatePartitionJob;
     SetPartitionLabelJob* m_SetPartitionLabelJob;
+    SetPartitionUUIDJob* m_SetPartitionUUIDJob;
     CreateFileSystemJob* m_CreateFileSystemJob;
     SetPartFlagsJob* m_SetPartFlagsJob;
     SetFileSystemLabelJob* m_SetFileSystemLabelJob;
     CheckFileSystemJob* m_CheckFileSystemJob;
 };
 
 #endif
diff --git a/src/plugins/dummy/dummypartitiontable.cpp b/src/plugins/dummy/dummypartitiontable.cpp
index dc4be94..136806a 100644
--- a/src/plugins/dummy/dummypartitiontable.cpp
+++ b/src/plugins/dummy/dummypartitiontable.cpp
@@ -1,128 +1,145 @@
 /*************************************************************************
  *  Copyright (C) 2010, 2012 by Volker Lanz <vl@fidra.de>                *
  *                                                                       *
  *  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 "plugins/dummy/dummypartitiontable.h"
 #include "plugins/dummy/dummybackend.h"
 
 #include "core/partition.h"
 #include "core/device.h"
 
 #include "fs/filesystem.h"
 
 #include "util/report.h"
 
 DummyPartitionTable::DummyPartitionTable() :
     CoreBackendPartitionTable()
 {
 }
 
 DummyPartitionTable::~DummyPartitionTable()
 {
 }
 
 bool DummyPartitionTable::open()
 {
     return true;
 }
 
 
 bool DummyPartitionTable::commit(quint32 timeout)
 {
     Q_UNUSED(timeout)
 
     return true;
 }
 
 QString DummyPartitionTable::createPartition(Report& report, const Partition& partition)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
 
     return QStringLiteral("dummy");
 }
 
 bool DummyPartitionTable::deletePartition(Report& report, const Partition& partition)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
 
     return true;
 }
 
 bool DummyPartitionTable::updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
     Q_UNUSED(sector_start)
     Q_UNUSED(sector_end)
 
     return true;
 }
 
 bool DummyPartitionTable::clobberFileSystem(Report& report, const Partition& partition)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
 
     return true;
 }
 
 bool DummyPartitionTable::resizeFileSystem(Report& report, const Partition& partition, qint64 newLength)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
     Q_UNUSED(newLength)
 
     return true;
 }
 
 FileSystem::Type DummyPartitionTable::detectFileSystemBySector(Report& report, const Device& device, qint64 sector)
 {
     Q_UNUSED(report)
     Q_UNUSED(device)
     Q_UNUSED(sector)
 
     FileSystem::Type rval = FileSystem::Type::Unknown;
     return rval;
 }
 
 bool DummyPartitionTable::setPartitionSystemType(Report& report, const Partition& partition)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
 
     return true;
 }
 
 bool DummyPartitionTable::setPartitionLabel(Report& report, const Partition& partition, const QString& label)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
     Q_UNUSED(label)
 
     return true;
 }
 
+QString DummyPartitionTable::getPartitionUUID(Report& report, const Partition& partition)
+{
+    Q_UNUSED(report)
+    Q_UNUSED(partition)
+
+    return QString();
+}
+
+bool DummyPartitionTable::setPartitionUUID(Report& report, const Partition& partition, const QString& uuid)
+{
+    Q_UNUSED(report)
+    Q_UNUSED(partition)
+    Q_UNUSED(uuid)
+
+    return true;
+}
+
 bool DummyPartitionTable::setFlag(Report& report, const Partition& partition, PartitionTable::Flag partitionManagerFlag, bool state)
 {
     Q_UNUSED(report)
     Q_UNUSED(partition)
     Q_UNUSED(partitionManagerFlag)
     Q_UNUSED(state)
 
     return true;
 }
diff --git a/src/plugins/dummy/dummypartitiontable.h b/src/plugins/dummy/dummypartitiontable.h
index d5ba513..55e9e8a 100644
--- a/src/plugins/dummy/dummypartitiontable.h
+++ b/src/plugins/dummy/dummypartitiontable.h
@@ -1,54 +1,56 @@
 /*************************************************************************
  *  Copyright (C) 2010, 2012 by Volker Lanz <vl@fidra.de>                *
  *                                                                       *
  *  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_DUMMYPARTITIONTABLE_H)
 
 #define KPMCORE_DUMMYPARTITIONTABLE_H
 
 #include "backend/corebackendpartitiontable.h"
 
 #include "fs/filesystem.h"
 
 #include <QtGlobal>
 
 class CoreBackendPartition;
 class Report;
 class Partition;
 
 class DummyPartitionTable : public CoreBackendPartitionTable
 {
 public:
     DummyPartitionTable();
     ~DummyPartitionTable();
 
 public:
     bool open() override;
 
     bool commit(quint32 timeout = 10) override;
 
     QString createPartition(Report& report, const Partition& partition) override;
     bool deletePartition(Report& report, const Partition& partition) override;
     bool updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end) override;
     bool clobberFileSystem(Report& report, const Partition& partition) override;
     bool resizeFileSystem(Report& report, const Partition& partition, qint64 newLength) override;
     FileSystem::Type detectFileSystemBySector(Report& report, const Device& device, qint64 sector) override;
     bool setPartitionLabel(Report& report, const Partition& partition, const QString& label) override;
+    QString getPartitionUUID(Report& report, const Partition& partition) override;
+    bool setPartitionUUID(Report& report, const Partition& partition, const QString& uuid) override;
     bool setPartitionSystemType(Report& report, const Partition& partition) override;
     bool setFlag(Report& report, const Partition& partition, PartitionTable::Flag partitionManagerFlag, bool state) override;
 };
 
 #endif
diff --git a/src/plugins/sfdisk/sfdiskpartitiontable.cpp b/src/plugins/sfdisk/sfdiskpartitiontable.cpp
index 4adcf65..809cd71 100644
--- a/src/plugins/sfdisk/sfdiskpartitiontable.cpp
+++ b/src/plugins/sfdisk/sfdiskpartitiontable.cpp
@@ -1,280 +1,304 @@
 /*************************************************************************
  *  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/>.*
  *************************************************************************/
 
 #include "plugins/sfdisk/sfdiskpartitiontable.h"
 
 #include "backend/corebackend.h"
 #include "backend/corebackendmanager.h"
 
 #include "core/partition.h"
 #include "core/device.h"
 #include "core/raid/softwareraid.h"
 
 #include "fs/filesystem.h"
 
 #include "util/report.h"
 #include "util/externalcommand.h"
 
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QRegularExpression>
 
 #include <KLocalizedString>
 
 SfdiskPartitionTable::SfdiskPartitionTable(const Device* d) :
     CoreBackendPartitionTable(),
     m_device(d)
 {
 }
 
 SfdiskPartitionTable::~SfdiskPartitionTable()
 {
 }
 
 bool SfdiskPartitionTable::open()
 {
     return true;
 }
 
 bool SfdiskPartitionTable::commit(quint32 timeout)
 {
     if (m_device->type() == Device::Type::SoftwareRAID_Device)
         ExternalCommand(QStringLiteral("udevadm"), { QStringLiteral("control"), QStringLiteral("--stop-exec-queue") }).run();
 
     ExternalCommand(QStringLiteral("udevadm"), { QStringLiteral("settle"), QStringLiteral("--timeout=") + QString::number(timeout) }).run();
     ExternalCommand(QStringLiteral("partx"), { QStringLiteral("--update"), m_device->deviceNode() }).run();
     ExternalCommand(QStringLiteral("udevadm"), { QStringLiteral("trigger"), QStringLiteral("--subsystem-match=block") }).run();
 
     if (m_device->type() == Device::Type::SoftwareRAID_Device)
         ExternalCommand(QStringLiteral("udevadm"), { QStringLiteral("control"), QStringLiteral("--start-exec-queue") }).run();
 
     ExternalCommand(QStringLiteral("udevadm"), { QStringLiteral("settle"), QStringLiteral("--timeout=") + QString::number(timeout) }).run();
     return true;
 }
 
 QString SfdiskPartitionTable::createPartition(Report& report, const Partition& partition)
 {
     if ( !(partition.roles().has(PartitionRole::Extended) || partition.roles().has(PartitionRole::Logical) || partition.roles().has(PartitionRole::Primary) ) ) {
         report.line() << xi18nc("@info:progress", "Unknown partition role for new partition <filename>%1</filename> (roles: %2)", partition.deviceNode(), partition.roles().toString());
         return QString();
     }
 
     QByteArray type = QByteArray();
     if (partition.roles().has(PartitionRole::Extended))
         type = QByteArrayLiteral(" type=5");
 
     // NOTE: at least on GPT partition types "are" partition flags
     ExternalCommand createCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--force"), QStringLiteral("--append"), partition.devicePath() } );
     if ( createCommand.write(QByteArrayLiteral("start=") + QByteArray::number(partition.firstSector()) +
                                                         type +
                                                         QByteArrayLiteral(" size=") + QByteArray::number(partition.length()) + QByteArrayLiteral("\nwrite\n")) && createCommand.start(-1) ) {
         QRegularExpression re(QStringLiteral("Created a new partition (\\d+)"));
         QRegularExpressionMatch rem = re.match(createCommand.output());
 
         if (rem.hasMatch()) {
             if ( partition.devicePath().back().isDigit() )
                 return partition.devicePath() + QLatin1Char('p') + rem.captured(1);
             else
                 return partition.devicePath() + rem.captured(1);
         }
     }
 
     report.line() << xi18nc("@info:progress", "Failed to add partition <filename>%1</filename> to device <filename>%2</filename>.", partition.deviceNode(), m_device->deviceNode());
 
     return QString();
 }
 
 bool SfdiskPartitionTable::deletePartition(Report& report, const Partition& partition)
 {
     ExternalCommand deleteCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--force"), QStringLiteral("--delete"), partition.devicePath(), QString::number(partition.number()) } );
     if (deleteCommand.run(-1) && deleteCommand.exitCode() == 0)
         return true;
 
     report.line() << xi18nc("@info:progress", "Could not delete partition <filename>%1</filename>.", partition.devicePath());
     return false;
 }
 
 bool SfdiskPartitionTable::updateGeometry(Report& report, const Partition& partition, qint64 sectorStart, qint64 sectorEnd)
 {
     ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--force"), partition.devicePath(), QStringLiteral("-N"), QString::number(partition.number()) } );
     if ( sfdiskCommand.write(QByteArrayLiteral("start=") + QByteArray::number(sectorStart) +
                                                         QByteArrayLiteral(" size=") + QByteArray::number(sectorEnd - sectorStart + 1) +
                                                         QByteArrayLiteral("\nY\n"))
                                                         && sfdiskCommand.start(-1) && sfdiskCommand.exitCode() == 0) {
         return true;
     }
 
     report.line() << xi18nc("@info:progress", "Could not set geometry for partition <filename>%1</filename> while trying to resize/move it.", partition.devicePath());
     return false;
 }
 
 bool SfdiskPartitionTable::clobberFileSystem(Report& report, const Partition& partition)
 {
     ExternalCommand wipeCommand(report, QStringLiteral("wipefs"), { QStringLiteral("--all"), partition.partitionPath() } );
     if (wipeCommand.run(-1) && wipeCommand.exitCode() == 0)
         return true;
 
     report.line() << xi18nc("@info:progress", "Failed to erase filesystem signature on partition <filename>%1</filename>.", partition.partitionPath());
 
     return false;
 }
 
 bool SfdiskPartitionTable::resizeFileSystem(Report& report, const Partition& partition, qint64 newLength)
 {
     // sfdisk does not have any partition resize capabilities
     Q_UNUSED(report)
     Q_UNUSED(partition)
     Q_UNUSED(newLength)
 
     return false;
 }
 
 FileSystem::Type SfdiskPartitionTable::detectFileSystemBySector(Report& report, const Device& device, qint64 sector)
 {
     FileSystem::Type type = FileSystem::Type::Unknown;
 
     ExternalCommand jsonCommand(QStringLiteral("sfdisk"), { QStringLiteral("--json"), device.deviceNode() } );
     if (jsonCommand.run(-1) && jsonCommand.exitCode() == 0) {
         const QJsonArray partitionTable = QJsonDocument::fromJson(jsonCommand.rawOutput()).object()[QLatin1String("partitiontable")].toObject()[QLatin1String("partitions")].toArray();
         for (const auto &partition : partitionTable) {
             const QJsonObject partitionObject = partition.toObject();
             const qint64 start = partitionObject[QLatin1String("start")].toVariant().toLongLong();
             if (start == sector) {
                 const QString deviceNode = partitionObject[QLatin1String("node")].toString();
                 type = CoreBackendManager::self()->backend()->detectFileSystem(deviceNode);
                 return type;
             }
         }
     }
 
     report.line() << xi18nc("@info:progress", "Could not determine file system of partition at sector %1 on device <filename>%2</filename>.", sector, device.deviceNode());
 
     return type;
 }
 
 static struct {
     FileSystem::Type type;
     QLatin1String partitionType[2]; // GPT, MBR
 } typemap[] = {
     { FileSystem::Type::Btrfs, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Ext2, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Ext3, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Ext4, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::LinuxSwap, { QLatin1String("0657FD6D-A4AB-43C4-84E5-0933C84B4F4F"), QLatin1String("82") } },
     { FileSystem::Type::Fat12, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("6") } },
     { FileSystem::Type::Fat16, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("6") } },
     { FileSystem::Type::Fat32, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("c") } },
     { FileSystem::Type::Nilfs2, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Ntfs, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("7") } },
     { FileSystem::Type::Exfat, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("7") } },
     { FileSystem::Type::ReiserFS, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Reiser4, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Xfs, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Jfs, { QLatin1String("0FC63DAF-8483-4772-8E79-3D69D8477DE4"), QLatin1String("83") } },
     { FileSystem::Type::Hfs, { QLatin1String("48465300-0000-11AA-AA11-00306543ECAC"), QLatin1String("af")} },
     { FileSystem::Type::HfsPlus, { QLatin1String("48465300-0000-11AA-AA11-00306543ECAC"), QLatin1String("af") } },
     { FileSystem::Type::Udf, { QLatin1String("EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"), QLatin1String("7") } }
     // Add ZFS too
 };
 
 static QLatin1String getPartitionType(FileSystem::Type t, PartitionTable::TableType tableType)
 {
     quint8 type;
     switch (tableType) {
     case PartitionTable::TableType::gpt:
         type = 0;
         break;
     case PartitionTable::TableType::msdos:
     case PartitionTable::TableType::msdos_sectorbased:
         type = 1;
         break;
     default:;
         return QLatin1String();
     }
     for (quint32 i = 0; i < sizeof(typemap) / sizeof(typemap[0]); i++)
         if (typemap[i].type == t)
             return typemap[i].partitionType[type];
 
     return QLatin1String();
 }
 
 bool SfdiskPartitionTable::setPartitionLabel(Report& report, const Partition& partition, const QString& label)
 {
     if (label.isEmpty())
         return true;
     ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--part-label"), m_device->deviceNode(), QString::number(partition.number()),
                 label } );
     return sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0;
 }
 
+QString SfdiskPartitionTable::getPartitionUUID(Report& report, const Partition& partition)
+{
+    ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--list"), QStringLiteral("--output"), QStringLiteral("Device,UUID"),
+                m_device->deviceNode() });
+    if (sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0) {
+        QRegularExpression re(m_device->deviceNode() + QString::number(partition.number()) + QStringLiteral(" +(.+)"));
+        QRegularExpressionMatch rem = re.match(sfdiskCommand.output());
+
+        if (rem.hasMatch())
+            return rem.captured(1);
+    }
+
+    return QString();
+}
+
+bool SfdiskPartitionTable::setPartitionUUID(Report& report, const Partition& partition, const QString& uuid)
+{
+    if (uuid.isEmpty())
+        return true;
+    ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--part-uuid"), m_device->deviceNode(), QString::number(partition.number()),
+                uuid } );
+    return sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0;
+}
+
 bool SfdiskPartitionTable::setPartitionSystemType(Report& report, const Partition& partition)
 {
     QString partitionType = partition.type();
     if (partitionType.isEmpty())
         partitionType = getPartitionType(partition.fileSystem().type(), m_device->partitionTable()->type());
     if (partitionType.isEmpty())
         return true;
     ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--part-type"), m_device->deviceNode(), QString::number(partition.number()),
                 partitionType } );
     return sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0;
 }
 
 bool SfdiskPartitionTable::setFlag(Report& report, const Partition& partition, PartitionTable::Flag flag, bool state)
 {
     if (m_device->partitionTable()->type() == PartitionTable::TableType::msdos ||
          m_device->partitionTable()->type() == PartitionTable::TableType::msdos_sectorbased) {
         // We only allow setting one active partition per device
         if (flag == PartitionTable::Flag::Boot && state == true) {
             ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--activate"), m_device->deviceNode(), QString::number(partition.number()) } );
             if (sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0)
                 return true;
             else
                 return false;
         } else if (flag == PartitionTable::Flag::Boot && state == false) {
             ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--activate"), m_device->deviceNode(), QStringLiteral("-") } );
             if (sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0)
                 return true;
             else
                 return false;
         }
     }
 
     if (flag == PartitionTable::Flag::Boot && state == true) {
         ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--part-type"), m_device->deviceNode(), QString::number(partition.number()),
                 QStringLiteral("C12A7328-F81F-11D2-BA4B-00A0C93EC93B") } );
         if (sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0)
             return true;
         else
             return false;
     }
     if (flag == PartitionTable::Flag::Boot && state == false)
         setPartitionSystemType(report, partition);
 
     if (flag == PartitionTable::Flag::BiosGrub && state == true) {
         ExternalCommand sfdiskCommand(report, QStringLiteral("sfdisk"), { QStringLiteral("--part-type"), m_device->deviceNode(), QString::number(partition.number()),
                 QStringLiteral("21686148-6449-6E6F-744E-656564454649") } );
         if (sfdiskCommand.run(-1) && sfdiskCommand.exitCode() == 0)
             return true;
         else
             return false;
     }
     if (flag == PartitionTable::Flag::BiosGrub && state == false)
         setPartitionSystemType(report, partition);
 
     return true;
 }
diff --git a/src/plugins/sfdisk/sfdiskpartitiontable.h b/src/plugins/sfdisk/sfdiskpartitiontable.h
index b1dd08e..08dc46c 100644
--- a/src/plugins/sfdisk/sfdiskpartitiontable.h
+++ b/src/plugins/sfdisk/sfdiskpartitiontable.h
@@ -1,57 +1,59 @@
 /*************************************************************************
  *  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/>.*
  *************************************************************************/
 
 #if !defined(SFDISKPARTITIONTABLE__H)
 
 #define SFDISKPARTITIONTABLE__H
 
 #include "backend/corebackendpartitiontable.h"
 
 #include "fs/filesystem.h"
 
 #include <QtGlobal>
 
 class CoreBackendPartition;
 class Report;
 class Partition;
 
 class SfdiskPartitionTable : public CoreBackendPartitionTable
 {
 public:
     explicit SfdiskPartitionTable(const Device *d);
     ~SfdiskPartitionTable();
 
 public:
     bool open() override;
 
     bool commit(quint32 timeout = 10) override;
 
     QString createPartition(Report& report, const Partition& partition) override;
     bool deletePartition(Report& report, const Partition& partition) override;
     bool updateGeometry(Report& report, const Partition& partition, qint64 sector_start, qint64 sector_end) override;
     bool clobberFileSystem(Report& report, const Partition& partition) override;
     bool resizeFileSystem(Report& report, const Partition& partition, qint64 newLength) override;
     FileSystem::Type detectFileSystemBySector(Report& report, const Device& device, qint64 sector) override;
     bool setPartitionLabel(Report& report, const Partition& partition, const QString& label) override;
+    QString getPartitionUUID(Report& report, const Partition& partition) override;
+    bool setPartitionUUID(Report& report, const Partition& partition, const QString& uuid) override;
     bool setPartitionSystemType(Report& report, const Partition& partition) override;
     bool setFlag(Report& report, const Partition& partition, PartitionTable::Flag flag, bool state) override;
 
 private:
     const Device *m_device;
 };
 
 #endif