diff --git a/src/partitionmanager.cpp b/src/partitionmanager.cpp
index 0566221..a428beb 100644
--- a/src/partitionmanager.cpp
+++ b/src/partitionmanager.cpp
@@ -278,9 +278,9 @@ void PartitionManagerPrivate::refresh(const Partitions &partitions, Partitions &
 
 void PartitionManagerPrivate::lock(const Partition &partition)
 {
-    qCInfo(lcMemoryCardLog) << "Can lock:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.deviceName();
+    qCInfo(lcMemoryCardLog) << "Can lock:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.devicePath();
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        m_udisksMonitor->lock(partition.deviceName());
+        m_udisksMonitor->lock(partition.devicePath());
     } else {
         qCWarning(lcMemoryCardLog) << "Lock allowed only for external memory cards," << partition.devicePath() << "is not allowed";
     }
@@ -288,9 +288,9 @@ void PartitionManagerPrivate::lock(const Partition &partition)
 
 void PartitionManagerPrivate::unlock(const Partition &partition, const QString &passphrase)
 {
-    qCInfo(lcMemoryCardLog) << "Can unlock:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.deviceName();
+    qCInfo(lcMemoryCardLog) << "Can unlock:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.devicePath();
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        m_udisksMonitor->instance()->unlock(partition.deviceName(), passphrase);
+        m_udisksMonitor->instance()->unlock(partition.devicePath(), passphrase);
     } else {
         qCWarning(lcMemoryCardLog) << "Unlock allowed only for external memory cards," << partition.devicePath() << "is not allowed";
     }
@@ -298,9 +298,9 @@ void PartitionManagerPrivate::unlock(const Partition &partition, const QString &
 
 void PartitionManagerPrivate::mount(const Partition &partition)
 {
-    qCInfo(lcMemoryCardLog) << "Can mount:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.deviceName();
+    qCInfo(lcMemoryCardLog) << "Can mount:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.devicePath();
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        m_udisksMonitor->instance()->mount(partition.deviceName());
+        m_udisksMonitor->instance()->mount(partition.devicePath());
     } else {
         qCWarning(lcMemoryCardLog) << "Mount allowed only for external memory cards," << partition.devicePath() << "is not allowed";
     }
@@ -308,9 +308,9 @@ void PartitionManagerPrivate::mount(const Partition &partition)
 
 void PartitionManagerPrivate::unmount(const Partition &partition)
 {
-    qCInfo(lcMemoryCardLog) << "Can unmount:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.deviceName();
+    qCInfo(lcMemoryCardLog) << "Can unmount:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.devicePath();
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        m_udisksMonitor->instance()->unmount(partition.deviceName());
+        m_udisksMonitor->instance()->unmount(partition.devicePath());
     } else {
         qCWarning(lcMemoryCardLog) << "Unmount allowed only for external memory cards," << partition.devicePath() << "is not allowed";
     }
@@ -318,10 +318,10 @@ void PartitionManagerPrivate::unmount(const Partition &partition)
 
 void PartitionManagerPrivate::format(const Partition &partition, const QString &type, const QString &label, const QString &passphrase)
 {
-    qCInfo(lcMemoryCardLog) << "Can format:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.deviceName();
+    qCInfo(lcMemoryCardLog) << "Can format:" << externalMedia.match(partition.deviceName()).hasMatch() << partition.devicePath();
 
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        m_udisksMonitor->instance()->format(partition.deviceName(), type, label, passphrase);
+        m_udisksMonitor->instance()->format(partition.devicePath(), type, label, passphrase);
     } else {
         qCWarning(lcMemoryCardLog) << "Formatting allowed only for external memory cards," << partition.devicePath() << "is not allowed";
     }
@@ -330,7 +330,7 @@ void PartitionManagerPrivate::format(const Partition &partition, const QString &
 QString PartitionManagerPrivate::objectPath(const Partition &partition) const
 {
     if (externalMedia.match(partition.deviceName()).hasMatch()) {
-        return m_udisksMonitor->instance()->objectPath(partition.deviceName());
+        return m_udisksMonitor->instance()->objectPath(partition.devicePath());
     } else {
         qCWarning(lcMemoryCardLog) << "Object path existing only for external memory cards:" << partition.devicePath();
         return QString();
diff --git a/src/partitionmodel.cpp b/src/partitionmodel.cpp
index e17c9b0..c27ad75 100644
--- a/src/partitionmodel.cpp
+++ b/src/partitionmodel.cpp
@@ -119,63 +119,63 @@ void PartitionModel::refresh(int index)
     }
 }
 
-void PartitionModel::lock(const QString &deviceName)
+void PartitionModel::lock(const QString &devicePath)
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName << m_partitions.count();
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath << m_partitions.count();
+    if (const Partition *partition = getPartition(devicePath)) {
         m_manager->lock(*partition);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to lock unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to lock unknown device:" << devicePath;
     }
 }
 
-void PartitionModel::unlock(const QString &deviceName, const QString &passphrase)
+void PartitionModel::unlock(const QString &devicePath, const QString &passphrase)
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName << m_partitions.count();
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath << m_partitions.count();
+    if (const Partition *partition = getPartition(devicePath)) {
         m_manager->unlock(*partition, passphrase);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to unlock unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to unlock unknown device:" << devicePath;
     }
 }
 
-void PartitionModel::mount(const QString &deviceName)
+void PartitionModel::mount(const QString &devicePath)
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName << m_partitions.count();
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath << m_partitions.count();
+    if (const Partition *partition = getPartition(devicePath)) {
         m_manager->mount(*partition);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to mount unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to mount unknown device:" << devicePath;
     }
 }
 
-void PartitionModel::unmount(const QString &deviceName)
+void PartitionModel::unmount(const QString &devicePath)
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName << m_partitions.count();
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath << m_partitions.count();
+    if (const Partition *partition = getPartition(devicePath)) {
         m_manager->unmount(*partition);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to unmount unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to unmount unknown device:" << devicePath;
     }
 }
 
-void PartitionModel::format(const QString &deviceName, const QString &type, const QString &label, const QString &passphrase)
+void PartitionModel::format(const QString &devicePath, const QString &type, const QString &label, const QString &passphrase)
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName << type << label << m_partitions.count();
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath << type << label << m_partitions.count();
+    if (const Partition *partition = getPartition(devicePath)) {
         m_manager->format(*partition, type, label, passphrase);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to format unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to format unknown device:" << devicePath;
     }
 }
 
-QString PartitionModel::objectPath(const QString &deviceName) const
+QString PartitionModel::objectPath(const QString &devicePath) const
 {
-    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << deviceName;
-    if (const Partition *partition = getPartition(deviceName)) {
+    qCInfo(lcMemoryCardLog) << Q_FUNC_INFO << devicePath;
+    if (const Partition *partition = getPartition(devicePath)) {
         return m_manager->objectPath(*partition);
     } else {
-        qCWarning(lcMemoryCardLog) << "Unable to get object path for unknown device:" << deviceName;
+        qCWarning(lcMemoryCardLog) << "Unable to get object path for unknown device:" << devicePath;
         return QString();
     }
 }
@@ -222,10 +222,10 @@ void PartitionModel::update()
     }
 }
 
-const Partition *PartitionModel::getPartition(const QString &deviceName) const
+const Partition *PartitionModel::getPartition(const QString &devicePath) const
 {
     for (const Partition &partition : m_partitions) {
-        if (deviceName == partition.deviceName()) {
+        if (devicePath == partition.devicePath()) {
             return &partition;
         }
     }
diff --git a/src/partitionmodel.h b/src/partitionmodel.h
index 64f7168..6d12ad7 100644
--- a/src/partitionmodel.h
+++ b/src/partitionmodel.h
@@ -127,13 +127,13 @@ class SYSTEMSETTINGS_EXPORT PartitionModel : public QAbstractListModel
     Q_INVOKABLE void refresh();
     Q_INVOKABLE void refresh(int index);
 
-    Q_INVOKABLE void lock(const QString &deviceName);
-    Q_INVOKABLE void unlock(const QString &deviceName, const QString &passphrase);
-    Q_INVOKABLE void mount(const QString &deviceName);
-    Q_INVOKABLE void unmount(const QString &deviceName);
-    Q_INVOKABLE void format(const QString &deviceName, const QString &type, const QString &label, const QString &passphrase = QString());
+    Q_INVOKABLE void lock(const QString &devicePath);
+    Q_INVOKABLE void unlock(const QString &devicePath, const QString &passphrase);
+    Q_INVOKABLE void mount(const QString &devicePath);
+    Q_INVOKABLE void unmount(const QString &devicePath);
+    Q_INVOKABLE void format(const QString &devicePath, const QString &type, const QString &label, const QString &passphrase = QString());
 
-    Q_INVOKABLE QString objectPath(const QString &deviceName) const;
+    Q_INVOKABLE QString objectPath(const QString &devicePath) const;
 
     QHash<int, QByteArray> roleNames() const;
 
@@ -154,7 +154,7 @@ class SYSTEMSETTINGS_EXPORT PartitionModel : public QAbstractListModel
 private:
     void update();
 
-    const Partition *getPartition(const QString &deviceName) const;
+    const Partition *getPartition(const QString &devicePath) const;
 
     void partitionChanged(const Partition &partition);
     void partitionAdded(const Partition &partition);
diff --git a/src/udisks2monitor.cpp b/src/udisks2monitor.cpp
index dbb5ee1..dc10ca8 100644
--- a/src/udisks2monitor.cpp
+++ b/src/udisks2monitor.cpp
@@ -132,43 +132,43 @@ UDisks2::Monitor::~Monitor()
 
 // TODO : Move lock, unlock, mount, unmount, format inside udisks2block.cpp
 // unlock, mount, format should be considered completed only after file system interface re-appears for the block.
-void UDisks2::Monitor::lock(const QString &deviceName)
+void UDisks2::Monitor::lock(const QString &devicePath)
 {
     QVariantList arguments;
     QVariantMap options;
     arguments << options;
-    startLuksOperation(deviceName, UDISKS2_ENCRYPTED_LOCK, objectPath(deviceName), arguments);
+    startLuksOperation(devicePath, UDISKS2_ENCRYPTED_LOCK, objectPath(devicePath), arguments);
 }
 
-void UDisks2::Monitor::unlock(const QString &deviceName, const QString &passphrase)
+void UDisks2::Monitor::unlock(const QString &devicePath, const QString &passphrase)
 {
     QVariantList arguments;
     arguments << passphrase;
     QVariantMap options;
     arguments << options;
-    startLuksOperation(deviceName, UDISKS2_ENCRYPTED_UNLOCK, objectPath(deviceName), arguments);
+    startLuksOperation(devicePath, UDISKS2_ENCRYPTED_UNLOCK, objectPath(devicePath), arguments);
 }
 
-void UDisks2::Monitor::mount(const QString &deviceName)
+void UDisks2::Monitor::mount(const QString &devicePath)
 {
     QVariantList arguments;
     QVariantMap options;
     options.insert(QStringLiteral("fstype"), QString());
     arguments << options;
-    startMountOperation(deviceName, UDISKS2_FILESYSTEM_MOUNT, objectPath(deviceName), arguments);
+    startMountOperation(devicePath, UDISKS2_FILESYSTEM_MOUNT, objectPath(devicePath), arguments);
 }
 
-void UDisks2::Monitor::unmount(const QString &deviceName)
+void UDisks2::Monitor::unmount(const QString &devicePath)
 {
     QVariantList arguments;
     QVariantMap options;
     arguments << options;
-    startMountOperation(deviceName, UDISKS2_FILESYSTEM_UNMOUNT, objectPath(deviceName), arguments);
+    startMountOperation(devicePath, UDISKS2_FILESYSTEM_UNMOUNT, objectPath(devicePath), arguments);
 }
 
-void UDisks2::Monitor::format(const QString &deviceName, const QString &type, const QString &label, const QString &passphrase)
+void UDisks2::Monitor::format(const QString &devicePath, const QString &type, const QString &label, const QString &passphrase)
 {
-    if (deviceName.isEmpty()) {
+    if (devicePath.isEmpty()) {
         qCCritical(lcMemoryCardLog) << "Cannot format without device name";
         return;
     }
@@ -188,19 +188,19 @@ void UDisks2::Monitor::format(const QString &deviceName, const QString &type, co
         arguments.insert(QStringLiteral("encrypt.passphrase"), passphrase);
     }
 
-    const QString objectPath = this->objectPath(deviceName);
+    const QString objectPath = this->objectPath(devicePath);
     PartitionManagerPrivate::Partitions affectedPartitions;
     lookupPartitions(affectedPartitions, QStringList() << objectPath);
 
     for (auto partition : affectedPartitions) {
         if (partition->status == Partition::Mounted) {
-            m_operationQueue.enqueue(Operation(QStringLiteral("format"), deviceName, objectPath, type, arguments));
-            unmount(deviceName);
+            m_operationQueue.enqueue(Operation(QStringLiteral("format"), devicePath, objectPath, type, arguments));
+            unmount(devicePath);
             return;
         }
     }
 
-    doFormat(deviceName, objectPath, type, arguments);
+    doFormat(devicePath, objectPath, type, arguments);
 }
 
 void UDisks2::Monitor::interfacesAdded(const QDBusObjectPath &objectPath, const UDisks2::InterfacePropertyMap &interfaces)
@@ -404,11 +404,11 @@ bool UDisks2::Monitor::externalBlockDevice(const QString &deviceName) const
     return externalBlockDevice.match(deviceName).hasMatch();
 }
 
-void UDisks2::Monitor::startLuksOperation(const QString &deviceName, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments)
+void UDisks2::Monitor::startLuksOperation(const QString &devicePath, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments)
 {
     Q_ASSERT(dbusMethod == UDISKS2_ENCRYPTED_LOCK || dbusMethod == UDISKS2_ENCRYPTED_UNLOCK);
 
-    if (deviceName.isEmpty()) {
+    if (devicePath.isEmpty()) {
         qCCritical(lcMemoryCardLog) << "Cannot" << dbusMethod.toLower() << "without device name";
         return;
     }
@@ -421,12 +421,12 @@ void UDisks2::Monitor::startLuksOperation(const QString &deviceName, const QStri
     QDBusPendingCall pendingCall = udisks2Interface.asyncCallWithArgumentList(dbusMethod, arguments);
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingCall, this);
     connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this, deviceName, dbusMethod](QDBusPendingCallWatcher *watcher) {
+            this, [this, devicePath, dbusMethod](QDBusPendingCallWatcher *watcher) {
         if (watcher->isValid() && watcher->isFinished()) {
             if (dbusMethod == UDISKS2_ENCRYPTED_LOCK) {
-                emit status(deviceName, Partition::Locked);
+                emit status(devicePath, Partition::Locked);
             } else {
-                emit status(deviceName, Partition::Unmounted);
+                emit status(devicePath, Partition::Unmounted);
             }
         } else if (watcher->isError()) {
             QDBusError error = watcher->error();
@@ -449,10 +449,10 @@ void UDisks2::Monitor::startLuksOperation(const QString &deviceName, const QStri
 
             if (dbusMethod == UDISKS2_ENCRYPTED_LOCK) {
                 // All other errors will revert back the previous state.
-                emit status(deviceName, Partition::Unmounted); // TODO: could it have been in Mounted state?
+                emit status(devicePath, Partition::Unmounted); // TODO: could it have been in Mounted state?
             } else if (dbusMethod == UDISKS2_ENCRYPTED_UNLOCK) {
                 // All other errors will revert back the previous state.
-                emit status(deviceName, Partition::Locked);
+                emit status(devicePath, Partition::Locked);
             }
         }
 
@@ -460,17 +460,17 @@ void UDisks2::Monitor::startLuksOperation(const QString &deviceName, const QStri
     });
 
     if (dbusMethod == UDISKS2_ENCRYPTED_LOCK) {
-        emit status(deviceName, Partition::Locking);
+        emit status(devicePath, Partition::Locking);
     } else {
-        emit status(deviceName, Partition::Unlocking);
+        emit status(devicePath, Partition::Unlocking);
     }
 }
 
-void UDisks2::Monitor::startMountOperation(const QString &deviceName, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments)
+void UDisks2::Monitor::startMountOperation(const QString &devicePath, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments)
 {
     Q_ASSERT(dbusMethod == UDISKS2_FILESYSTEM_MOUNT || dbusMethod == UDISKS2_FILESYSTEM_UNMOUNT);
 
-    if (deviceName.isEmpty()) {
+    if (devicePath.isEmpty()) {
         qCCritical(lcMemoryCardLog) << "Cannot" << dbusMethod.toLower() << "without device name";
         return;
     }
@@ -483,12 +483,12 @@ void UDisks2::Monitor::startMountOperation(const QString &deviceName, const QStr
     QDBusPendingCall pendingCall = udisks2Interface.asyncCallWithArgumentList(dbusMethod, arguments);
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingCall, this);
     connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this, deviceName, dbusMethod](QDBusPendingCallWatcher *watcher) {
+            this, [this, devicePath, dbusMethod](QDBusPendingCallWatcher *watcher) {
         if (watcher->isValid() && watcher->isFinished()) {
             if (dbusMethod == UDISKS2_FILESYSTEM_MOUNT) {
-                emit status(deviceName, Partition::Mounted);
+                emit status(devicePath, Partition::Mounted);
             } else {
-                emit status(deviceName, Partition::Unmounted);
+                emit status(devicePath, Partition::Unmounted);
             }
         } else if (watcher->isError()) {
             QDBusError error = watcher->error();
@@ -512,13 +512,13 @@ void UDisks2::Monitor::startMountOperation(const QString &deviceName, const QStr
             if (strcmp(UDISKS2_ERROR_ALREADY_UNMOUNTING, errorCStr) == 0) {
                 // Do nothing
             } else if (strcmp(UDISKS2_ERROR_ALREADY_MOUNTED, errorCStr) == 0) {
-                emit status(deviceName, Partition::Mounted);
+                emit status(devicePath, Partition::Mounted);
             } else if (dbusMethod == UDISKS2_FILESYSTEM_UNMOUNT) {
                 // All other errors will revert back the previous state.
-                emit status(deviceName, Partition::Mounted);
+                emit status(devicePath, Partition::Mounted);
             } else if (dbusMethod == UDISKS2_FILESYSTEM_MOUNT) {
                 // All other errors will revert back the previous state.
-                emit status(deviceName, Partition::Unmounted);
+                emit status(devicePath, Partition::Unmounted);
             }
         }
 
@@ -526,9 +526,9 @@ void UDisks2::Monitor::startMountOperation(const QString &deviceName, const QStr
     });
 
     if (dbusMethod == UDISKS2_FILESYSTEM_MOUNT) {
-        emit status(deviceName, Partition::Mounting);
+        emit status(devicePath, Partition::Mounting);
     } else {
-        emit status(deviceName, Partition::Unmounting);
+        emit status(devicePath, Partition::Unmounting);
     }
 }
 
@@ -567,16 +567,16 @@ void UDisks2::Monitor::createPartition(const UDisks2::Block *block)
     m_manager->add(addedPartitions);
 }
 
-void UDisks2::Monitor::createBlockDevice(const QString &path, const UDisks2::InterfacePropertyMap &interfacePropertyMap)
+void UDisks2::Monitor::createBlockDevice(const QString &dbusObjectPath, const UDisks2::InterfacePropertyMap &interfacePropertyMap)
 {
-    if (m_blockDevices.contains(path)) {
+    if (m_blockDevices.contains(dbusObjectPath)) {
         return;
     }
 
     // First guards that we don't create extensively block devices that cannot be
     // external block devices.
-    if (externalBlockDevice(path)) {
-        UDisks2::Block *block = new UDisks2::Block(path, interfacePropertyMap);
+    if (externalBlockDevice(dbusObjectPath)) {
+        UDisks2::Block *block = new UDisks2::Block(dbusObjectPath, interfacePropertyMap);
 
         // Upon creation.
         connect(block, &UDisks2::Block::completed, this, [this]() {
@@ -650,14 +650,14 @@ void UDisks2::Monitor::createBlockDevice(const QString &path, const UDisks2::Int
                 Operation op = m_operationQueue.head();
                 if (op.command == QStringLiteral("format") && block->mountPath().isEmpty()) {
                     m_operationQueue.dequeue();
-                    doFormat(op.deviceName, op.dbusObjectPath, op.type, op.arguments);
+                    doFormat(op.devicePath, op.dbusObjectPath, op.type, op.arguments);
                 }
             }
         });
     }
 }
 
-void UDisks2::Monitor::doFormat(const QString &deviceName, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments)
+void UDisks2::Monitor::doFormat(const QString &devicePath, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments)
 {
     QDBusInterface blockDeviceInterface(UDISKS2_SERVICE,
                                     dbusObjectPath,
@@ -667,9 +667,9 @@ void UDisks2::Monitor::doFormat(const QString &deviceName, const QString &dbusOb
     QDBusPendingCall pendingCall = blockDeviceInterface.asyncCall(UDISKS2_BLOCK_FORMAT, type, arguments);
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingCall, this);
     connect(watcher, &QDBusPendingCallWatcher::finished,
-            this, [this, deviceName, arguments](QDBusPendingCallWatcher *watcher) {
+            this, [this, devicePath, arguments](QDBusPendingCallWatcher *watcher) {
         if (watcher->isValid() && watcher->isFinished()) {
-            emit status(deviceName, Partition::Formatted);
+            emit status(devicePath, Partition::Formatted);
         } else if (watcher->isError()) {
             QDBusError error = watcher->error();
             QByteArray errorData = error.name().toLocal8Bit();
@@ -714,13 +714,11 @@ void UDisks2::Monitor::getBlockDevices()
     });
 }
 
-QString UDisks2::Monitor::objectPath(const QString &deviceName) const
+QString UDisks2::Monitor::objectPath(const QString &devicePath) const
 {
-    QString dev = QString("/dev/%1").arg(deviceName);
-
     for (QMap<QString, Block *>::const_iterator i = m_blockDevices.begin(); i != m_blockDevices.end(); ++i) {
         Block *block = i.value();
-        if (block->device() == dev) {
+        if (block->device() == devicePath) {
             return block->path();
         }
     }
diff --git a/src/udisks2monitor_p.h b/src/udisks2monitor_p.h
index 6b53f53..b45590e 100644
--- a/src/udisks2monitor_p.h
+++ b/src/udisks2monitor_p.h
@@ -54,16 +54,16 @@ class Job;
 
 struct Operation
 {
-    Operation(const QString &command, const QString &deviceName, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments)
+    Operation(const QString &command, const QString &devicePath, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments)
         : command(command)
-        , deviceName(deviceName)
+        , devicePath(devicePath)
         , dbusObjectPath(dbusObjectPath)
         , type(type)
         , arguments(arguments)
     {}
 
     QString command;
-    QString deviceName;
+    QString devicePath;
     QString dbusObjectPath;
     QString type;
     QVariantHash arguments;
@@ -78,18 +78,18 @@ class Monitor : public QObject
 
     static Monitor *instance();
 
-    void lock(const QString &deviceName);
-    void unlock(const QString &deviceName, const QString &passphrase);
+    void lock(const QString &devicePath);
+    void unlock(const QString &devicePath, const QString &passphrase);
 
-    void mount(const QString &deviceName);
-    void unmount(const QString &deviceName);
+    void mount(const QString &devicePath);
+    void unmount(const QString &devicePath);
 
-    void format(const QString &deviceName, const QString &type, const QString &label, const QString &passphrase);
+    void format(const QString &devicePath, const QString &type, const QString &label, const QString &passphrase);
 
-    QString objectPath(const QString &deviceName) const;
+    QString objectPath(const QString &devicePath) const;
 
 signals:
-    void status(const QString &deviceName, Partition::Status);
+    void status(const QString &devicePath, Partition::Status);
     void errorMessage(const QString &objectPath, const QString &errorName);
     void lockError(Partition::Error error);
     void unlockError(Partition::Error error);
@@ -107,14 +107,14 @@ private slots:
     void updatePartitionStatus(const UDisks2::Job *job, bool success);
     bool externalBlockDevice(const QString &objectPathStr) const;
 
-    void startLuksOperation(const QString &deviceName, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments);
-    void startMountOperation(const QString &deviceName, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments);
+    void startLuksOperation(const QString &devicePath, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments);
+    void startMountOperation(const QString &devicePath, const QString &dbusMethod, const QString &dbusObjectPath, const QVariantList &arguments);
     void lookupPartitions(PartitionManagerPrivate::Partitions &affectedPartitions, const QStringList &objects);
 
     void createPartition(const Block *block);
-    void createBlockDevice(const QString &path, const UDisks2::InterfacePropertyMap &interfacePropertyMap);
+    void createBlockDevice(const QString &dbusObjectPath, const UDisks2::InterfacePropertyMap &interfacePropertyMap);
 
-    void doFormat(const QString &deviceName, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments);
+    void doFormat(const QString &devicePath, const QString &dbusObjectPath, const QString &type, const QVariantHash &arguments);
     void getBlockDevices();
 
 private: