source: calamares/trunk/fuentes/src/modules/partition/core/KPMHelpers.cpp @ 7538

Last change on this file since 7538 was 7538, checked in by kbut, 13 months ago

sync with github

File size: 7.4 KB
Line 
1/* === This file is part of Calamares - <https://github.com/calamares> ===
2 *
3 *   Copyright 2014,      Aurélien Gâteau <agateau@kde.org>
4 *   Copyright 2015-2016, Teo Mrnjavac <teo@kde.org>
5 *
6 *   Calamares is free software: you can redistribute it and/or modify
7 *   it under the terms of the GNU General Public License as published by
8 *   the Free Software Foundation, either version 3 of the License, or
9 *   (at your option) any later version.
10 *
11 *   Calamares is distributed in the hope that it will be useful,
12 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 *   GNU General Public License for more details.
15 *
16 *   You should have received a copy of the GNU General Public License
17 *   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include "core/KPMHelpers.h"
21
22#include "core/PartitionInfo.h"
23#include "core/PartitionIterator.h"
24
25// KPMcore
26#include <kpmcore/core/device.h>
27#include <kpmcore/core/partition.h>
28#include <kpmcore/fs/filesystemfactory.h>
29#include <kpmcore/backend/corebackendmanager.h>
30#include <kpmcore/fs/luks.h>
31
32#include "utils/Logger.h"
33
34#include <QDebug>
35
36
37namespace KPMHelpers
38{
39
40static bool s_KPMcoreInited = false;
41
42bool
43initKPMcore()
44{
45    if ( s_KPMcoreInited )
46        return true;
47
48    QByteArray backendName = qgetenv( "KPMCORE_BACKEND" );
49    if ( !CoreBackendManager::self()->load( backendName.isEmpty() ? CoreBackendManager::defaultBackendName() : backendName ) )
50    {
51        cWarning() << "Failed to load backend plugin" << backendName;
52        return false;
53    }
54    s_KPMcoreInited = true;
55    return true;
56}
57
58
59bool
60isPartitionFreeSpace( Partition* partition )
61{
62    return partition->roles().has( PartitionRole::Unallocated );
63}
64
65
66bool
67isPartitionNew( Partition* partition )
68{
69    return partition->state() == Partition::StateNew;
70}
71
72
73Partition*
74findPartitionByMountPoint( const QList< Device* >& devices, const QString& mountPoint )
75{
76    for ( auto device : devices )
77        for ( auto it = PartitionIterator::begin( device ); it != PartitionIterator::end( device ); ++it )
78            if ( PartitionInfo::mountPoint( *it ) == mountPoint )
79                return *it;
80    return nullptr;
81}
82
83
84Partition*
85findPartitionByPath( const QList< Device* >& devices, const QString& path )
86{
87    if ( path.simplified().isEmpty() )
88        return nullptr;
89
90    for ( auto device : devices )
91        for ( auto it = PartitionIterator::begin( device ); it != PartitionIterator::end( device ); ++it )
92            if ( ( *it )->partitionPath() == path.simplified() )
93                return *it;
94    return nullptr;
95}
96
97
98QList< Partition* >
99findPartitions( const QList< Device* >& devices,
100                std::function< bool ( Partition* ) > criterionFunction )
101{
102    QList< Partition* > results;
103    for ( auto device : devices )
104        for ( auto it = PartitionIterator::begin( device ); it != PartitionIterator::end( device ); ++it )
105            if ( criterionFunction( *it ) )
106                results.append( *it );
107    return results;
108}
109
110
111Partition*
112createNewPartition( PartitionNode* parent,
113                    const Device& device,
114                    const PartitionRole& role,
115                    FileSystem::Type fsType,
116                    qint64 firstSector,
117                    qint64 lastSector,
118                    PartitionTable::Flags flags )
119{
120    FileSystem* fs = FileSystemFactory::create( fsType, firstSector, lastSector
121                                                ,device.logicalSize()
122    );
123    return new Partition(
124               parent,
125               device,
126               role,
127               fs, fs->firstSector(), fs->lastSector(),
128               QString() /* path */,
129               PartitionTable::FlagNone /* availableFlags */,
130               QString() /* mountPoint */,
131               false /* mounted */,
132               flags /* activeFlags */,
133               Partition::StateNew
134           );
135}
136
137
138Partition*
139createNewEncryptedPartition( PartitionNode* parent,
140                             const Device& device,
141                             const PartitionRole& role,
142                             FileSystem::Type fsType,
143                             qint64 firstSector,
144                             qint64 lastSector,
145                             const QString& passphrase,
146                             PartitionTable::Flags flags )
147{
148    PartitionRole::Roles newRoles = role.roles();
149    if ( !role.has( PartitionRole::Luks ) )
150        newRoles |= PartitionRole::Luks;
151
152    FS::luks* fs = dynamic_cast< FS::luks* >(
153                           FileSystemFactory::create( FileSystem::Luks,
154                                                      firstSector,
155                                                      lastSector
156                                                     ,device.logicalSize()
157                                                      ) );
158    if ( !fs )
159    {
160        cError() << "cannot create LUKS filesystem. Giving up.";
161        return nullptr;
162    }
163
164    fs->createInnerFileSystem( fsType );
165    fs->setPassphrase( passphrase );
166    Partition* p = new Partition( parent,
167                                  device,
168                                  PartitionRole( newRoles ),
169                                  fs, fs->firstSector(), fs->lastSector(),
170                                  QString() /* path */,
171                                  PartitionTable::FlagNone /* availableFlags */,
172                                  QString() /* mountPoint */,
173                                  false /* mounted */,
174                                  flags /* activeFlags */,
175                                  Partition::StateNew );
176    return p;
177}
178
179
180Partition*
181clonePartition( Device* device, Partition* partition )
182{
183    FileSystem* fs = FileSystemFactory::create(
184                         partition->fileSystem().type(),
185                         partition->firstSector(),
186                         partition->lastSector()
187                        ,device->logicalSize()
188                     );
189    return new Partition( partition->parent(),
190                          *device,
191                          partition->roles(),
192                          fs,
193                          fs->firstSector(),
194                          fs->lastSector(),
195                          partition->partitionPath(),
196                          partition->activeFlags() );
197}
198
199
200QString
201prettyNameForFileSystemType( FileSystem::Type t )
202{
203    switch ( t )
204    {
205    case FileSystem::Unknown:
206        return QObject::tr( "unknown" );
207    case FileSystem::Extended:
208        return QObject::tr( "extended" );
209    case FileSystem::Unformatted:
210        return QObject::tr( "unformatted" );
211    case FileSystem::LinuxSwap:
212        return QObject::tr( "swap" );
213    case FileSystem::Fat16:
214    case FileSystem::Fat32:
215    case FileSystem::Ntfs:
216    case FileSystem::Xfs:
217    case FileSystem::Jfs:
218    case FileSystem::Hfs:
219    case FileSystem::Ufs:
220    case FileSystem::Hpfs:
221    case FileSystem::Luks:
222    case FileSystem::Ocfs2:
223    case FileSystem::Zfs:
224    case FileSystem::Nilfs2:
225        return FileSystem::nameForType( t ).toUpper();
226    case FileSystem::ReiserFS:
227        return "ReiserFS";
228    case FileSystem::Reiser4:
229        return "Reiser4";
230    case FileSystem::HfsPlus:
231        return "HFS+";
232    case FileSystem::Btrfs:
233        return "Btrfs";
234    case FileSystem::Exfat:
235        return "exFAT";
236    case FileSystem::Lvm2_PV:
237        return "LVM PV";
238    default:
239        return FileSystem::nameForType( t );
240    }
241}
242
243} // namespace
Note: See TracBrowser for help on using the repository browser.