1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
<!-- SPDX-FileCopyrightText: 2017 Adriaan de Groot <groot@kde.org>
SPDX-FileCopyrightText: 2017-2020 Andrius Štikonas <andrius@stikonas.eu>
SPDX-License-Identifier: CC-BY-4.0
-->
# KPMcore
> KPMcore, the KDE Partition Manager core, is a library for examining
> and modifying partitions, disk devices, and filesystems on a
> Linux system. It provides a unified programming interface over
> top of (external) system-manipulation tools.
KPMcore is a library for examining and manipulating all facets
of storage devices on a system:
* raw disk devices
* partition tables on a device
* filesystems within a partition
There are multiple backends so that KPMcore can support different
operating systems, although the only functional backend is the
one for Linux systems:
* sfdisk backend (Linux)
* null backend
## Using KPMcore
Most of the usage information on KPMcore is included in the API
documentation; this section contains only high-level usage information.
### Finding KPMcore with CMake
KPMcore supports CMake as (meta-)build system and installs suitable
CMake support files. Typical use of of KPMcore in a `CMakeLists.txt`
looks like this:
```cmake
find_package( KPMcore 3.2 REQUIRED )
target_link_libraries( target kpmcore )
```
There are no imported targets defined for KPMcore.
### Initialization
An application must initialize the library and load a suitable
backend before using KPMcore functions. By convention, the
environment variable `KPMCORE_BACKEND` names a backend,
and typical initialization code will look like this (or use the
class `KPMCoreInitializer` from `test/helpers.h`):
```cpp
#include <backend/corebackendmanager.h>
#include <QDebug>
bool initKPMcore()
{
static bool inited = false;
if ( inited ) return true;
QByteArray env = qgetenv( "KPMCORE_BACKEND" );
auto backendName = env.isEmpty() ? CoreBackendManager::defaultBackendName() : env;
if ( !CoreBackendManager::self()->load( backendName ) )
{
qWarning() << "Failed to load backend plugin" << backendName;
return false;
}
inited = true;
return true;
}
```
This code uses the environment variable if set, and otherwise falls
back to a default backend suitable for the current platform.
Calling KPMcore functions before the library is initialized will
result in undefined behavior.
### Devices
After the backend is initialized you can scan for available devices.
If you only want devices from the loaded backend you can call
```cpp
QList<Device*> devices = backend->scanDevices( excludeReadOnly );
```
where `bool` option `excludeReadOnly` specifies whether to exclude
read only devices.
#### KPMcore device scanner
Alternatively, you can use KPMcore device scanner
```cpp
#include <core/device.h>
#include <core/devicescanner.h>
#include <core/operationstack.h>
// First create operationStack with another QObject as parent, we will use nullptr here.
OperationStack *operationStack = new OperationStack(nullptr);
DeviceScanner *deviceScanner = new DeviceScanner(nullptr, *operationStack);
deviceScanner->scan(); // use start() for scanning in the background thread
QList<Device*> devices = operationStack->previewDevices();
```
Then `deviceScanner` scans for the devices in a background thread. After
scanning is complete `DeviceScanner::finished()` signal will be emitted.
Then the devices can accessed using `operationStack->previewDevices()`.
|
