747f878911
When using squashfs in a custom partitions setup like the following:
<partitions>
<partition ... filesystem="squashfs"/>
</partitions>
The build fails because the filesystem needs to be created
using the create_on_file() API and not the create_on_device()
API. In addition the size estimation is bogus when using
squashfs and cannot be pre-calculated because we only know
how much space the filesystem really needs after mksquashfs
as worked on the data and the compression. Thus this commit
also relaxes the required size check in case of squashfs.
Last but not least a squashfs filesystem does not provide
label or UUID and can only be referenced by the PARTUUID
it gets dumped on or by the native unix device node. As
the unix node is a loop during build time of the image and
meaningless this commit also forces by-partuuid mapping in
fstab when mounting the squashfs based device.
486 lines
18 KiB
Python
486 lines
18 KiB
Python
# Copyright (c) 2015 SUSE Linux GmbH. All rights reserved.
|
|
#
|
|
# This file is part of kiwi.
|
|
#
|
|
# kiwi 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.
|
|
#
|
|
# kiwi 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 kiwi. If not, see <http://www.gnu.org/licenses/>
|
|
#
|
|
import os
|
|
import logging
|
|
from collections import namedtuple
|
|
from textwrap import dedent
|
|
|
|
# project
|
|
from kiwi.firmware import FirmWare
|
|
from kiwi.system.size import SystemSize
|
|
from kiwi.defaults import Defaults
|
|
from kiwi.xml_state import XMLState
|
|
from kiwi.exceptions import (
|
|
KiwiVolumeTooSmallError,
|
|
KiwiPartitionTooSmallError
|
|
)
|
|
|
|
log = logging.getLogger('kiwi')
|
|
|
|
|
|
class DiskSetup:
|
|
"""
|
|
**Implements disk setup methods**
|
|
|
|
Methods from this class provides information required
|
|
before building a disk image
|
|
|
|
:param object xml_state: Instance of XMLState
|
|
:param string root_dir: root directory path name
|
|
"""
|
|
def __init__(self, xml_state: XMLState, root_dir: str):
|
|
self.root_filesystem_is_overlay = xml_state.build_type.get_overlayroot()
|
|
self.swap_mbytes = xml_state.get_oemconfig_swap_mbytes()
|
|
self.configured_size = xml_state.get_build_type_size()
|
|
self.disk_resize_requested = xml_state.get_oemconfig_oem_resize()
|
|
self.filesystem = xml_state.build_type.get_filesystem()
|
|
self.bootpart_requested = xml_state.build_type.get_bootpartition()
|
|
self.bootpart_mbytes = xml_state.build_type.get_bootpartsize()
|
|
self.spare_part_mbytes = xml_state.get_build_type_spare_part_size()
|
|
self.mdraid = xml_state.build_type.get_mdraid()
|
|
self.luks = xml_state.get_luks_credentials()
|
|
self.volume_manager = xml_state.get_volume_management()
|
|
self.bootloader = xml_state.get_build_type_bootloader_name()
|
|
self.oemconfig = xml_state.get_build_type_oemconfig_section()
|
|
self.volumes = xml_state.get_volumes()
|
|
self.custom_partitions = xml_state.get_partitions()
|
|
|
|
self.firmware = FirmWare(
|
|
xml_state
|
|
)
|
|
self.rootsize = SystemSize(
|
|
root_dir
|
|
)
|
|
|
|
self.root_dir = root_dir
|
|
self.xml_state = xml_state
|
|
|
|
def get_disksize_mbytes(
|
|
self, root_clone: int = 0, boot_clone: int = 0
|
|
) -> int:
|
|
"""
|
|
Precalculate disk size requirements in mbytes
|
|
|
|
:param int root_clone:
|
|
root partition gets cloned, N+1 times the size is needed
|
|
:param int boot_clone:
|
|
boot partition gets cloned, N+1 times the size is needed
|
|
|
|
:return: disk size mbytes
|
|
|
|
:rtype: int
|
|
"""
|
|
log.info('Precalculating required disk size')
|
|
calculated_disk_mbytes = 0
|
|
root_filesystem_mbytes = self.rootsize.customize(
|
|
self.rootsize.accumulate_mbyte_file_sizes(), self.filesystem
|
|
)
|
|
if root_clone:
|
|
root_clone += 1
|
|
log.info(
|
|
'--> root partition is clone: {0}*{1} MB'.format(
|
|
root_clone, root_filesystem_mbytes
|
|
)
|
|
)
|
|
root_filesystem_mbytes *= root_clone
|
|
calculated_disk_mbytes += root_filesystem_mbytes
|
|
log.info(
|
|
'--> system data with filesystem overhead needs %s MB',
|
|
root_filesystem_mbytes
|
|
)
|
|
if self.custom_partitions:
|
|
partition_mbytes = self._accumulate_partitions_size()
|
|
if partition_mbytes:
|
|
calculated_disk_mbytes += partition_mbytes
|
|
log.info(
|
|
'--> partition(s) size setup adding %s MB', partition_mbytes
|
|
)
|
|
if self.volume_manager and self.volume_manager == 'lvm':
|
|
lvm_overhead_mbytes = Defaults.get_lvm_overhead_mbytes()
|
|
log.info(
|
|
'--> LVM overhead adding %s MB', lvm_overhead_mbytes
|
|
)
|
|
calculated_disk_mbytes += lvm_overhead_mbytes
|
|
volume_mbytes = self._accumulate_volume_size(
|
|
root_filesystem_mbytes
|
|
)
|
|
if volume_mbytes:
|
|
calculated_disk_mbytes += volume_mbytes
|
|
log.info(
|
|
'--> volume(s) size setup adding %s MB', volume_mbytes
|
|
)
|
|
elif self.swap_mbytes:
|
|
calculated_disk_mbytes += self.swap_mbytes
|
|
log.info(
|
|
'--> swap partition adding %s MB', self.swap_mbytes
|
|
)
|
|
|
|
legacy_bios_mbytes = self.firmware.get_legacy_bios_partition_size()
|
|
if legacy_bios_mbytes:
|
|
calculated_disk_mbytes += legacy_bios_mbytes
|
|
log.info(
|
|
'--> legacy bios boot partition adding %s MB',
|
|
legacy_bios_mbytes
|
|
)
|
|
|
|
boot_mbytes = self.boot_partition_size()
|
|
if boot_mbytes:
|
|
if boot_clone:
|
|
boot_clone += 1
|
|
log.info(
|
|
'--> boot partition is clone: {0}*{1} MB'.format(
|
|
boot_clone, boot_mbytes
|
|
)
|
|
)
|
|
boot_mbytes *= boot_clone
|
|
calculated_disk_mbytes += boot_mbytes
|
|
log.info(
|
|
'--> boot partition adding %s MB', boot_mbytes
|
|
)
|
|
|
|
if self.spare_part_mbytes:
|
|
calculated_disk_mbytes += self.spare_part_mbytes
|
|
log.info(
|
|
'--> spare partition adding %s MB', self.spare_part_mbytes
|
|
)
|
|
|
|
efi_mbytes = self.firmware.get_efi_partition_size()
|
|
if efi_mbytes:
|
|
calculated_disk_mbytes += efi_mbytes
|
|
log.info(
|
|
'--> EFI partition adding %s MB', efi_mbytes
|
|
)
|
|
|
|
prep_mbytes = self.firmware.get_prep_partition_size()
|
|
if prep_mbytes:
|
|
calculated_disk_mbytes += prep_mbytes
|
|
log.info(
|
|
'--> PReP partition adding %s MB', prep_mbytes
|
|
)
|
|
|
|
recovery_mbytes = self._inplace_recovery_partition_size()
|
|
if recovery_mbytes:
|
|
calculated_disk_mbytes += recovery_mbytes
|
|
log.info(
|
|
'--> In-place recovery partition adding: %s MB',
|
|
recovery_mbytes
|
|
)
|
|
|
|
if not self.configured_size:
|
|
log.info(
|
|
'Using calculated disk size: %d MB',
|
|
calculated_disk_mbytes
|
|
)
|
|
return calculated_disk_mbytes
|
|
elif self.configured_size.additive:
|
|
result_disk_mbytes = \
|
|
self.configured_size.mbytes + calculated_disk_mbytes
|
|
log.info(
|
|
'Using configured disk size: %d MB + %d MB calculated = %d MB',
|
|
self.configured_size.mbytes,
|
|
calculated_disk_mbytes,
|
|
result_disk_mbytes
|
|
)
|
|
return result_disk_mbytes
|
|
else:
|
|
log.info(
|
|
'Using configured disk size: %d MB',
|
|
self.configured_size.mbytes
|
|
)
|
|
if self.configured_size.mbytes < calculated_disk_mbytes:
|
|
log.warning(
|
|
'--> Configured size smaller than calculated size: %d MB',
|
|
calculated_disk_mbytes
|
|
)
|
|
return self.configured_size.mbytes
|
|
|
|
def need_boot_partition(self):
|
|
"""
|
|
Decide if an extra boot partition is needed. This is done with
|
|
the bootpartition attribute from the type, however if it is not
|
|
set it depends on some other type configuration parameters if
|
|
we need a boot partition or not
|
|
|
|
:return: True or False
|
|
|
|
:rtype: bool
|
|
"""
|
|
if self.bootpart_requested is True:
|
|
return True
|
|
if self.bootpart_requested is False:
|
|
return False
|
|
if self.mdraid:
|
|
return True
|
|
if self.volume_manager == 'lvm':
|
|
return True
|
|
if self.volume_manager == 'btrfs':
|
|
return False
|
|
if self.root_filesystem_is_overlay:
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def get_boot_label() -> str:
|
|
"""
|
|
Filesystem Label to use for the boot partition
|
|
|
|
:return: label name
|
|
|
|
:rtype: str
|
|
"""
|
|
return 'BOOT'
|
|
|
|
def get_root_label(self) -> str:
|
|
"""
|
|
Filesystem Label to use for the root partition
|
|
|
|
If not specified in the XML configuration the default
|
|
root label is set to 'ROOT'
|
|
|
|
:return: label name
|
|
|
|
:rtype: str
|
|
"""
|
|
root_label = self.xml_state.build_type.get_rootfs_label()
|
|
if not root_label:
|
|
root_label = 'ROOT'
|
|
return root_label
|
|
|
|
@staticmethod
|
|
def get_efi_label() -> str:
|
|
"""
|
|
Filesystem Label to use for the EFI partition
|
|
|
|
:return: label name
|
|
|
|
:rtype: str
|
|
"""
|
|
return 'EFI'
|
|
|
|
def boot_partition_size(self) -> int:
|
|
"""
|
|
Size of the boot partition in mbytes
|
|
|
|
:return: boot size mbytes
|
|
|
|
:rtype: int
|
|
"""
|
|
if self.need_boot_partition():
|
|
if self.bootpart_mbytes:
|
|
return self.bootpart_mbytes
|
|
return Defaults.get_default_boot_mbytes()
|
|
return 0
|
|
|
|
def _inplace_recovery_partition_size(self):
|
|
"""
|
|
In inplace recovery mode the recovery archive is created at
|
|
install time. This requires free space on the disk. The
|
|
amount of free space is specified with the oem-recovery-part-size
|
|
attribute. If specified we add the given size to the disk.
|
|
If not specified an inplace setup at install time will be
|
|
moved to the first boot of an oem image when the recovery
|
|
partition has been created
|
|
"""
|
|
if self.oemconfig and self.oemconfig.get_oem_inplace_recovery():
|
|
recovery_mbytes = self.oemconfig.get_oem_recovery_part_size()
|
|
if recovery_mbytes:
|
|
return int(recovery_mbytes[0] * 1.7)
|
|
|
|
def _accumulate_partitions_size(self):
|
|
"""
|
|
Calculate number of mbytes to add to the disk to allow
|
|
the creaton of the partitions with their configured size
|
|
"""
|
|
disk_partition_mbytes = 0
|
|
data_partition_mbytes = self._calculate_partition_mbytes()
|
|
for map_name in sorted(self.custom_partitions.keys()):
|
|
partition_mount_path = self.custom_partitions[map_name].mountpoint
|
|
partition_filesystem = self.custom_partitions[map_name].filesystem
|
|
partition_clone = self.custom_partitions[map_name].clone
|
|
if partition_mount_path:
|
|
partition_mbsize = self.custom_partitions[map_name].mbsize
|
|
if partition_filesystem == 'squashfs':
|
|
# cannot predict compressed size prior compressing
|
|
# use size as configured
|
|
disk_add_mbytes = int(partition_mbsize)
|
|
else:
|
|
disk_add_mbytes = int(partition_mbsize) - \
|
|
data_partition_mbytes.partition[partition_mount_path]
|
|
if disk_add_mbytes > 0:
|
|
if partition_clone:
|
|
partition_clone += 1
|
|
log.info(
|
|
'--> {0} partition is clone: {1}*{2} MB'.format(
|
|
map_name, partition_clone, disk_add_mbytes
|
|
)
|
|
)
|
|
disk_add_mbytes *= partition_clone
|
|
disk_partition_mbytes += disk_add_mbytes
|
|
else:
|
|
message = dedent('''\n
|
|
Requested partition size {0}MB for {1!r} is too small
|
|
|
|
The minimum byte value to store the data below
|
|
the {1!r} path was calculated to be {2}MB
|
|
''')
|
|
raise KiwiPartitionTooSmallError(
|
|
message.format(
|
|
partition_mbsize, partition_mount_path,
|
|
data_partition_mbytes.partition[partition_mount_path]
|
|
)
|
|
)
|
|
return disk_partition_mbytes
|
|
|
|
def _accumulate_volume_size(self, root_mbytes):
|
|
"""
|
|
Calculate number of mbytes to add to the disk to allow
|
|
the creaton of the volumes with their configured size
|
|
"""
|
|
disk_volume_mbytes = 0
|
|
|
|
data_volume_mbytes = self._calculate_volume_mbytes()
|
|
root_volume = self._get_root_volume_configuration()
|
|
|
|
# If disk resize is requested we only add the default min
|
|
# volume size because their target size request is handled
|
|
# on first boot of the disk image in oemboot/repart
|
|
if self.disk_resize_requested:
|
|
for volume in self.volumes:
|
|
disk_volume_mbytes += Defaults.get_min_volume_mbytes()
|
|
return disk_volume_mbytes
|
|
|
|
# For static disk(no resize requested) we need to add the
|
|
# configured volume sizes because the image is used directly
|
|
# as it is without being deployed and resized on a target disk
|
|
for volume in self.volumes:
|
|
if volume.realpath and not volume.realpath == '/' and volume.size:
|
|
[size_type, req_size] = volume.size.split(':')
|
|
disk_add_mbytes = 0
|
|
if size_type == 'freespace':
|
|
disk_add_mbytes += int(req_size)
|
|
else:
|
|
disk_add_mbytes += int(req_size) - \
|
|
data_volume_mbytes.volume[volume.realpath]
|
|
if disk_add_mbytes > 0:
|
|
disk_volume_mbytes += disk_add_mbytes + \
|
|
Defaults.get_min_volume_mbytes()
|
|
else:
|
|
message = dedent('''\n
|
|
Requested volume size {0}MB for {1!r} is too small
|
|
|
|
The minimum byte value to store the data below
|
|
the {1!r} path was calculated to be {2}MB
|
|
''')
|
|
raise KiwiVolumeTooSmallError(
|
|
message.format(
|
|
req_size, volume.realpath,
|
|
data_volume_mbytes.volume[volume.realpath]
|
|
)
|
|
)
|
|
|
|
if root_volume:
|
|
if root_volume.size_type == 'freespace':
|
|
disk_add_mbytes = root_volume.req_size
|
|
else:
|
|
disk_add_mbytes = root_volume.req_size - \
|
|
root_mbytes + data_volume_mbytes.total
|
|
|
|
if disk_add_mbytes > 0:
|
|
disk_volume_mbytes += disk_add_mbytes + \
|
|
Defaults.get_min_volume_mbytes()
|
|
else:
|
|
log.warning(
|
|
'root volume size of %s MB is too small, skipped',
|
|
root_volume.req_size
|
|
)
|
|
|
|
return disk_volume_mbytes
|
|
|
|
def _get_root_volume_configuration(self):
|
|
"""
|
|
Provide root volume configuration if present and in
|
|
use according to the selected volume management. So far
|
|
this only affects the LVM volume manager
|
|
"""
|
|
root_volume_type = namedtuple(
|
|
'root_volume_type', ['size_type', 'req_size']
|
|
)
|
|
for volume in self.volumes:
|
|
if volume.is_root_volume:
|
|
if volume.size:
|
|
[size_type, req_size] = volume.size.split(':')
|
|
return root_volume_type(
|
|
size_type=size_type,
|
|
req_size=int(req_size)
|
|
)
|
|
|
|
def _calculate_volume_mbytes(self):
|
|
"""
|
|
Calculate the number of mbytes each volume path currently
|
|
consumes and also provide a total number of these values.
|
|
"""
|
|
volume_mbytes_type = namedtuple(
|
|
'volume_mbytes_type', ['volume', 'total']
|
|
)
|
|
volume_mbytes = {}
|
|
volume_total = 0
|
|
for volume in self.volumes:
|
|
if volume.realpath and not volume.realpath == '/':
|
|
path_to_volume = self.root_dir + '/' + volume.realpath
|
|
if os.path.exists(path_to_volume):
|
|
volume_size = SystemSize(path_to_volume)
|
|
volume_mbytes[volume.realpath] = volume_size.customize(
|
|
volume_size.accumulate_mbyte_file_sizes(),
|
|
self.filesystem
|
|
)
|
|
else:
|
|
volume_mbytes[volume.realpath] = 0
|
|
volume_total += volume_mbytes[volume.realpath]
|
|
|
|
return volume_mbytes_type(
|
|
volume=volume_mbytes,
|
|
total=volume_total
|
|
)
|
|
|
|
def _calculate_partition_mbytes(self):
|
|
"""
|
|
Calculate the number of mbytes each partition path consumes
|
|
"""
|
|
partition_mbytes_type = namedtuple(
|
|
'partition_mbytes_type', ['partition']
|
|
)
|
|
partition_mbytes = {}
|
|
for map_name in sorted(self.custom_partitions.keys()):
|
|
partition_mount_path = self.custom_partitions[map_name].mountpoint
|
|
if partition_mount_path:
|
|
partition_filesystem = self.custom_partitions[map_name].filesystem
|
|
path_to_partition = os.path.normpath(
|
|
os.sep.join([self.root_dir, partition_mount_path])
|
|
)
|
|
if os.path.exists(path_to_partition):
|
|
partition_size = SystemSize(path_to_partition)
|
|
partition_mbytes[partition_mount_path] = partition_size.customize(
|
|
partition_size.accumulate_mbyte_file_sizes(),
|
|
partition_filesystem
|
|
)
|
|
else:
|
|
partition_mbytes[partition_mount_path] = 0
|
|
return partition_mbytes_type(
|
|
partition=partition_mbytes
|
|
)
|