napcok/calamares
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1558 from gportay/partition-cleanups

Browse Source 
[partition] cleanups
This commit is contained in:
Adriaan de Groot 2020-10-30 22:30:38 +01:00 committed by GitHub
commit 7db398cfdf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 205 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/modules/partition/core/PartUtils.cpp
View File

@ -1,7 +1,7 @@
/* === This file is part of Calamares - <https://calamares.io> === /* === This file is part of Calamares - <https://calamares.io> ===
* *
* SPDX-FileCopyrightText: 2015-2016 Teo Mrnjavac <teo@kde.org> * SPDX-FileCopyrightText: 2015-2016 Teo Mrnjavac <teo@kde.org>
* Copyright 2018-2019 Adriaan de Groot <groot@kde.org> * SPDX-FileCopyrightText: 2018-2019 Adriaan de Groot <groot@kde.org>
* SPDX-FileCopyrightText: 2019 Collabora Ltd <arnaud.ferraris@collabora.com> * SPDX-FileCopyrightText: 2019 Collabora Ltd <arnaud.ferraris@collabora.com>
* SPDX-License-Identifier: GPL-3.0-or-later * SPDX-License-Identifier: GPL-3.0-or-later
* *
@ -59,7 +59,7 @@ convenienceName( const Partition* const candidate )
QString p; QString p;
QTextStream s( &p ); QTextStream s( &p );
s << static_cast<const void*>(candidate); // No good name available, use pointer address s << static_cast< const void* >( candidate ); // No good name available, use pointer address
return p; return p;
} }

76
src/modules/partition/core/PartitionCoreModule.cpp
View File

@ -860,82 +860,10 @@ PartitionCoreModule::setBootLoaderInstallPath( const QString& path )
m_bootLoaderInstallPath = path; m_bootLoaderInstallPath = path;
} }
void
PartitionCoreModule::initLayout()
{
m_partLayout = new PartitionLayout();
m_partLayout->addEntry( QString( "/" ), QString( "100%" ) );
}
void void
PartitionCoreModule::initLayout( const QVariantList& config ) PartitionCoreModule::initLayout( const QVariantList& config )
{ {
bool ok; m_partLayout.init( config );
QString sizeString;
QString minSizeString;
QString maxSizeString;
m_partLayout = new PartitionLayout();
for ( const auto& r : config )
{
QVariantMap pentry = r.toMap();
if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
|| !pentry.contains( "size" ) )
{
cError() << "Partition layout entry #" << config.indexOf( r )
<< "lacks mandatory attributes, switching to default layout.";
delete ( m_partLayout );
initLayout();
break;
}
if ( pentry.contains( "size" ) && CalamaresUtils::getString( pentry, "size" ).isEmpty() )
{
sizeString.setNum( CalamaresUtils::getInteger( pentry, "size", 0 ) );
}
else
{
sizeString = CalamaresUtils::getString( pentry, "size" );
}
if ( pentry.contains( "minSize" ) && CalamaresUtils::getString( pentry, "minSize" ).isEmpty() )
{
minSizeString.setNum( CalamaresUtils::getInteger( pentry, "minSize", 0 ) );
}
else
{
minSizeString = CalamaresUtils::getString( pentry, "minSize" );
}
if ( pentry.contains( "maxSize" ) && CalamaresUtils::getString( pentry, "maxSize" ).isEmpty() )
{
maxSizeString.setNum( CalamaresUtils::getInteger( pentry, "maxSize", 0 ) );
}
else
{
maxSizeString = CalamaresUtils::getString( pentry, "maxSize" );
}
if ( !m_partLayout->addEntry( CalamaresUtils::getString( pentry, "name" ),
CalamaresUtils::getString( pentry, "uuid" ),
CalamaresUtils::getString( pentry, "type" ),
CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
CalamaresUtils::getString( pentry, "mountPoint" ),
CalamaresUtils::getString( pentry, "filesystem" ),
CalamaresUtils::getSubMap( pentry, "features", ok ),
sizeString,
minSizeString,
maxSizeString ) )
{
cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
delete ( m_partLayout );
initLayout();
break;
}
}
} }
void void
@ -947,7 +875,7 @@ PartitionCoreModule::layoutApply( Device* dev,
const PartitionRole& role ) const PartitionRole& role )
{ {
bool isEfi = PartUtils::isEfiSystem(); bool isEfi = PartUtils::isEfiSystem();
QList< Partition* > partList = m_partLayout->execute( dev, firstSector, lastSector, luksPassphrase, parent, role ); QList< Partition* > partList = m_partLayout.createPartitions( dev, firstSector, lastSector, luksPassphrase, parent, role );
// Partition::mountPoint() tells us where it is mounted **now**, while // Partition::mountPoint() tells us where it is mounted **now**, while
// PartitionInfo::mountPoint() says where it will be mounted in the target system. // PartitionInfo::mountPoint() says where it will be mounted in the target system.

5
src/modules/partition/core/PartitionCoreModule.h
View File

@ -156,8 +156,7 @@ public:
/// @brief Set the path where the bootloader will be installed /// @brief Set the path where the bootloader will be installed
void setBootLoaderInstallPath( const QString& path ); void setBootLoaderInstallPath( const QString& path );
void initLayout(); void initLayout( const QVariantList& config = QVariantList() );
void initLayout( const QVariantList& config );
void layoutApply( Device* dev, qint64 firstSector, qint64 lastSector, QString luksPassphrase ); void layoutApply( Device* dev, qint64 firstSector, qint64 lastSector, QString luksPassphrase );
void layoutApply( Device* dev, void layoutApply( Device* dev,
@ -256,7 +255,7 @@ private:
bool m_hasRootMountPoint = false; bool m_hasRootMountPoint = false;
bool m_isDirty = false; bool m_isDirty = false;
QString m_bootLoaderInstallPath; QString m_bootLoaderInstallPath;
PartitionLayout* m_partLayout; PartitionLayout m_partLayout;
OsproberEntryList m_osproberLines; OsproberEntryList m_osproberLines;

339
src/modules/partition/core/PartitionLayout.cpp
View File

@ -21,6 +21,8 @@
#include "core/PartitionActions.h" #include "core/PartitionActions.h"
#include "core/PartitionInfo.h" #include "core/PartitionInfo.h"
#include "utils/Variant.h"
#include <kpmcore/core/device.h> #include <kpmcore/core/device.h>
#include <kpmcore/core/partition.h> #include <kpmcore/core/partition.h>
#include <kpmcore/fs/filesystem.h> #include <kpmcore/fs/filesystem.h>
@ -48,12 +50,6 @@ PartitionLayout::PartitionLayout()
{ {
} }
PartitionLayout::PartitionLayout( PartitionLayout::PartitionEntry entry )
: PartitionLayout()
{
m_partLayout.append( entry );
}
PartitionLayout::PartitionLayout( const PartitionLayout& layout ) PartitionLayout::PartitionLayout( const PartitionLayout& layout )
: m_defaultFsType( layout.m_defaultFsType ) : m_defaultFsType( layout.m_defaultFsType )
, m_partLayout( layout.m_partLayout ) , m_partLayout( layout.m_partLayout )
@ -62,59 +58,21 @@ PartitionLayout::PartitionLayout( const PartitionLayout& layout )
PartitionLayout::~PartitionLayout() {} PartitionLayout::~PartitionLayout() {}
bool
PartitionLayout::addEntry( PartitionLayout::PartitionEntry entry )
{
if ( !entry.isValid() )
{
cError() << "Partition size is invalid or has min size > max size";
return false;
}
m_partLayout.append( entry );
return true;
}
PartitionLayout::PartitionEntry::PartitionEntry() PartitionLayout::PartitionEntry::PartitionEntry()
: partAttributes( 0 ) : partAttributes( 0 )
{ {
} }
PartitionLayout::PartitionEntry::PartitionEntry( const QString& size, const QString& min, const QString& max ) PartitionLayout::PartitionEntry::PartitionEntry( const QString& mountPoint, const QString& size, const QString& minSize, const QString& maxSize )
: partAttributes( 0 ) : partAttributes( 0 )
, partMountPoint( mountPoint )
, partSize( size ) , partSize( size )
, partMinSize( min ) , partMinSize( minSize )
, partMaxSize( max ) , partMaxSize( maxSize )
{ {
} }
bool PartitionLayout::PartitionEntry::PartitionEntry( const QString& label,
PartitionLayout::addEntry( const QString& mountPoint, const QString& size, const QString& min, const QString& max )
{
PartitionLayout::PartitionEntry entry( size, min, max );
if ( !entry.isValid() )
{
cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
return false;
}
if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
{
cError() << "Partition mount point" << mountPoint << "is invalid";
return false;
}
entry.partMountPoint = mountPoint;
entry.partFileSystem = m_defaultFsType;
m_partLayout.append( entry );
return true;
}
bool
PartitionLayout::addEntry( const QString& label,
const QString& uuid, const QString& uuid,
const QString& type, const QString& type,
quint64 attributes, quint64 attributes,
@ -122,41 +80,94 @@ PartitionLayout::addEntry( const QString& label,
const QString& fs, const QString& fs,
const QVariantMap& features, const QVariantMap& features,
const QString& size, const QString& size,
const QString& min, const QString& minSize,
const QString& max ) const QString& maxSize )
: partLabel( label )
, partUUID( uuid )
, partType( type )
, partAttributes( attributes )
, partMountPoint( mountPoint )
, partFeatures( features )
, partSize( size )
, partMinSize( minSize )
, partMaxSize( maxSize )
{ {
PartitionLayout::PartitionEntry entry( size, min, max ); PartUtils::findFS( fs, &partFileSystem );
}
PartitionLayout::PartitionEntry::PartitionEntry( const PartitionEntry& e )
: partLabel( e.partLabel )
, partUUID( e.partUUID )
, partType( e.partType )
, partAttributes( e.partAttributes )
, partMountPoint( e.partMountPoint )
, partFileSystem( e.partFileSystem )
, partFeatures( e.partFeatures )
, partSize( e.partSize )
, partMinSize( e.partMinSize )
, partMaxSize( e.partMaxSize )
{
}
bool
PartitionLayout::addEntry( const PartitionEntry& entry )
{
if ( !entry.isValid() ) if ( !entry.isValid() )
{ {
cError() << "Partition size" << size << "is invalid or" << min << ">" << max;
return false; return false;
} }
if ( mountPoint.isEmpty() || !mountPoint.startsWith( QString( "/" ) ) )
{
cError() << "Partition mount point" << mountPoint << "is invalid";
return false;
}
entry.partLabel = label;
entry.partUUID = uuid;
entry.partType = type;
entry.partAttributes = attributes;
entry.partMountPoint = mountPoint;
PartUtils::findFS( fs, &entry.partFileSystem );
if ( entry.partFileSystem == FileSystem::Unknown )
{
entry.partFileSystem = m_defaultFsType;
}
entry.partFeatures = features;
m_partLayout.append( entry ); m_partLayout.append( entry );
return true; return true;
} }
void
PartitionLayout::init( const QVariantList& config )
{
bool ok;
m_partLayout.clear();
for ( const auto& r : config )
{
QVariantMap pentry = r.toMap();
if ( !pentry.contains( "name" ) || !pentry.contains( "mountPoint" ) || !pentry.contains( "filesystem" )
|| !pentry.contains( "size" ) )
{
cError() << "Partition layout entry #" << config.indexOf( r )
<< "lacks mandatory attributes, switching to default layout.";
m_partLayout.clear();
break;
}
if ( !addEntry( { CalamaresUtils::getString( pentry, "name" ),
CalamaresUtils::getString( pentry, "uuid" ),
CalamaresUtils::getString( pentry, "type" ),
CalamaresUtils::getUnsignedInteger( pentry, "attributes", 0 ),
CalamaresUtils::getString( pentry, "mountPoint" ),
CalamaresUtils::getString( pentry, "filesystem" ),
CalamaresUtils::getSubMap( pentry, "features", ok ),
CalamaresUtils::getString( pentry, "size", QStringLiteral( "0" ) ),
CalamaresUtils::getString( pentry, "minSize", QStringLiteral( "0" ) ),
CalamaresUtils::getString( pentry, "maxSize", QStringLiteral( "0" ) ) } ) )
{
cError() << "Partition layout entry #" << config.indexOf( r ) << "is invalid, switching to default layout.";
m_partLayout.clear();
break;
}
}
if ( !m_partLayout.count() )
{
addEntry( { QString( "/" ), QString( "100%" ) } );
}
}
QList< Partition* > QList< Partition* >
PartitionLayout::execute( Device* dev, PartitionLayout::createPartitions( Device* dev,
qint64 firstSector, qint64 firstSector,
qint64 lastSector, qint64 lastSector,
QString luksPassphrase, QString luksPassphrase,
@ -165,167 +176,129 @@ PartitionLayout::execute( Device* dev,
{ {
QList< Partition* > partList; QList< Partition* > partList;
// Map each partition entry to its requested size (0 when calculated later) // Map each partition entry to its requested size (0 when calculated later)
QMap< const PartitionLayout::PartitionEntry*, qint64 > partSizeMap; QMap< const PartitionLayout::PartitionEntry*, qint64 > partSectorsMap;
qint64 totalSize = lastSector - firstSector + 1; const qint64 totalSectors = lastSector - firstSector + 1;
qint64 availableSize = totalSize; qint64 currentSector, availableSectors = totalSectors;
// Let's check if we have enough space for each partSize // Let's check if we have enough space for each partitions, using the size
for ( const auto& part : qAsConst( m_partLayout ) ) // propery or the min-size property if unit is in percentage.
for ( const auto& entry : qAsConst( m_partLayout ) )
{ {
if ( !part.partSize.isValid() ) if ( !entry.partSize.isValid() )
{ {
cWarning() << "Partition" << part.partMountPoint << "size is invalid, skipping..."; cWarning() << "Partition" << entry.partMountPoint << "size is invalid, skipping...";
continue; continue;
} }
// Calculate partition size: Rely on "possibly uninitialized use" // Calculate partition size: Rely on "possibly uninitialized use"
// warnings to ensure that all the cases are covered below. // warnings to ensure that all the cases are covered below.
qint64 size;
// We need to ignore the percent-defined until later // We need to ignore the percent-defined until later
if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent ) qint64 sectors = 0;
if ( entry.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
{ {
size = part.partSize.toSectors( totalSize, dev->logicalSize() ); sectors = entry.partSize.toSectors( totalSectors, dev->logicalSize() );
} }
else else if ( entry.partMinSize.isValid() )
{ {
if ( part.partMinSize.isValid() ) sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
{
size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
} }
else partSectorsMap.insert( &entry, sectors );
availableSectors -= sectors;
}
// There is not enough space for all partitions, use the min-size property
// and see if we can do better afterward.
if ( availableSectors < 0 )
{ {
size = 0; availableSectors = totalSectors;
for ( const auto& entry : qAsConst( m_partLayout ) )
{
qint64 sectors = partSectorsMap.value( &entry );
if ( entry.partMinSize.isValid() )
{
sectors = entry.partMinSize.toSectors( totalSectors, dev->logicalSize() );
partSectorsMap.insert( &entry, sectors );
}
availableSectors -= sectors;
} }
} }
partSizeMap.insert( &part, size ); // Assign sectors for percentage-defined partitions.
availableSize -= size; for ( const auto& entry : qAsConst( m_partLayout ) )
{
if ( entry.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent )
{
qint64 sectors = entry.partSize.toSectors( availableSectors + partSectorsMap.value( &entry ),
dev->logicalSize() );
if ( entry.partMinSize.isValid() )
{
sectors = std::max( sectors, entry.partMinSize.toSectors( totalSectors, dev->logicalSize() ) );
} }
if ( entry.partMaxSize.isValid() )
// Use partMinSize and see if we can do better afterward.
if ( availableSize < 0 )
{ {
availableSize = totalSize; sectors = std::min( sectors, entry.partMaxSize.toSectors( totalSectors, dev->logicalSize() ) );
for ( const auto& part : qAsConst( m_partLayout ) )
{
qint64 size;
if ( part.partMinSize.isValid() )
{
size = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
} }
else if ( part.partSize.isValid() ) partSectorsMap.insert( &entry, sectors );
{
if ( part.partSize.unit() != CalamaresUtils::Partition::SizeUnit::Percent )
{
size = part.partSize.toSectors( totalSize, dev->logicalSize() );
}
else
{
size = 0;
}
}
else
{
size = 0;
}
partSizeMap.insert( &part, size );
availableSize -= size;
} }
} }
// Assign size for percentage-defined partitions // Create the partitions.
for ( const auto& part : qAsConst( m_partLayout ) ) currentSector = firstSector;
availableSectors = totalSectors;
for ( const auto& entry : qAsConst( m_partLayout ) )
{ {
if ( part.partSize.unit() == CalamaresUtils::Partition::SizeUnit::Percent ) // Adjust partition size based on available space.
qint64 sectors = partSectorsMap.value( &entry );
sectors = std::min( sectors, availableSectors );
if ( sectors == 0 )
{ {
qint64 size = partSizeMap.value( &part ); continue;
size = part.partSize.toSectors( availableSize + size, dev->logicalSize() );
if ( part.partMinSize.isValid() )
{
qint64 minSize = part.partMinSize.toSectors( totalSize, dev->logicalSize() );
if ( minSize > size )
{
size = minSize;
}
}
if ( part.partMaxSize.isValid() )
{
qint64 maxSize = part.partMaxSize.toSectors( totalSize, dev->logicalSize() );
if ( maxSize < size )
{
size = maxSize;
}
} }
partSizeMap.insert( &part, size ); Partition* part = nullptr;
}
}
availableSize = totalSize;
// TODO: Refine partition sizes to make sure there is room for every partition
// Use a default (200-500M ?) minimum size for partition without minSize
for ( const auto& part : qAsConst( m_partLayout ) )
{
qint64 size, end;
Partition* currentPartition = nullptr;
size = partSizeMap.value( &part );
// Adjust partition size based on available space
if ( size > availableSize )
{
size = availableSize;
}
end = firstSector + std::max( size - 1, Q_INT64_C( 0 ) );
if ( luksPassphrase.isEmpty() ) if ( luksPassphrase.isEmpty() )
{ {
currentPartition = KPMHelpers::createNewPartition( part = KPMHelpers::createNewPartition(
parent, *dev, role, part.partFileSystem, firstSector, end, KPM_PARTITION_FLAG( None ) ); parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, KPM_PARTITION_FLAG( None ) );
} }
else else
{ {
currentPartition = KPMHelpers::createNewEncryptedPartition( part = KPMHelpers::createNewEncryptedPartition(
parent, *dev, role, part.partFileSystem, firstSector, end, luksPassphrase, KPM_PARTITION_FLAG( None ) ); parent, *dev, role, entry.partFileSystem, currentSector, currentSector + sectors - 1, luksPassphrase, KPM_PARTITION_FLAG( None ) );
} }
PartitionInfo::setFormat( currentPartition, true ); PartitionInfo::setFormat( part, true );
PartitionInfo::setMountPoint( currentPartition, part.partMountPoint ); PartitionInfo::setMountPoint( part, entry.partMountPoint );
if ( !part.partLabel.isEmpty() ) if ( !entry.partLabel.isEmpty() )
{ {
currentPartition->setLabel( part.partLabel ); part->setLabel( entry.partLabel );
currentPartition->fileSystem().setLabel( part.partLabel ); part->fileSystem().setLabel( entry.partLabel );
} }
if ( !part.partUUID.isEmpty() ) if ( !entry.partUUID.isEmpty() )
{ {
currentPartition->setUUID( part.partUUID ); part->setUUID( entry.partUUID );
} }
if ( !part.partType.isEmpty() ) if ( !entry.partType.isEmpty() )
{ {
#if defined( WITH_KPMCORE42API ) #if defined( WITH_KPMCORE42API )
currentPartition->setType( part.partType ); part->setType( entry.partType );
#else #else
cWarning() << "Ignoring type; requires KPMcore >= 4.2.0."; cWarning() << "Ignoring type; requires KPMcore >= 4.2.0.";
#endif #endif
} }
if ( part.partAttributes ) if ( entry.partAttributes )
{ {
#if defined( WITH_KPMCORE42API ) #if defined( WITH_KPMCORE42API )
currentPartition->setAttributes( part.partAttributes ); part->setAttributes( entry.partAttributes );
#else #else
cWarning() << "Ignoring attributes; requires KPMcore >= 4.2.0."; cWarning() << "Ignoring attributes; requires KPMcore >= 4.2.0.";
#endif #endif
} }
if ( !part.partFeatures.isEmpty() ) if ( !entry.partFeatures.isEmpty() )
{ {
#if defined( WITH_KPMCORE42API ) #if defined( WITH_KPMCORE42API )
for ( const auto& k : part.partFeatures.keys() ) for ( const auto& k : entry.partFeatures.keys() )
{ {
currentPartition->fileSystem().addFeature( k, part.partFeatures.value( k ) ); part->fileSystem().addFeature( k, entry.partFeatures.value( k ) );
} }
#else #else
cWarning() << "Ignoring features; requires KPMcore >= 4.2.0."; cWarning() << "Ignoring features; requires KPMcore >= 4.2.0.";
@ -333,9 +306,9 @@ PartitionLayout::execute( Device* dev,
} }
// Some buggy (legacy) BIOSes test if the bootflag of at least one partition is set. // Some buggy (legacy) BIOSes test if the bootflag of at least one partition is set.
// Otherwise they ignore the device in boot-order, so add it here. // Otherwise they ignore the device in boot-order, so add it here.
partList.append( currentPartition ); partList.append( part );
firstSector = end + 1; currentSector += sectors;
availableSize -= size; availableSectors -= sectors;
} }
return partList; return partList;

40
src/modules/partition/core/PartitionLayout.h
View File

@ -44,8 +44,24 @@ public:
/// @brief All-zeroes PartitionEntry /// @brief All-zeroes PartitionEntry
PartitionEntry(); PartitionEntry();
/// @brief Parse @p size, @p min and @p max to their respective member variables /// @brief Parse @p mountPoint, @p size, @p minSize and @p maxSize to their respective member variables
PartitionEntry( const QString& size, const QString& min, const QString& max ); PartitionEntry( const QString& mountPoint,
const QString& size,
const QString& minSize = QString(),
const QString& maxSize = QString() );
/// @brief All-field PartitionEntry
PartitionEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& minSize = QString(),
const QString& maxSize = QString() );
/// @brief Copy PartitionEntry
PartitionEntry( const PartitionEntry& e );
bool isValid() const bool isValid() const
{ {
@ -59,31 +75,17 @@ public:
}; };
PartitionLayout(); PartitionLayout();
PartitionLayout( PartitionEntry entry );
PartitionLayout( const PartitionLayout& layout ); PartitionLayout( const PartitionLayout& layout );
~PartitionLayout(); ~PartitionLayout();
bool addEntry( PartitionEntry entry ); void init( const QVariantList& config );
bool addEntry( const QString& mountPoint, bool addEntry( const PartitionEntry& entry );
const QString& size,
const QString& min = QString(),
const QString& max = QString() );
bool addEntry( const QString& label,
const QString& uuid,
const QString& type,
quint64 attributes,
const QString& mountPoint,
const QString& fs,
const QVariantMap& features,
const QString& size,
const QString& min = QString(),
const QString& max = QString() );
/** /**
* @brief Apply the current partition layout to the selected drive space. * @brief Apply the current partition layout to the selected drive space.
* @return A list of Partition objects. * @return A list of Partition objects.
*/ */
QList< Partition* > execute( Device* dev, QList< Partition* > createPartitions( Device* dev,
qint64 firstSector, qint64 firstSector,
qint64 lastSector, qint64 lastSector,
QString luksPassphrase, QString luksPassphrase,

7
src/modules/partition/gui/PartitionViewStep.cpp
View File

@ -596,14 +596,7 @@ PartitionViewStep::setConfigurationMap( const QVariantMap& configurationMap )
QFuture< void > future = QtConcurrent::run( this, &PartitionViewStep::initPartitionCoreModule ); QFuture< void > future = QtConcurrent::run( this, &PartitionViewStep::initPartitionCoreModule );
m_future->setFuture( future ); m_future->setFuture( future );
if ( configurationMap.contains( "partitionLayout" ) )
{
m_core->initLayout( configurationMap.value( "partitionLayout" ).toList() ); m_core->initLayout( configurationMap.value( "partitionLayout" ).toList() );
}
else
{
m_core->initLayout();
}
} }

14
src/modules/partition/partition.conf
View File

@ -154,7 +154,19 @@ defaultFileSystemType: "ext4"
# If nothing is specified, LUKS is enabled in automated modes. # If nothing is specified, LUKS is enabled in automated modes.
#enableLuksAutomatedPartitioning: true #enableLuksAutomatedPartitioning: true
# To apply a custom partition layout, it has to be defined this way : # Partition layout.
#
# This optional setting specifies a custom partition layout.
#
# If nothing is specified, the default partition layout is a single partition
# for root that uses 100% of the space and uses the filesystem defined by
# defaultFileSystemType.
#
# Note: the EFI system partition is prepend automatically to the layout if
# needed; the swap partition is appended to the layout if enabled (small of
# suspend).
#
# Otherwise, the partition layout is defined as follow:
# #
# partitionLayout: # partitionLayout:
# - name: "rootfs" # - name: "rootfs"

16
src/modules/partition/tests/CreateLayoutsTests.cpp
View File

@ -61,12 +61,12 @@ CreateLayoutsTests::testFixedSizePartition()
PartitionRole role( PartitionRole::Role::Any ); PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions; QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) ) if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
{ {
QFAIL( qPrintable( "Unable to create / partition" ) ); QFAIL( qPrintable( "Unable to create / partition" ) );
} }
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role ); partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 1 ); QCOMPARE( partitions.count(), 1 );
@ -81,12 +81,12 @@ CreateLayoutsTests::testPercentSizePartition()
PartitionRole role( PartitionRole::Role::Any ); PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions; QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "50%" ) ) ) if ( !layout.addEntry( { QString( "/" ), QString( "50%" ) } ) )
{ {
QFAIL( qPrintable( "Unable to create / partition" ) ); QFAIL( qPrintable( "Unable to create / partition" ) );
} }
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role ); partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 1 ); QCOMPARE( partitions.count(), 1 );
@ -101,22 +101,22 @@ CreateLayoutsTests::testMixedSizePartition()
PartitionRole role( PartitionRole::Role::Any ); PartitionRole role( PartitionRole::Role::Any );
QList< Partition* > partitions; QList< Partition* > partitions;
if ( !layout.addEntry( QString( "/" ), QString( "5MiB" ) ) ) if ( !layout.addEntry( { QString( "/" ), QString( "5MiB" ) } ) )
{ {
QFAIL( qPrintable( "Unable to create / partition" ) ); QFAIL( qPrintable( "Unable to create / partition" ) );
} }
if ( !layout.addEntry( QString( "/home" ), QString( "50%" ) ) ) if ( !layout.addEntry( { QString( "/home" ), QString( "50%" ) } ) )
{ {
QFAIL( qPrintable( "Unable to create /home partition" ) ); QFAIL( qPrintable( "Unable to create /home partition" ) );
} }
if ( !layout.addEntry( QString( "/bkup" ), QString( "50%" ) ) ) if ( !layout.addEntry( { QString( "/bkup" ), QString( "50%" ) } ) )
{ {
QFAIL( qPrintable( "Unable to create /bkup partition" ) ); QFAIL( qPrintable( "Unable to create /bkup partition" ) );
} }
partitions = layout.execute( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role ); partitions = layout.createPartitions( static_cast< Device* >( &dev ), 0, dev.totalLogical(), nullptr, nullptr, role );
QCOMPARE( partitions.count(), 3 ); QCOMPARE( partitions.count(), 3 );