def mount_kernel_file_systems(self):
"""
Bind mount kernel filesystems
:raises KiwiMountKernelFileSystemsError: if some kernel filesystem
fails to mount
"""
try:
for location in self.bind_locations:
location_mount_target = os.path.normpath(os.sep.join([
self.root_dir, location
]))
if os.path.exists(location) and os.path.exists(
location_mount_target
):
shared_mount = MountManager(
device=location, mountpoint=location_mount_target
)
shared_mount.bind_mount()
self.mount_stack.append(shared_mount)
except Exception as e:
self.cleanup()
raise KiwiMountKernelFileSystemsError(
'%s: %s' % (type(e).__name__, format(e))
)
def mount_shared_directory(self, host_dir=None):
"""
Bind mount shared location
The shared location is a directory which shares data from
the image buildsystem host with the image root system. It
is used for the repository setup and the package manager
cache to allow chroot operations without being forced to
duplicate this data
:param str host_dir: directory to share between image root and build
system root
:raises KiwiMountSharedDirectoryError: if mount fails
"""
if not host_dir:
host_dir = self.shared_location
try:
Path.create(self.root_dir + host_dir)
Path.create('/' + host_dir)
shared_mount = MountManager(
device=host_dir, mountpoint=self.root_dir + host_dir
)
shared_mount.bind_mount()
self.mount_stack.append(shared_mount)
self.dir_stack.append(host_dir)
except Exception as e:
self.cleanup()
raise KiwiMountSharedDirectoryError(
'%s: %s' % (type(e).__name__, format(e))
)
def mount_shared_directory(self, host_dir=None):
"""
Bind mount shared location
The shared location is a directory which shares data from
the image buildsystem host with the image root system. It
is used for the repository setup and the package manager
cache to allow chroot operations without being forced to
duplicate this data
:param str host_dir: directory to share between image root and build
system root
:raises KiwiMountSharedDirectoryError: if mount fails
"""
if not host_dir:
host_dir = self.shared_location
try:
Path.create(self.root_dir + host_dir)
Path.create('/' + host_dir)
shared_mount = MountManager(
device=host_dir, mountpoint=self.root_dir + host_dir
)
shared_mount.bind_mount()
self.mount_stack.append(shared_mount)
self.dir_stack.append(host_dir)
except Exception as e:
self.cleanup()
raise KiwiMountSharedDirectoryError(
'%s: %s' % (type(e).__name__, format(e))
)
def mount_kernel_file_systems(self):
"""
Bind mount kernel filesystems
:raises KiwiMountKernelFileSystemsError: if some kernel filesystem
fails to mount
"""
try:
for location in self.bind_locations:
location_mount_target = os.path.normpath(os.sep.join([
self.root_dir, location
]))
if os.path.exists(location) and os.path.exists(
location_mount_target
):
shared_mount = MountManager(
device=location, mountpoint=location_mount_target
)
shared_mount.bind_mount()
self.mount_stack.append(shared_mount)
except Exception as e:
self.cleanup()
raise KiwiMountKernelFileSystemsError(
'%s: %s' % (type(e).__name__, format(e))
)
def _get_rpm_database_location(self):
shared_mount = MountManager(device='/dev',
mountpoint=self.root_dir + '/dev')
if not shared_mount.is_mounted():
shared_mount.bind_mount()
rpmdb = RpmDataBase(self.root_dir)
if rpmdb.has_rpm():
dbpath = rpmdb.rpmdb_image.expand_query('%_dbpath')
else:
dbpath = rpmdb.rpmdb_host.expand_query('%_dbpath')
if shared_mount.is_mounted():
shared_mount.umount_lazy()
return dbpath
class BootLoaderConfigBase:
"""
**Base class for bootloader configuration**
:param object xml_state: instance of :class:`XMLState`
:param string root_dir: root directory path name
:param dict custom_args: custom bootloader arguments dictionary
"""
def __init__(self, xml_state, root_dir, boot_dir=None, custom_args=None):
self.root_dir = root_dir
self.boot_dir = boot_dir or root_dir
self.xml_state = xml_state
self.arch = Defaults.get_platform_name()
self.volumes_mount = []
self.root_mount = None
self.boot_mount = None
self.efi_mount = None
self.device_mount = None
self.proc_mount = None
self.tmp_mount = None
self.root_filesystem_is_overlay = xml_state.build_type.get_overlayroot(
)
self.post_init(custom_args)
def post_init(self, custom_args):
"""
Post initialization method
Store custom arguments by default
:param dict custom_args: custom bootloader arguments
"""
self.custom_args = custom_args
def write(self):
"""
Write config data to config file.
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def write_meta_data(self, root_uuid=None, boot_options=''):
"""
Write bootloader setup meta data files
:param string root_uuid: root device UUID
:param string boot_options: kernel options as string
Implementation in specialized bootloader class optional
"""
pass
def setup_disk_image_config(self,
boot_uuid,
root_uuid,
hypervisor,
kernel,
initrd,
boot_options={}):
"""
Create boot config file to boot from disk.
:param string boot_uuid: boot device UUID
:param string root_uuid: root device UUID
:param string hypervisor: hypervisor name
:param string kernel: kernel name
:param string initrd: initrd name
:param dict boot_options:
custom options dictionary required to setup the bootloader.
The scope of the options covers all information needed
to setup and configure the bootloader and gets effective
in the individual implementation. boot_options should
not be mixed up with commandline options used at boot time.
This information is provided from the get_*_cmdline
methods. The contents of the dictionary can vary between
bootloaders or even not be needed
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_install_image_config(self, mbrid, hypervisor, kernel, initrd):
"""
Create boot config file to boot from install media in EFI mode.
:param string mbrid: mbrid file name on boot device
:param string hypervisor: hypervisor name
:param string kernel: kernel name
:param string initrd: initrd name
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_live_image_config(self, mbrid, hypervisor, kernel, initrd):
"""
Create boot config file to boot live ISO image in EFI mode.
:param string mbrid: mbrid file name on boot device
:param string hypervisor: hypervisor name
:param string kernel: kernel name
:param string initrd: initrd name
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_disk_boot_images(self, boot_uuid, lookup_path=None):
"""
Create bootloader images for disk boot
Some bootloaders requires to build a boot image the bootloader
can load from a specific offset address or from a standardized
path on a filesystem.
:param string boot_uuid: boot device UUID
:param string lookup_path: custom module lookup path
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_install_boot_images(self, mbrid, lookup_path=None):
"""
Create bootloader images for ISO boot an install media
:param string mbrid: mbrid file name on boot device
:param string lookup_path: custom module lookup path
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_live_boot_images(self, mbrid, lookup_path=None):
"""
Create bootloader images for ISO boot a live ISO image
:param string mbrid: mbrid file name on boot device
:param string lookup_path: custom module lookup path
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def setup_sysconfig_bootloader(self):
"""
Create or update etc/sysconfig/bootloader by parameters
required according to the bootloader setup
Implementation in specialized bootloader class required
"""
raise NotImplementedError
def create_efi_path(self, in_sub_dir='boot/efi'):
"""
Create standard EFI boot directory structure
:param string in_sub_dir: toplevel directory
:return: Full qualified EFI boot path
:rtype: str
"""
efi_boot_path = os.path.normpath(
os.sep.join([self.boot_dir, in_sub_dir, 'EFI/BOOT']))
Path.create(efi_boot_path)
return efi_boot_path
def get_boot_theme(self):
"""
Bootloader Theme name
:return: theme name
:rtype: str
"""
theme = None
for preferences in self.xml_state.get_preferences_sections():
section_content = preferences.get_bootloader_theme()
if section_content:
theme = section_content[0]
return theme
def get_boot_timeout_seconds(self):
"""
Bootloader timeout in seconds
If no timeout is specified the default timeout applies
:return: timeout seconds
:rtype: int
"""
timeout_seconds = self.xml_state.get_build_type_bootloader_timeout()
if timeout_seconds is None:
timeout_seconds = Defaults.get_default_boot_timeout_seconds()
return timeout_seconds
def get_continue_on_timeout(self):
"""
Check if the boot should continue after boot timeout or not
:return: True or False
:rtype: bool
"""
continue_on_timeout = \
self.xml_state.build_type.get_install_continue_on_timeout()
if continue_on_timeout is None:
continue_on_timeout = True
return continue_on_timeout
def failsafe_boot_entry_requested(self):
"""
Check if a failsafe boot entry is requested
:return: True or False
:rtype: bool
"""
if self.xml_state.build_type.get_installprovidefailsafe() is False:
return False
return True
def get_boot_cmdline(self, uuid=None):
"""
Boot commandline arguments passed to the kernel
:param string uuid: boot device UUID
:return: kernel boot arguments
:rtype: str
"""
cmdline = ''
custom_cmdline = self.xml_state.build_type.get_kernelcmdline()
if custom_cmdline:
cmdline += ' ' + custom_cmdline
custom_root = self._get_root_cmdline_parameter(uuid)
if custom_root and custom_root not in cmdline:
cmdline += ' ' + custom_root
return cmdline.strip()
def get_install_image_boot_default(self, loader=None):
"""
Provide the default boot menu entry identifier for install images
The install image can be configured to provide more than
one boot menu entry. Menu entries configured are:
* [0] Boot From Hard Disk
* [1] Install
* [2] Failsafe Install
The installboot attribute controlls which of these are used
by default. If not specified the boot from hard disk entry
will be the default. Depending on the specified loader type
either an entry number or name will be returned.
:param string loader: bootloader name
:return: menu name or id
:rtype: str
"""
menu_entry_title = self.get_menu_entry_title(plain=True)
menu_type = namedtuple('menu_type', ['name', 'menu_id'])
menu_list = [
menu_type(name='Boot_from_Hard_Disk', menu_id='0'),
menu_type(name='Install_' + menu_entry_title, menu_id='1'),
menu_type(name='Failsafe_--_Install_' + menu_entry_title,
menu_id='2')
]
boot_id = 0
install_boot_name = self.xml_state.build_type.get_installboot()
if install_boot_name == 'failsafe-install':
boot_id = 2
elif install_boot_name == 'install':
boot_id = 1
if not self.failsafe_boot_entry_requested() and boot_id == 2:
log.warning(
'Failsafe install requested but failsafe menu entry is disabled'
)
log.warning('Switching to standard install')
boot_id = 1
if loader and loader == 'isolinux':
return menu_list[boot_id].name
else:
return menu_list[boot_id].menu_id
def get_boot_path(self, target='disk'):
"""
Bootloader lookup path on boot device
If the bootloader reads the data it needs to boot, it does
that from the configured boot device. Depending if that
device is an extra boot partition or the root partition or
or based on a non standard filesystem like a btrfs snapshot,
the path name varies
:param string target: target name: disk|iso
:return: path name
:rtype: str
"""
if target != 'disk' and target != 'iso':
raise KiwiBootLoaderTargetError('Invalid boot loader target %s' %
target)
bootpath = '/boot'
need_boot_partition = False
if target == 'disk':
disk_setup = DiskSetup(self.xml_state, self.boot_dir)
need_boot_partition = disk_setup.need_boot_partition()
if need_boot_partition:
# if an extra boot partition is used we will find the
# data directly in the root of this partition and not
# below the boot/ directory
bootpath = '/'
if target == 'disk':
if not need_boot_partition:
filesystem = self.xml_state.build_type.get_filesystem()
volumes = self.xml_state.get_volumes()
if filesystem == 'btrfs' and volumes:
# grub boot data paths must not be in a subvolume
# otherwise grub won't be able to find its config file
grub2_boot_data_paths = ['boot', 'boot/grub', 'boot/grub2']
for volume in volumes:
if volume.name in grub2_boot_data_paths:
raise KiwiBootLoaderTargetError(
'{0} must not be a subvolume'.format(
volume.name))
if target == 'iso':
bootpath = '/boot/' + self.arch + '/loader'
return bootpath
def quote_title(self, name):
"""
Quote special characters in the title name
Not all characters can be displayed correctly in the bootloader
environment. Therefore a quoting is required
:param string name: title name
:return: quoted text
:rtype: str
"""
name = name.replace(' ', '_')
name = name.replace('[', '(')
name = name.replace(']', ')')
return name
def get_menu_entry_title(self, plain=False):
"""
Prefixed menu entry title
If no displayname is specified in the image description,
the menu title is constructed from the image name and
build type
:param bool plain: indicate to add built type into title text
:return: title text
:rtype: str
"""
title = self.xml_state.xml_data.get_displayname()
if not title:
title = self.xml_state.xml_data.get_name()
else:
# if the title is set via the displayname attribute no custom
# kiwi prefix or other style changes to that text should
# be made
plain = True
type_name = self.xml_state.build_type.get_image()
if plain:
return title
return title + ' [ ' + type_name.upper() + ' ]'
def get_menu_entry_install_title(self):
"""
Prefixed menu entry title for install images
If no displayname is specified in the image description,
the menu title is constructed from the image name
:return: title text
:rtype: str
"""
title = self.xml_state.xml_data.get_displayname()
if not title:
title = self.xml_state.xml_data.get_name()
return title
def get_gfxmode(self, target):
"""
Graphics mode according to bootloader target
Bootloaders which support a graphics mode can be configured
to run graphics in a specific resolution and colors. There
is no standard for this setup which causes kiwi to create
a mapping from the kernel vesa mode number to the corresponding
bootloader graphics mode setup
:param string target: bootloader name
:return: boot graphics mode
:rtype: str
"""
gfxmode_map = Defaults.get_video_mode_map()
default_mode = Defaults.get_default_video_mode()
requested_gfxmode = self.xml_state.build_type.get_vga()
if requested_gfxmode in gfxmode_map:
gfxmode = requested_gfxmode
else:
gfxmode = default_mode
if target == 'grub2':
return gfxmode_map[gfxmode].grub2
elif target == 'isolinux':
return gfxmode_map[gfxmode].isolinux
else:
return gfxmode
def _mount_system(self,
root_device,
boot_device,
efi_device=None,
volumes=None):
self.root_mount = MountManager(device=root_device)
self.boot_mount = MountManager(device=boot_device,
mountpoint=self.root_mount.mountpoint +
'/boot')
if efi_device:
self.efi_mount = MountManager(
device=efi_device,
mountpoint=self.root_mount.mountpoint + '/boot/efi')
self.root_mount.mount()
if not self.root_mount.device == self.boot_mount.device:
self.boot_mount.mount()
if efi_device:
self.efi_mount.mount()
if volumes:
for volume_path in Path.sort_by_hierarchy(sorted(volumes.keys())):
volume_mount = MountManager(
device=volumes[volume_path]['volume_device'],
mountpoint=self.root_mount.mountpoint + '/' + volume_path)
self.volumes_mount.append(volume_mount)
volume_mount.mount(
options=[volumes[volume_path]['volume_options']])
if self.root_filesystem_is_overlay:
# In case of an overlay root system all parts of the rootfs
# are read-only by squashfs except for the extra boot partition.
# However tools like grub's mkconfig creates temporary files
# at call time and therefore /tmp needs to be writable during
# the call time of the tools
self.tmp_mount = MountManager(
device='/tmp', mountpoint=self.root_mount.mountpoint + '/tmp')
self.tmp_mount.bind_mount()
self.device_mount = MountManager(
device='/dev', mountpoint=self.root_mount.mountpoint + '/dev')
self.proc_mount = MountManager(device='/proc',
mountpoint=self.root_mount.mountpoint +
'/proc')
self.device_mount.bind_mount()
self.proc_mount.bind_mount()
def _get_root_cmdline_parameter(self, uuid):
firmware = self.xml_state.build_type.get_firmware()
initrd_system = self.xml_state.get_initrd_system()
cmdline = self.xml_state.build_type.get_kernelcmdline()
if cmdline and 'root=' in cmdline:
log.info('Kernel root device explicitly set via kernelcmdline')
root_search = re.search(r'(root=(.*)[ ]+|root=(.*)$)', cmdline)
if root_search:
return root_search.group(1)
want_root_cmdline_parameter = False
if firmware and 'ec2' in firmware:
# EC2 requires to specifiy the root device in the bootloader
# configuration. This is because the used pvgrub or hvmloader
# reads this information and passes it to the guest configuration
# which has an impact on the devices attached to the guest.
want_root_cmdline_parameter = True
if initrd_system == 'dracut':
# When using a dracut initrd we have to specify the location
# of the root device
want_root_cmdline_parameter = True
if want_root_cmdline_parameter:
if uuid and self.xml_state.build_type.get_overlayroot():
return 'root=overlay:UUID={0}'.format(uuid)
elif uuid:
return 'root=UUID={0} rw'.format(uuid)
else:
log.warning(
'root=UUID=<uuid> setup requested, but uuid is not provided'
)
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
for volume_mount in reversed(self.volumes_mount):
volume_mount.umount()
if self.device_mount:
self.device_mount.umount()
if self.proc_mount:
self.proc_mount.umount()
if self.efi_mount:
self.efi_mount.umount()
if self.tmp_mount:
self.tmp_mount.umount()
if self.boot_mount:
self.boot_mount.umount()
if self.root_mount:
self.root_mount.umount()
class BootLoaderInstallGrub2(BootLoaderInstallBase):
"""
grub2 bootloader installation
Attributes
* :attr:`arch`
platform.machine
* :attr:`firmware`
Instance of FirmWare
* :attr:`efi_mount`
Instance of MountManager for EFI device
* :attr:`root_mount`
Instance of MountManager for root device
* :attr:`boot_mount`
Instance of MountManager for boot device
* :attr:`device_mount`
Instance of MountManager for /dev tree
* :attr:`proc_mount`
Instance of MountManager for proc
* :attr:`sysfs_mount`
Instance of MountManager for sysfs
"""
def post_init(self, custom_args):
"""
grub2 post initialization method
Setup class attributes
"""
self.arch = platform.machine()
self.custom_args = custom_args
self.install_arguments = []
self.firmware = None
self.efi_mount = None
self.root_mount = None
self.boot_mount = None
self.device_mount = None
self.proc_mount = None
self.sysfs_mount = None
self.volumes = None
self.volumes_mount = []
self.target_removable = None
if custom_args and 'target_removable' in custom_args:
self.target_removable = custom_args['target_removable']
if custom_args and 'system_volumes' in custom_args:
self.volumes = custom_args['system_volumes']
if custom_args and 'firmware' in custom_args:
self.firmware = custom_args['firmware']
if self.firmware and self.firmware.efi_mode():
if not custom_args or 'efi_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'EFI device name required for shim installation')
if not custom_args or 'boot_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'boot device name required for grub2 installation')
if not custom_args or 'root_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'root device name required for grub2 installation')
def install_required(self):
"""
Check if grub2 has to be installed
Take architecture and firmware setup into account to check if
bootloader code in a boot record is required
:rtype: bool
"""
if 'ppc64' in self.arch and self.firmware.opal_mode():
# OPAL doesn't need a grub2 stage1, just a config file.
# The machine will be setup to kexec grub2 in user space
log.info('No grub boot code installation in opal mode on %s',
self.arch)
return False
elif 'arm' in self.arch or self.arch == 'aarch64':
# On arm grub2 is used for EFI setup only, no install
# of grub2 boot code makes sense
log.info('No grub boot code installation on %s', self.arch)
return False
return True
def install(self):
"""
Install bootloader on disk device
"""
log.info('Installing grub2 on disk %s', self.device)
if self.target_removable:
self.install_arguments.append('--removable')
if self.arch == 'x86_64' or self.arch == 'i686' or self.arch == 'i586':
self.target = 'i386-pc'
self.install_device = self.device
self.modules = ' '.join(
Defaults.get_grub_bios_modules(multiboot=True))
self.install_arguments.append('--skip-fs-probe')
elif self.arch.startswith('ppc64'):
if not self.custom_args or 'prep_device' not in self.custom_args:
raise KiwiBootLoaderGrubInstallError(
'prep device name required for grub2 installation on ppc')
self.target = 'powerpc-ieee1275'
self.install_device = self.custom_args['prep_device']
self.modules = ' '.join(Defaults.get_grub_ofw_modules())
self.install_arguments.append('--skip-fs-probe')
self.install_arguments.append('--no-nvram')
else:
raise KiwiBootLoaderGrubPlatformError(
'host architecture %s not supported for grub2 installation' %
self.arch)
self.root_mount = MountManager(device=self.custom_args['root_device'])
self.boot_mount = MountManager(device=self.custom_args['boot_device'],
mountpoint=self.root_mount.mountpoint +
'/boot')
self.root_mount.mount()
if not self.root_mount.device == self.boot_mount.device:
self.boot_mount.mount()
if self.volumes:
for volume_path in Path.sort_by_hierarchy(
sorted(self.volumes.keys())):
volume_mount = MountManager(
device=self.volumes[volume_path]['volume_device'],
mountpoint=self.root_mount.mountpoint + '/' + volume_path)
self.volumes_mount.append(volume_mount)
volume_mount.mount(
options=[self.volumes[volume_path]['volume_options']])
self.device_mount = MountManager(
device='/dev', mountpoint=self.root_mount.mountpoint + '/dev')
self.proc_mount = MountManager(device='/proc',
mountpoint=self.root_mount.mountpoint +
'/proc')
self.sysfs_mount = MountManager(device='/sys',
mountpoint=self.root_mount.mountpoint +
'/sys')
self.device_mount.bind_mount()
self.proc_mount.bind_mount()
self.sysfs_mount.bind_mount()
# check if a grub installation could be found in the image system
grub_directory = Defaults.get_grub_path(self.root_mount.mountpoint +
'/usr/lib')
if not grub_directory:
raise KiwiBootLoaderGrubDataError(
'No grub2 installation found in %s' %
self.root_mount.mountpoint)
grub_directory = grub_directory.replace(self.root_mount.mountpoint, '')
module_directory = grub_directory + '/' + self.target
boot_directory = '/boot'
# wipe existing grubenv to allow the grub installer to create a new one
grubenv_glob = os.sep.join(
[self.root_mount.mountpoint, 'boot', '*', 'grubenv'])
for grubenv in glob.glob(grubenv_glob):
Path.wipe(grubenv)
# install grub2 boot code
Command.run([
'chroot', self.root_mount.mountpoint,
self._get_grub2_install_tool_name(self.root_mount.mountpoint)
] + self.install_arguments + [
'--directory', module_directory, '--boot-directory',
boot_directory, '--target', self.target, '--modules', self.modules,
self.install_device
])
if self.firmware and self.firmware.efi_mode() == 'uefi':
shim_install = self._get_shim_install_tool_name(
self.root_mount.mountpoint)
# if shim-install does _not_ exist the fallback mechanism
# has applied at the bootloader/config level and we expect
# no further tool calls to be required
if shim_install:
self.efi_mount = MountManager(
device=self.custom_args['efi_device'],
mountpoint=self.root_mount.mountpoint + '/boot/efi')
self.efi_mount.mount()
# Before we call shim-install, the grub installer binary is
# replaced by a noop. Actually there is no reason for
# shim-install to call the grub installer because it should
# only setup the system for EFI secure boot which does not
# require any bootloader code in the master boot record.
# In addition kiwi has called the grub installer right
# before
self._disable_grub2_install(self.root_mount.mountpoint)
Command.run([
'chroot', self.root_mount.mountpoint, 'shim-install',
'--removable', self.install_device
])
# restore the grub installer noop
self._enable_grub2_install(self.root_mount.mountpoint)
def _disable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join([
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
])
grub2_install_backup = ''.join([grub2_install, '.orig'])
grub2_install_noop = ''.join([root_path, '/bin/true'])
Command.run(['cp', '-p', grub2_install, grub2_install_backup])
Command.run(['cp', grub2_install_noop, grub2_install])
def _enable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join([
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
])
grub2_install_backup = ''.join([grub2_install, '.orig'])
if os.path.exists(grub2_install_backup):
Command.run(['cp', '-p', grub2_install_backup, grub2_install])
def _get_grub2_install_tool_name(self, root_path):
return self._get_tool_name(
root_path, lookup_list=['grub2-install', 'grub-install'])
def _get_shim_install_tool_name(self, root_path):
return self._get_tool_name(root_path,
lookup_list=['shim-install'],
fallback_on_not_found=False)
def _get_tool_name(self,
root_path,
lookup_list,
fallback_on_not_found=True):
chroot_env = {'PATH': os.sep.join([root_path, 'usr', 'sbin'])}
for tool in lookup_list:
if Path.which(filename=tool, custom_env=chroot_env):
return tool
if fallback_on_not_found:
# no tool from the list was found, we intentionally don't
# raise here but return the default tool name and raise
# an exception at invocation time in order to log the
# expected call and its arguments
return lookup_list[0]
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
for volume_mount in reversed(self.volumes_mount):
volume_mount.umount()
if self.device_mount:
self.device_mount.umount()
if self.proc_mount:
self.proc_mount.umount()
if self.sysfs_mount:
self.sysfs_mount.umount()
if self.efi_mount:
self.efi_mount.umount()
if self.boot_mount:
self.boot_mount.umount()
if self.root_mount:
self._enable_grub2_install(self.root_mount.mountpoint)
self.root_mount.umount()
class BootImageDracut(BootImageBase):
"""
**Implements creation of dracut boot(initrd) images.**
"""
@staticmethod
def has_initrd_support() -> bool:
"""
This instance supports initrd preparation and creation
"""
return True
def post_init(self) -> None:
"""
Post initialization method
Initialize empty list of dracut caller options
"""
self.device_mount: Optional[MountManager] = None
self.proc_mount: Optional[MountManager] = None
# signing keys are only taken into account on install of
# packages. As dracut runs from a pre defined root directory,
# no signing keys will be used in the process of creating
# an initrd with dracut
self.signing_keys = None
# Initialize empty list of dracut caller options
self.dracut_options: List[str] = []
self.included_files: List[str] = []
self.modules: List[str] = []
self.add_modules: List[str] = []
self.omit_modules: List[str] = []
self.available_modules = self._get_modules()
def include_file(self, filename: str, install_media: bool = False) -> None:
"""
Include file to dracut boot image
:param str filename: file path name
:param bool install_media: unused
"""
self.included_files.append('--install')
self.included_files.append(filename)
def include_module(self, module: str, install_media: bool = False) -> None:
"""
Include module to dracut boot image
:param str module: module to include
:param bool install_media: unused
"""
warn_msg = 'module "{0}" not included in initrd'.format(module)
if self._module_available(module):
if module not in self.add_modules:
self.add_modules.append(module)
else:
log.warning(warn_msg)
def omit_module(self, module: str, install_media: bool = False) -> None:
"""
Omit module to dracut boot image
:param str module: module to omit
:param bool install_media: unused
"""
if module not in self.omit_modules:
self.omit_modules.append(module)
def set_static_modules(self,
modules: List[str],
install_media: bool = False) -> None:
"""
Set static dracut modules list for boot image
:param list modules: list of the modules to include
:param bool install_media: unused
"""
self.modules = modules
def write_system_config_file(self,
config: Dict,
config_file: Optional[str] = None) -> None:
"""
Writes modules configuration into a dracut configuration file.
:param dict config: a dictionary containing the modules to add and omit
:param str conf_file: configuration file to write
"""
dracut_config = []
if not config_file:
config_file = os.path.normpath(self.boot_root_directory +
Defaults.get_dracut_conf_name())
if config.get('modules'):
modules = [
module for module in config['modules']
if self._module_available(module)
]
dracut_config.append('add_dracutmodules+=" {0} "\n'.format(
' '.join(modules)))
if config.get('omit_modules'):
dracut_config.append('omit_dracutmodules+=" {0} "\n'.format(
' '.join(config['omit_modules'])))
if config.get('install_items'):
dracut_config.append('install_items+=" {0} "\n'.format(' '.join(
config['install_items'])))
if dracut_config and config_file:
with open(config_file, 'w') as config_handle:
config_handle.writelines(dracut_config)
def prepare(self) -> None:
"""
Prepare dracut caller environment
* Setup machine_id(s) to be generic and rebuild by dracut on boot
"""
setup = SystemSetup(self.xml_state, self.boot_root_directory)
setup.setup_machine_id()
self.dracut_options.append('--install')
self.dracut_options.append('/.profile')
def create_initrd(self,
mbrid: Optional[SystemIdentifier] = None,
basename: Optional[str] = None,
install_initrd: bool = False) -> None:
"""
Create kiwi .profile environment to be included in dracut initrd.
Call dracut as chroot operation to create the initrd and move
the result into the image build target directory
:param SystemIdentifier mbrid: unused
:param str basename: base initrd file name
:param bool install_initrd: unused
"""
if self.is_prepared():
log.info('Creating generic dracut initrd archive')
self._create_profile_environment()
kernel_info = Kernel(self.boot_root_directory)
kernel_details = kernel_info.get_kernel(raise_on_not_found=True)
if basename:
dracut_initrd_basename = basename
else:
dracut_initrd_basename = self.initrd_base_name
included_files = self.included_files
modules_args = [
'--modules', ' {0} '.format(' '.join(self.modules))
] if self.modules else []
modules_args += [
'--add', ' {0} '.format(' '.join(self.add_modules))
] if self.add_modules else []
modules_args += [
'--omit', ' {0} '.format(' '.join(self.omit_modules))
] if self.omit_modules else []
options = self.dracut_options + modules_args + included_files
if kernel_details:
self.device_mount = MountManager(
device='/dev',
mountpoint=self.boot_root_directory + '/dev')
self.device_mount.bind_mount()
self.proc_mount = MountManager(
device='/proc',
mountpoint=self.boot_root_directory + '/proc')
self.proc_mount.bind_mount()
dracut_call = Command.run([
'chroot', self.boot_root_directory, 'dracut', '--verbose',
'--no-hostonly', '--no-hostonly-cmdline'
] + options + [dracut_initrd_basename, kernel_details.version],
stderr_to_stdout=True)
self.device_mount.umount()
self.proc_mount.umount()
log.debug(dracut_call.output)
Command.run([
'mv',
os.sep.join([self.boot_root_directory,
dracut_initrd_basename]), self.target_dir
])
self.initrd_filename = os.sep.join(
[self.target_dir, dracut_initrd_basename])
def _get_modules(self) -> List[str]:
cmd = Command.run([
'chroot', self.boot_root_directory, 'dracut', '--list-modules',
'--no-kernel'
])
return cmd.output.splitlines()
def _module_available(self, module: str) -> bool:
warn_msg = 'dracut module "{0}" not found in the root tree'
if module in self.available_modules:
return True
log.warning(warn_msg.format(module))
return False
def _create_profile_environment(self) -> None:
profile = Profile(self.xml_state)
defaults = Defaults()
defaults.to_profile(profile)
profile.create(Defaults.get_profile_file(self.boot_root_directory))
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
if self.device_mount:
self.device_mount.umount()
if self.proc_mount:
self.proc_mount.umount()
class BootLoaderInstallGrub2(BootLoaderInstallBase):
"""
**grub2 bootloader installation**
"""
def post_init(self, custom_args):
"""
grub2 post initialization method
:param dict custom_args:
Contains custom grub2 bootloader arguments
.. code:: python
{
'target_removable': bool,
'system_volumes': list_of_volumes,
'firmware': FirmWare_instance,
'efi_device': string,
'boot_device': string,
'root_device': string
}
"""
self.arch = Defaults.get_platform_name()
self.custom_args = custom_args
self.install_arguments = []
self.firmware = None
self.efi_mount = None
self.root_mount = None
self.boot_mount = None
self.device_mount = None
self.proc_mount = None
self.sysfs_mount = None
self.volumes = None
self.volumes_mount = []
self.target_removable = None
if custom_args and 'target_removable' in custom_args:
self.target_removable = custom_args['target_removable']
if custom_args and 'system_volumes' in custom_args:
self.volumes = custom_args['system_volumes']
if custom_args and 'firmware' in custom_args:
self.firmware = custom_args['firmware']
if self.firmware and self.firmware.efi_mode():
if not custom_args or 'efi_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'EFI device name required for shim installation')
if not custom_args or 'boot_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'boot device name required for grub2 installation')
if not custom_args or 'root_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'root device name required for grub2 installation')
def install_required(self):
"""
Check if grub2 has to be installed
Take architecture and firmware setup into account to check if
bootloader code in a boot record is required
:return: True or False
:rtype: bool
"""
if 'ppc64' in self.arch and self.firmware.opal_mode():
# OPAL doesn't need a grub2 stage1, just a config file.
# The machine will be setup to kexec grub2 in user space
log.info('No grub boot code installation in opal mode on %s',
self.arch)
return False
elif 'arm' in self.arch or self.arch == 'aarch64':
# On arm grub2 is used for EFI setup only, no install
# of grub2 boot code makes sense
log.info('No grub boot code installation on %s', self.arch)
return False
elif self.arch == 'riscv64':
# On riscv grub2 is used for EFI setup only, no install
# of grub2 boot code makes sense
log.info('No grub boot code installation on %s', self.arch)
return False
return True
def install(self):
"""
Install bootloader on disk device
"""
log.info('Installing grub2 on disk %s', self.device)
if self.target_removable:
self.install_arguments.append('--removable')
if Defaults.is_x86_arch(self.arch):
self.target = 'i386-pc'
self.install_device = self.device
self.modules = ' '.join(
Defaults.get_grub_bios_modules(multiboot=True))
self.install_arguments.append('--skip-fs-probe')
elif self.arch.startswith('ppc64'):
if not self.custom_args or 'prep_device' not in self.custom_args:
raise KiwiBootLoaderGrubInstallError(
'prep device name required for grub2 installation on ppc')
self.target = 'powerpc-ieee1275'
self.install_device = self.custom_args['prep_device']
self.modules = ' '.join(Defaults.get_grub_ofw_modules())
self.install_arguments.append('--skip-fs-probe')
self.install_arguments.append('--no-nvram')
elif self.arch.startswith('s390'):
self.target = 's390x-emu'
self.install_device = self.device
self.modules = ' '.join(Defaults.get_grub_s390_modules())
self.install_arguments.append('--skip-fs-probe')
self.install_arguments.append('--no-nvram')
else:
raise KiwiBootLoaderGrubPlatformError(
'host architecture %s not supported for grub2 installation' %
self.arch)
self._mount_device_and_volumes()
# check if a grub installation could be found in the image system
module_directory = Defaults.get_grub_path(self.root_mount.mountpoint,
self.target,
raise_on_error=False)
if not module_directory:
raise KiwiBootLoaderGrubDataError(
'No grub2 installation found in {0} for target {1}'.format(
self.root_mount.mountpoint, self.target))
module_directory = module_directory.replace(self.root_mount.mountpoint,
'')
boot_directory = '/boot'
# wipe existing grubenv to allow the grub installer to create a new one
grubenv_glob = os.sep.join(
[self.root_mount.mountpoint, 'boot', '*', 'grubenv'])
for grubenv in glob.glob(grubenv_glob):
Path.wipe(grubenv)
# install grub2 boot code
if self.firmware.get_partition_table_type() == 'dasd':
# On s390 and in CDL mode (4k DASD) the call of grub2-install
# does not work because grub2-install is not able to identify
# a 4k fdasd partitioned device as a grub supported device
# and fails. As grub2-install is only used to invoke
# grub2-zipl-setup and has no other job to do we can
# circumvent this problem by directly calling grub2-zipl-setup
# instead.
Command.run([
'chroot', self.root_mount.mountpoint, 'grub2-zipl-setup',
'--keep'
])
zipl_config_file = ''.join(
[self.root_mount.mountpoint, '/boot/zipl/config'])
zipl2grub_config_file_orig = ''.join([
self.root_mount.mountpoint,
'/etc/default/zipl2grub.conf.in.orig'
])
if os.path.exists(zipl2grub_config_file_orig):
Command.run([
'mv', zipl2grub_config_file_orig,
zipl2grub_config_file_orig.replace('.orig', '')
])
if os.path.exists(zipl_config_file):
Command.run(
['mv', zipl_config_file, zipl_config_file + '.kiwi'])
else:
Command.run([
'chroot', self.root_mount.mountpoint,
self._get_grub2_install_tool_name(self.root_mount.mountpoint)
] + self.install_arguments + [
'--directory', module_directory, '--boot-directory',
boot_directory, '--target', self.target, '--modules',
self.modules, self.install_device
])
def secure_boot_install(self):
if self.firmware and self.firmware.efi_mode() == 'uefi' and (
Defaults.is_x86_arch(self.arch) or 'arm' in self.arch
or self.arch == 'aarch64' # noqa: W503
):
self._mount_device_and_volumes()
shim_install = self._get_shim_install_tool_name(
self.root_mount.mountpoint)
# if shim-install does _not_ exist the fallback mechanism
# has applied at the bootloader/config level and we expect
# no further tool calls to be required
if shim_install:
# Before we call shim-install, the grub installer binary is
# replaced by a noop. Actually there is no reason for
# shim-install to call the grub installer because it should
# only setup the system for EFI secure boot which does not
# require any bootloader code in the master boot record.
# In addition kiwi has called the grub installer right
# before
self._disable_grub2_install(self.root_mount.mountpoint)
Command.run([
'chroot', self.root_mount.mountpoint, 'shim-install',
'--removable', self.device
])
# restore the grub installer noop
self._enable_grub2_install(self.root_mount.mountpoint)
def _mount_device_and_volumes(self):
if self.root_mount is None:
self.root_mount = MountManager(
device=self.custom_args['root_device'])
self.root_mount.mount()
if self.boot_mount is None:
if 's390' in self.arch:
self.boot_mount = MountManager(
device=self.custom_args['boot_device'],
mountpoint=self.root_mount.mountpoint + '/boot/zipl')
else:
self.boot_mount = MountManager(
device=self.custom_args['boot_device'],
mountpoint=self.root_mount.mountpoint + '/boot')
if not self.root_mount.device == self.boot_mount.device:
self.boot_mount.mount()
if self.efi_mount is None and self.custom_args.get('efi_device'):
self.efi_mount = MountManager(
device=self.custom_args['efi_device'],
mountpoint=self.root_mount.mountpoint + '/boot/efi')
self.efi_mount.mount()
if self.volumes and not self.volumes_mount:
for volume_path in Path.sort_by_hierarchy(
sorted(self.volumes.keys())):
volume_mount = MountManager(
device=self.volumes[volume_path]['volume_device'],
mountpoint=self.root_mount.mountpoint + '/' + volume_path)
self.volumes_mount.append(volume_mount)
volume_mount.mount(
options=[self.volumes[volume_path]['volume_options']])
if self.device_mount is None:
self.device_mount = MountManager(
device='/dev', mountpoint=self.root_mount.mountpoint + '/dev')
self.device_mount.bind_mount()
if self.proc_mount is None:
self.proc_mount = MountManager(
device='/proc',
mountpoint=self.root_mount.mountpoint + '/proc')
self.proc_mount.bind_mount()
if self.sysfs_mount is None:
self.sysfs_mount = MountManager(
device='/sys', mountpoint=self.root_mount.mountpoint + '/sys')
self.sysfs_mount.bind_mount()
def _disable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join([
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
])
grub2_install_backup = ''.join([grub2_install, '.orig'])
grub2_install_noop = ''.join([root_path, '/bin/true'])
Command.run(['cp', '-p', grub2_install, grub2_install_backup])
Command.run(['cp', grub2_install_noop, grub2_install])
def _enable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join([
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
])
grub2_install_backup = ''.join([grub2_install, '.orig'])
if os.path.exists(grub2_install_backup):
Command.run(['mv', grub2_install_backup, grub2_install])
def _get_grub2_install_tool_name(self, root_path):
return self._get_tool_name(
root_path, lookup_list=['grub2-install', 'grub-install'])
def _get_shim_install_tool_name(self, root_path):
return self._get_tool_name(root_path,
lookup_list=['shim-install'],
fallback_on_not_found=False)
def _get_tool_name(self,
root_path,
lookup_list,
fallback_on_not_found=True):
for tool in lookup_list:
if Path.which(filename=tool, root_dir=root_path):
return tool
if fallback_on_not_found:
# no tool from the list was found, we intentionally don't
# raise here but return the default tool name and raise
# an exception at invocation time in order to log the
# expected call and its arguments
return lookup_list[0]
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
for volume_mount in reversed(self.volumes_mount):
volume_mount.umount()
if self.device_mount:
self.device_mount.umount()
if self.proc_mount:
self.proc_mount.umount()
if self.sysfs_mount:
self.sysfs_mount.umount()
if self.efi_mount:
self.efi_mount.umount()
if self.boot_mount:
self.boot_mount.umount()
if self.root_mount:
self._enable_grub2_install(self.root_mount.mountpoint)
self.root_mount.umount()
class TestMountManager:
def setup(self):
self.mount_manager = MountManager(
'/dev/some-device', '/some/mountpoint'
)
@patch('kiwi.mount_manager.mkdtemp')
def test_setup_empty_mountpoint(self, mock_mkdtemp):
mock_mkdtemp.return_value = 'tmpdir'
mount_manager = MountManager('/dev/some-device')
assert mount_manager.mountpoint == 'tmpdir'
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_bind_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.bind_mount()
mock_command.assert_called_once_with(
['mount', '-n', '--bind', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.mount(['options'])
mock_command.assert_called_once_with(
['mount', '-o', 'options', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_lazy(self, mock_mounted, mock_command):
mock_mounted.return_value = True
self.mount_manager.umount_lazy()
mock_command.assert_called_once_with(
['umount', '-l', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
@patch('kiwi.logger.log.warning')
def test_umount_with_errors(
self, mock_warn, mock_sleep, mock_mounted, mock_command
):
mock_command.side_effect = Exception
mock_mounted.return_value = True
assert self.mount_manager.umount() is False
assert mock_command.call_args_list == [
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint'])
]
assert mock_warn.called
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_success(self, mock_mounted, mock_command):
mock_mounted.return_value = True
assert self.mount_manager.umount() is True
mock_command.assert_called_once_with(
['umount', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_true(self, mock_command):
command = mock.Mock()
command.returncode = 0
mock_command.return_value = command
assert self.mount_manager.is_mounted() is True
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False
)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_false(self, mock_command):
command = mock.Mock()
command.returncode = 1
mock_command.return_value = command
assert self.mount_manager.is_mounted() is False
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False
)
@patch('kiwi.mount_manager.Path.wipe')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_destructor(self, mock_mounted, mock_wipe):
self.mount_manager.mountpoint_created_by_mount_manager = True
mock_mounted.return_value = False
self.mount_manager.__del__()
mock_wipe.assert_called_once_with('/some/mountpoint')
def mount(self) -> None:
"""
Mount image system from current block layers
"""
# mount root boot and efi devices as they are present
(root_device, boot_device, efi_device) = self._setup_device_names()
root_mount = MountManager(device=root_device)
if 's390' in self.arch:
boot_mount = MountManager(device=boot_device,
mountpoint=os.path.join(
root_mount.mountpoint, 'boot',
'zipl'))
else:
boot_mount = MountManager(device=boot_device,
mountpoint=os.path.join(
root_mount.mountpoint, 'boot'))
if efi_device:
efi_mount = MountManager(device=efi_device,
mountpoint=os.path.join(
root_mount.mountpoint, 'boot', 'efi'))
self.mount_list.append(root_mount)
root_mount.mount()
if not root_mount.device == boot_mount.device:
self.mount_list.append(boot_mount)
boot_mount.mount()
if efi_device:
self.mount_list.append(efi_mount)
efi_mount.mount()
if self.volumes:
self._mount_volumes(root_mount.mountpoint)
# bind mount /image from unpacked root to get access to e.g scripts
image_mount = MountManager(device=os.path.join(self.root_dir, 'image'),
mountpoint=os.path.join(
root_mount.mountpoint, 'image'))
self.mount_list.append(image_mount)
image_mount.bind_mount()
# mount tmp as tmpfs
tmp_mount = MountManager(device='tmpfs',
mountpoint=os.path.join(
root_mount.mountpoint, 'tmp'))
self.mount_list.append(tmp_mount)
tmp_mount.tmpfs_mount()
# mount var/tmp as tmpfs
var_tmp_mount = MountManager(device='tmpfs',
mountpoint=os.path.join(
root_mount.mountpoint, 'var', 'tmp'))
self.mount_list.append(var_tmp_mount)
var_tmp_mount.tmpfs_mount()
# mount dev as bind
device_mount = MountManager(device='/dev',
mountpoint=os.path.join(
root_mount.mountpoint, 'dev'))
self.mount_list.append(device_mount)
device_mount.bind_mount()
# mount proc as bind
proc_mount = MountManager(device='/proc',
mountpoint=os.path.join(
root_mount.mountpoint, 'proc'))
self.mount_list.append(proc_mount)
proc_mount.bind_mount()
class TestMountManager(object):
def setup(self):
self.mount_manager = MountManager(
'/dev/some-device', '/some/mountpoint'
)
@patch('kiwi.mount_manager.mkdtemp')
def test_setup_empty_mountpoint(self, mock_mkdtemp):
mock_mkdtemp.return_value = 'tmpdir'
mount_manager = MountManager('/dev/some-device')
assert mount_manager.mountpoint == 'tmpdir'
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_bind_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.bind_mount()
mock_command.assert_called_once_with(
['mount', '-n', '--bind', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.mount(['options'])
mock_command.assert_called_once_with(
['mount', '-o', 'options', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_lazy(self, mock_mounted, mock_command):
mock_mounted.return_value = True
self.mount_manager.umount_lazy()
mock_command.assert_called_once_with(
['umount', '-l', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
@patch('kiwi.logger.log.warning')
def test_umount_with_errors(
self, mock_warn, mock_sleep, mock_mounted, mock_command
):
mock_command.side_effect = Exception
mock_mounted.return_value = True
assert self.mount_manager.umount() is False
assert mock_command.call_args_list == [
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint'])
]
assert mock_warn.called
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_success(self, mock_mounted, mock_command):
mock_mounted.return_value = True
assert self.mount_manager.umount() is True
mock_command.assert_called_once_with(
['umount', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_true(self, mock_command):
command = mock.Mock()
command.returncode = 0
mock_command.return_value = command
assert self.mount_manager.is_mounted() is True
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_false(self, mock_command):
command = mock.Mock()
command.returncode = 1
mock_command.return_value = command
assert self.mount_manager.is_mounted() is False
@patch('kiwi.mount_manager.Path.wipe')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_destructor(self, mock_mounted, mock_wipe):
self.mount_manager.mountpoint_created_by_mount_manager = True
mock_mounted.return_value = False
self.mount_manager.__del__()
mock_wipe.assert_called_once_with('/some/mountpoint')
class TestMountManager:
@fixture(autouse=True)
def inject_fixtures(self, caplog):
self._caplog = caplog
def setup(self):
self.mount_manager = MountManager(
'/dev/some-device', '/some/mountpoint'
)
@patch('kiwi.mount_manager.Temporary')
def test_setup_empty_mountpoint(self, mock_Temporary):
mock_Temporary.return_value.new_dir.return_value.name = 'tmpdir'
mount_manager = MountManager('/dev/some-device')
assert mount_manager.mountpoint == 'tmpdir'
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_bind_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.bind_mount()
mock_command.assert_called_once_with(
['mount', '-n', '--bind', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.mount(['options'])
mock_command.assert_called_once_with(
['mount', '-o', 'options', '/dev/some-device', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_lazy(self, mock_mounted, mock_command):
mock_mounted.return_value = True
self.mount_manager.umount_lazy()
mock_command.assert_called_once_with(
['umount', '-l', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
def test_umount_with_errors(
self, mock_sleep, mock_mounted, mock_command
):
mock_command.side_effect = Exception
mock_mounted.return_value = True
with self._caplog.at_level(logging.WARNING):
assert self.mount_manager.umount() is False
assert mock_command.call_args_list == [
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint']),
call(['umount', '/some/mountpoint'])
]
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_success(self, mock_mounted, mock_command):
mock_mounted.return_value = True
assert self.mount_manager.umount() is True
mock_command.assert_called_once_with(
['umount', '/some/mountpoint']
)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_true(self, mock_command):
command = Mock()
command.returncode = 0
mock_command.return_value = command
assert self.mount_manager.is_mounted() is True
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False
)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_false(self, mock_command):
command = Mock()
command.returncode = 1
mock_command.return_value = command
assert self.mount_manager.is_mounted() is False
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False
)
class BootLoaderInstallGrub2(BootLoaderInstallBase):
"""
grub2 bootloader installation
Attributes
* :attr:`arch`
platform.machine
* :attr:`firmware`
Instance of FirmWare
* :attr:`efi_mount`
Instance of MountManager for EFI device
* :attr:`root_mount`
Instance of MountManager for root device
* :attr:`boot_mount`
Instance of MountManager for boot device
* :attr:`device_mount`
Instance of MountManager for /dev tree
* :attr:`proc_mount`
Instance of MountManager for proc
* :attr:`sysfs_mount`
Instance of MountManager for sysfs
"""
def post_init(self, custom_args):
"""
grub2 post initialization method
Setup class attributes
"""
self.arch = platform.machine()
self.custom_args = custom_args
self.install_arguments = []
self.firmware = None
self.efi_mount = None
self.root_mount = None
self.boot_mount = None
self.device_mount = None
self.proc_mount = None
self.sysfs_mount = None
self.volumes = None
self.volumes_mount = []
self.target_removable = None
if custom_args and 'target_removable' in custom_args:
self.target_removable = custom_args['target_removable']
if custom_args and 'system_volumes' in custom_args:
self.volumes = custom_args['system_volumes']
if custom_args and 'firmware' in custom_args:
self.firmware = custom_args['firmware']
if self.firmware and self.firmware.efi_mode():
if not custom_args or 'efi_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'EFI device name required for shim installation'
)
if not custom_args or 'boot_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'boot device name required for grub2 installation'
)
if not custom_args or 'root_device' not in custom_args:
raise KiwiBootLoaderGrubInstallError(
'root device name required for grub2 installation'
)
def install_required(self):
"""
Check if grub2 has to be installed
Take architecture and firmware setup into account to check if
bootloader code in a boot record is required
:rtype: bool
"""
if 'ppc64' in self.arch and self.firmware.opal_mode():
# OPAL doesn't need a grub2 stage1, just a config file.
# The machine will be setup to kexec grub2 in user space
log.info(
'No grub boot code installation in opal mode on %s', self.arch
)
return False
elif 'arm' in self.arch or self.arch == 'aarch64':
# On arm grub2 is used for EFI setup only, no install
# of grub2 boot code makes sense
log.info(
'No grub boot code installation on %s', self.arch
)
return False
return True
def install(self):
"""
Install bootloader on disk device
"""
log.info('Installing grub2 on disk %s', self.device)
if self.target_removable:
self.install_arguments.append('--removable')
if self.arch == 'x86_64' or self.arch == 'i686' or self.arch == 'i586':
self.target = 'i386-pc'
self.install_device = self.device
self.modules = ' '.join(
Defaults.get_grub_bios_modules(multiboot=True)
)
self.install_arguments.append('--skip-fs-probe')
elif self.arch.startswith('ppc64'):
if not self.custom_args or 'prep_device' not in self.custom_args:
raise KiwiBootLoaderGrubInstallError(
'prep device name required for grub2 installation on ppc'
)
self.target = 'powerpc-ieee1275'
self.install_device = self.custom_args['prep_device']
self.modules = ' '.join(Defaults.get_grub_ofw_modules())
self.install_arguments.append('--skip-fs-probe')
self.install_arguments.append('--no-nvram')
else:
raise KiwiBootLoaderGrubPlatformError(
'host architecture %s not supported for grub2 installation' %
self.arch
)
self.root_mount = MountManager(
device=self.custom_args['root_device']
)
self.boot_mount = MountManager(
device=self.custom_args['boot_device'],
mountpoint=self.root_mount.mountpoint + '/boot'
)
self.root_mount.mount()
if not self.root_mount.device == self.boot_mount.device:
self.boot_mount.mount()
if self.volumes:
for volume_path in Path.sort_by_hierarchy(
sorted(self.volumes.keys())
):
volume_mount = MountManager(
device=self.volumes[volume_path]['volume_device'],
mountpoint=self.root_mount.mountpoint + '/' + volume_path
)
self.volumes_mount.append(volume_mount)
volume_mount.mount(
options=[self.volumes[volume_path]['volume_options']]
)
self.device_mount = MountManager(
device='/dev',
mountpoint=self.root_mount.mountpoint + '/dev'
)
self.proc_mount = MountManager(
device='/proc',
mountpoint=self.root_mount.mountpoint + '/proc'
)
self.sysfs_mount = MountManager(
device='/sys',
mountpoint=self.root_mount.mountpoint + '/sys'
)
self.device_mount.bind_mount()
self.proc_mount.bind_mount()
self.sysfs_mount.bind_mount()
# check if a grub installation could be found in the image system
grub_directory = Defaults.get_grub_path(
self.root_mount.mountpoint + '/usr/lib'
)
if not grub_directory:
raise KiwiBootLoaderGrubDataError(
'No grub2 installation found in %s' % self.root_mount.mountpoint
)
grub_directory = grub_directory.replace(
self.root_mount.mountpoint, ''
)
module_directory = grub_directory + '/' + self.target
boot_directory = '/boot'
# wipe existing grubenv to allow the grub installer to create a new one
grubenv_glob = os.sep.join(
[self.root_mount.mountpoint, 'boot', '*', 'grubenv']
)
for grubenv in glob.glob(grubenv_glob):
Path.wipe(grubenv)
# install grub2 boot code
Command.run(
[
'chroot', self.root_mount.mountpoint,
self._get_grub2_install_tool_name(self.root_mount.mountpoint)
] + self.install_arguments + [
'--directory', module_directory,
'--boot-directory', boot_directory,
'--target', self.target,
'--modules', self.modules,
self.install_device
]
)
if self.firmware and self.firmware.efi_mode() == 'uefi':
shim_install = self._get_shim_install_tool_name(
self.root_mount.mountpoint
)
# if shim-install does _not_ exist the fallback mechanism
# has applied at the bootloader/config level and we expect
# no further tool calls to be required
if shim_install:
self.efi_mount = MountManager(
device=self.custom_args['efi_device'],
mountpoint=self.root_mount.mountpoint + '/boot/efi'
)
self.efi_mount.mount()
# Before we call shim-install, the grub installer binary is
# replaced by a noop. Actually there is no reason for
# shim-install to call the grub installer because it should
# only setup the system for EFI secure boot which does not
# require any bootloader code in the master boot record.
# In addition kiwi has called the grub installer right
# before
self._disable_grub2_install(self.root_mount.mountpoint)
Command.run(
[
'chroot', self.root_mount.mountpoint,
'shim-install', '--removable',
self.install_device
]
)
# restore the grub installer noop
self._enable_grub2_install(self.root_mount.mountpoint)
def _disable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join(
[
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
]
)
grub2_install_backup = ''.join(
[grub2_install, '.orig']
)
grub2_install_noop = ''.join(
[root_path, '/bin/true']
)
Command.run(
['cp', '-p', grub2_install, grub2_install_backup]
)
Command.run(
['cp', grub2_install_noop, grub2_install]
)
def _enable_grub2_install(self, root_path):
if os.access(root_path, os.W_OK):
grub2_install = ''.join(
[
root_path, '/usr/sbin/',
self._get_grub2_install_tool_name(root_path)
]
)
grub2_install_backup = ''.join(
[grub2_install, '.orig']
)
if os.path.exists(grub2_install_backup):
Command.run(
['cp', '-p', grub2_install_backup, grub2_install]
)
def _get_grub2_install_tool_name(self, root_path):
return self._get_tool_name(
root_path, lookup_list=['grub2-install', 'grub-install']
)
def _get_shim_install_tool_name(self, root_path):
return self._get_tool_name(
root_path, lookup_list=['shim-install'], fallback_on_not_found=False
)
def _get_tool_name(
self, root_path, lookup_list, fallback_on_not_found=True
):
chroot_env = {'PATH': os.sep.join([root_path, 'usr', 'sbin'])}
for tool in lookup_list:
if Path.which(filename=tool, custom_env=chroot_env):
return tool
if fallback_on_not_found:
# no tool from the list was found, we intentionally don't
# raise here but return the default tool name and raise
# an exception at invocation time in order to log the
# expected call and its arguments
return lookup_list[0]
def __del__(self):
log.info('Cleaning up %s instance', type(self).__name__)
for volume_mount in reversed(self.volumes_mount):
volume_mount.umount()
if self.device_mount:
self.device_mount.umount()
if self.proc_mount:
self.proc_mount.umount()
if self.sysfs_mount:
self.sysfs_mount.umount()
if self.efi_mount:
self.efi_mount.umount()
if self.boot_mount:
self.boot_mount.umount()
if self.root_mount:
self._enable_grub2_install(self.root_mount.mountpoint)
self.root_mount.umount()
class TestMountManager:
@fixture(autouse=True)
def inject_fixtures(self, caplog):
self._caplog = caplog
def setup(self):
self.mount_manager = MountManager('/dev/some-device',
'/some/mountpoint')
@patch('kiwi.mount_manager.Temporary')
def test_setup_empty_mountpoint(self, mock_Temporary):
mock_Temporary.return_value.new_dir.return_value.name = 'tmpdir'
mount_manager = MountManager('/dev/some-device')
assert mount_manager.mountpoint == 'tmpdir'
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_bind_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.bind_mount()
mock_command.assert_called_once_with(
['mount', '-n', '--bind', '/dev/some-device', '/some/mountpoint'])
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_mount(self, mock_mounted, mock_command):
mock_mounted.return_value = False
self.mount_manager.mount(['options'])
mock_command.assert_called_once_with(
['mount', '-o', 'options', '/dev/some-device', '/some/mountpoint'])
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_lazy(self, mock_mounted, mock_command):
mock_mounted.return_value = True
self.mount_manager.umount_lazy()
mock_command.assert_called_once_with(
['umount', '-l', '/some/mountpoint'])
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
def test_umount_with_errors(self, mock_sleep, mock_mounted, mock_command):
mock_command.side_effect = Exception
mock_mounted.return_value = True
with self._caplog.at_level(logging.WARNING):
assert self.mount_manager.umount(raise_on_busy=False) is False
assert mock_command.call_args_list == [
call(['umount', '/some/mountpoint']), # 1
call(['umount', '/some/mountpoint']), # 2
call(['umount', '/some/mountpoint']), # 3
call(['umount', '/some/mountpoint']), # 4
call(['umount', '/some/mountpoint']), # 5
call(['umount', '/some/mountpoint']), # 6
call(['umount', '/some/mountpoint']), # 7
call(['umount', '/some/mountpoint']), # 8
call(['umount', '/some/mountpoint']), # 9
call(['umount', '/some/mountpoint']) # 10
]
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
@patch('kiwi.mount_manager.Path.which')
def test_umount_with_errors_raises_no_lsof_present(self, mock_Path_which,
mock_sleep,
mock_mounted,
mock_command):
def command_call(args):
if 'umount' in args:
raise Exception
mock_Path_which.return_value = None
mock_command.side_effect = command_call
mock_mounted.return_value = True
with raises(KiwiUmountBusyError):
self.mount_manager.umount()
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
@patch('time.sleep')
@patch('kiwi.mount_manager.Path.which')
def test_umount_with_errors_raises_lsof_present(self, mock_Path_which,
mock_sleep, mock_mounted,
mock_command):
def command_call(args, raise_on_error=None):
if 'umount' in args:
raise Exception
else:
call_return = Mock()
call_return.output = 'HEADLINE\ndata'
return call_return
mock_Path_which.return_value = 'lsof'
mock_command.side_effect = command_call
mock_mounted.return_value = True
with raises(KiwiUmountBusyError) as issue:
self.mount_manager.umount()
assert 'HEADLINE' in issue.value.message
@patch('kiwi.mount_manager.Command.run')
@patch('kiwi.mount_manager.MountManager.is_mounted')
def test_umount_success(self, mock_mounted, mock_command):
mock_mounted.return_value = True
assert self.mount_manager.umount() is True
mock_command.assert_called_once_with(['umount', '/some/mountpoint'])
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_true(self, mock_command):
command = Mock()
command.returncode = 0
mock_command.return_value = command
assert self.mount_manager.is_mounted() is True
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False)
@patch('kiwi.mount_manager.Command.run')
def test_is_mounted_false(self, mock_command):
command = Mock()
command.returncode = 1
mock_command.return_value = command
assert self.mount_manager.is_mounted() is False
mock_command.assert_called_once_with(
command=['mountpoint', '-q', '/some/mountpoint'],
raise_on_error=False)
