-#!/usr/bin/env python
+#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0302
"""
This script installs a Grml system (either a running system or ISO[s]) to a USB device
-:copyright: (c) 2009, 2010, 2011 by Michael Prokop <mika@grml.org>
+:copyright: (c) 2009-2019 by Michael Prokop <mika@grml.org>
:license: GPL v2 or any later version
:bugreports: http://grml.org/bugs/
"""
-from __future__ import print_function
+
from optparse import OptionParser
from inspect import isroutine, isclass
import datetime
import shutil
# The line following this line is patched by debian/rules and tarball.sh.
-PROG_VERSION = '***UNRELEASED***'
+PROG_VERSION = '***UNKNOWN***'
+
+# when running from inside git, try to report version information via git-describe
+try:
+ git_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
+ with open(os.devnull, 'w') as devnull:
+ PROG_VERSION = subprocess.check_output(["git",
+ "-C",
+ git_dir,
+ "describe",
+ "--always",
+ "--dirty"],
+ stderr=devnull).strip().decode('utf-8', errors='replace') + \
+ " (git)"
+except Exception:
+ pass
# global variables
MOUNTED = set() # register mountpoints
GRML_FLAVOURS = set() # which flavours are being installed?
GRML_DEFAULT = None
UUID = None
-SYSLINUX_LIBS = "/usr/lib/syslinux/"
-GPT_HEADER = "\x55\xaa\x45\x46\x49\x20\x50\x41\x52\x54" # original GPT header
+SYSLINUX_LIBS = "/usr/lib/syslinux/modules/bios/"
+GPT_HEADER = b"\x55\xaa\x45\x46\x49\x20\x50\x41\x52\x54" # original GPT header
GRUB_INSTALL = None
RE_PARTITION = re.compile(r'([a-z/]*?)(\d+)$')
setattr(opt_parser.values, option.dest, True)
setattr(opt_parser.values, 'syslinux', False)
+
# cmdline parsing
-USAGE = "Usage: %prog [options] <[ISO[s] | /lib/live/mount/medium]> </dev/sdX#>\n\
+USAGE = "Usage: %prog [options] <[ISO[s] | /run/live/medium]> </dev/sdX#>\n\
\n\
%prog installs Grml ISO[s] to an USB device to be able to boot from it.\n\
-Make sure you have at least one Grml ISO or a running Grml system (/lib/live/mount/medium),\n\
+Make sure you have at least one Grml ISO or a running Grml system (/run/live/medium),\n\
grub or syslinux and root access.\n\
\n\
Run %prog --help for usage hints, further information via: man grml2usb"
help="do not output anything but just errors on console")
parser.add_option("--remove-bootoption", dest="removeoption", action="append",
help="regex for removing existing bootoptions")
+parser.add_option("--rw-blockdev", dest="rwblockdev", action="store_true",
+ help="enforce read-write mode on involved block devices")
parser.add_option("--skip-addons", dest="skipaddons", action="store_true",
help="do not install /boot/addons/ files")
parser.add_option("--skip-bootflag", dest="skipbootflag", action="store_true",
GRML2USB_BASE = os.path.dirname(os.path.realpath(__file__))
+class HodorException(Exception):
+ """Throw exception if the exact error is not known and not fatal.
+
+ @Exception: message"""
+
+
class CriticalException(Exception):
"""Throw critical exception if the exact error is not known but fatal.
try:
unmount(device, "")
logging.debug('Unmounted %s' % device)
- except StandardError:
+ except Exception:
logging.debug('RuntimeError while umount %s, ignoring' % device)
for tmppath in TMPFILES.copy():
os.unlink(tmppath)
logging.debug('temporary file %s deleted' % tmppath)
unregister_tmpfile(tmppath)
- except StandardError:
+ except Exception:
msg = 'RuntimeError while removing temporary %s, ignoring'
logging.debug(msg % tmppath)
def get_function_name(obj):
- """Helper function for use in execute() to retrive name of a function
+ """Helper function for use in execute() to retrieve name of a function
@obj: the function object
"""
return obj.__module__ + '.' + obj.__name__
+def set_rw(device):
+ if not options.rwblockdev:
+ return
+
+ logging.debug("executing: blockdev --setrw %s", device)
+ proc = subprocess.Popen(["blockdev", "--setrw", device])
+ proc.wait()
+ if proc.returncode != 0:
+ raise Exception("error executing blockdev on %s" % device)
+
+
def execute(f, *exec_arguments):
"""Wrapper for executing a command. Either really executes
the command (default) or when using --dry-run commandline option
"""
bootloader_dirs = ['/boot/isolinux/', '/boot/syslinux/']
for directory in bootloader_dirs:
- for name in name, \
- "%s_%s" % (get_flavour_filename(flavour), name):
+ for name in name, "%s_%s" % (get_flavour_filename(flavour), name):
if os.path.isfile(iso_mount + directory + name):
return (directory, name)
return ('', '')
-def search_file(filename, search_path='/bin' + os.pathsep + '/usr/bin', lst_return=False):
+def search_file(filename, search_path='/bin' + os.pathsep + '/usr/bin', lst_return=False, required=False):
"""Given a search path, find file
@filename: name of file to search for
retval.append(os.path.abspath(os.path.join(current_dir, filename)))
if not lst_return:
break
+
+ if required and not retval:
+ raise CriticalException("Required file %s not found in %s" % (filename, search_path))
+
if lst_return:
return retval
elif retval:
try:
import parted
part = get_partition_for_path(device)
+ if part is None:
+ raise HodorException("parted could not find partition")
if part.getFlag(parted.PARTITION_BOOT):
logging.debug("bootflag is enabled on %s" % device)
return
- except ImportError, e:
+ except HodorException as e:
+ logging.info("%s, falling back to old bootflag detection", e)
+ except ImportError as e:
logging.debug("could not import parted, falling back to old bootflag detection")
- with open(boot_dev, 'r') as image:
+ with open(boot_dev, 'rb') as image:
data = image.read(520)
bootcode = data[440:]
gpt_data = bootcode[70:80]
if gpt_data == GPT_HEADER:
logging.info("GPT detected, skipping bootflag check")
- elif bootcode[6] == '\x80':
+ elif bootcode[6] == b"\x80":
logging.debug("bootflag is enabled")
else:
logging.debug("bootflag is NOT enabled")
device_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
register_tmpfile(device_mountpoint)
try:
- mount(device, device_mountpoint, "")
-
# If using --grub-mbr then make sure we install grub in MBR instead of PBR
if options.grubmbr:
logging.debug("Using option --grub-mbr ...")
else:
grub_device = device
+ set_rw(device)
+ mount(device, device_mountpoint, "")
+
logging.info("Installing grub as bootloader")
- for opt in ["", "--force"]:
- logging.debug("grub-install --recheck %s --no-floppy --root-directory=%s %s",
- opt, device_mountpoint, grub_device)
- proc = subprocess.Popen([GRUB_INSTALL, "--recheck", opt,
+ for opt in ["--", "--force"]:
+ set_rw(device)
+ set_rw(grub_device)
+ logging.debug("%s --recheck --no-floppy --target=i386-pc --root-directory=%s %s %s",
+ GRUB_INSTALL, device_mountpoint, opt, grub_device)
+ proc = subprocess.Popen([GRUB_INSTALL, "--recheck",
"--no-floppy", "--target=i386-pc",
- "--root-directory=%s" % device_mountpoint, grub_device],
- stdout=file(os.devnull, "r+"))
+ "--root-directory=%s" % device_mountpoint,
+ opt, grub_device],
+ stdout=open(os.devnull, "r+"))
proc.wait()
if proc.returncode == 0:
break
if proc.returncode != 0:
# raise Exception("error executing grub-install")
- logging.critical("Fatal: error executing grub-install "
- + "(please check the grml2usb FAQ or drop the --grub option)")
- logging.critical("Note: if using grub2 consider using "
- + "the --grub-mbr option as grub considers PBR problematic.")
+ logging.critical("Fatal: error executing grub-install " +
+ "(please check the grml2usb FAQ or drop the --grub option)")
+ logging.critical("Note: if using grub2 consider using " +
+ "the --grub-mbr option as grub considers PBR problematic.")
cleanup()
sys.exit(1)
except CriticalException as error:
logging.info("Would install syslinux as bootloader on %s", device)
return 0
+ set_rw(device)
+
# syslinux -d boot/isolinux /dev/sdb1
logging.info("Installing syslinux as bootloader")
logging.debug("syslinux -d boot/syslinux %s", device)
logging.debug("executing: dd if='%s' of='%s' bs=512 count=1", device, tmpf.name)
proc = subprocess.Popen(["dd", "if=%s" % device, "of=%s" % tmpf.name, "bs=512", "count=1"],
- stderr=file(os.devnull, "r+"))
+ stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (first run)")
logging.debug("executing: dd if=%s of=%s bs=%s count=1 conv=notrunc", mbrtemplate,
tmpf.name, nmbrbytes)
proc = subprocess.Popen(["dd", "if=%s" % mbrtemplate, "of=%s" % tmpf.name, "bs=%s" % nmbrbytes,
- "count=1", "conv=notrunc"], stderr=file(os.devnull, "r+"))
+ "count=1", "conv=notrunc"], stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (second run)")
if partition is not None:
if ismirbsdmbr:
- mbrcode = mbrcode[0:439] + chr(partition) + \
- mbrcode[440:510] + "\x55\xAA"
+ mbrcode = mbrcode[0:439] + chr(partition).encode('latin-1') + \
+ mbrcode[440:510] + b"\x55\xAA"
else:
- actives = ["\x00", "\x00", "\x00", "\x00"]
- actives[partition] = "\x80"
+ actives = [b"\x00", b"\x00", b"\x00", b"\x00"]
+ actives[partition] = b"\x80"
mbrcode = mbrcode[0:446] + actives[0] + \
mbrcode[447:462] + actives[1] + \
mbrcode[463:478] + actives[2] + \
mbrcode[479:494] + actives[3] + \
- mbrcode[495:510] + "\x55\xAA"
+ mbrcode[495:510] + b"\x55\xAA"
tmpf.file.seek(0)
tmpf.file.truncate()
tmpf.file.write(mbrcode)
tmpf.file.close()
+ set_rw(device)
+
logging.debug("executing: dd if='%s' of='%s' bs=512 count=1 conv=notrunc", tmpf.name, device)
proc = subprocess.Popen(["dd", "if=%s" % tmpf.name, "of=%s" % device, "bs=512", "count=1",
- "conv=notrunc"], stderr=file(os.devnull, "r+"))
+ "conv=notrunc"], stderr=open(os.devnull, "r+"))
proc.wait()
if proc.returncode != 0:
raise Exception("error executing dd (third run)")
proc = subprocess.Popen(["sync"])
proc.wait()
+ set_rw(device)
+
def is_writeable(device):
"""Check if the device is writeable for the current user
if not device:
return False
- #raise Exception("no device for checking write permissions")
if not os.path.exists(device):
return False
# note: options.dryrun does not work here, as we have to
# locate files and identify the grml flavour
- for x in file('/proc/mounts').readlines():
+ for x in open('/proc/mounts', 'r').readlines():
if x.startswith(source):
- raise CriticalException("Error executing mount: %s already mounted - " % source
- + "please unmount before invoking grml2usb")
+ raise CriticalException("Error executing mount: %s already mounted - " % source +
+ "please unmount before invoking grml2usb")
if os.path.isdir(source):
logging.debug("Source %s is not a device, therefore not mounting.", source)
" (wrong UID/permissions or device/directory not present?)" % partition)
try:
- udev_info = subprocess.Popen(["/sbin/blkid", "-s", "TYPE", "-o", "value", partition],
- stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- filesystem = udev_info.communicate()[0].rstrip()
+ filesystem = subprocess.check_output(["/sbin/blkid", "-s", "TYPE", "-o", "value", partition]).decode().rstrip()
if filesystem != "vfat":
raise CriticalException(
"(Use --fat16 or run mkfs.vfat %s)" % (partition, partition))
except OSError:
- raise CriticalException("Sorry, /sbin/blkid not available (install e2fsprogs?)")
+ raise CriticalException("Sorry, /sbin/blkid not available (install util-linux?)")
def mkdir(directory):
# update the existing flavours on the target
for line in fileinput.input([target_grml_version_file], inplace=1):
flavour = get_flavour(line)
- if flavour in iso_versions.keys():
+ if flavour in list(iso_versions.keys()):
print(iso_versions.pop(flavour))
else:
print(line.strip())
logging.warn("Warning: could not find flavour directory for %s ", grml_flavour)
-def handle_addon_copy(filename, dst, iso_mount, ignore_errors=False):
- """handle copy of optional addons
-
- @filename: filename of the addon
- @dst: destination directory
- @iso_mount: location of the iso mount
- @ignore_errors: don't report missing files
- """
- file_location = search_file(filename, iso_mount)
- if file_location is None:
- if not ignore_errors:
- logging.warn("Warning: %s not found (that's fine if you don't need it)", filename)
- else:
- exec_rsync(file_location, dst)
-
-
def copy_addons(iso_mount, target):
"""copy grml's addons files (like allinoneimg, bsd4grml,..) to a given target
addons = target + '/boot/addons/'
execute(mkdir, addons)
- # grub all-in-one image
- handle_addon_copy('allinone.img', addons, iso_mount)
-
- # bsd image
- handle_addon_copy('bsd4grml', addons, iso_mount)
-
- # DOS image
- handle_addon_copy('balder10.imz', addons, iso_mount)
-
- # syslinux + pci.ids for hdt
- for expr in '*.c32', 'pci.ids':
- glob_and_copy(iso_mount + '/boot/addons/' + expr, addons)
-
- # memdisk image
- handle_addon_copy('memdisk', addons, iso_mount)
-
- # memtest86+ image
- handle_addon_copy('memtest', addons, iso_mount)
-
- # gpxe.lkrn: got replaced by ipxe
- handle_addon_copy('gpxe.lkrn', addons, iso_mount, ignore_errors=True)
-
- # ipxe.lkrn
- handle_addon_copy('ipxe.lkrn', addons, iso_mount)
+ for addon_file in glob.glob(iso_mount + '/boot/addons/*'):
+ filename = os.path.basename(addon_file)
+ src_file = iso_mount + "/boot/addons/" + os.path.basename(addon_file)
+ logging.debug("Copying addon file %s" % filename)
+ exec_rsync(src_file, addons)
def build_loopbackcfg(target):
grub_target = target + '/boot/grub/'
execute(mkdir, grub_target)
- logo = search_file('logo.16', iso_mount)
+ logo = search_file('logo.16', iso_mount, required=True)
exec_rsync(logo, syslinux_target + 'logo.16')
bootx64_efi = search_file('bootx64.efi', iso_mount)
if efi_img:
mkdir(target + '/boot/')
exec_rsync(efi_img, target + '/boot/efi.img')
+ handle_secure_boot(target, efi_img)
for ffile in ['f%d' % number for number in range(1, 11)]:
search_and_copy(ffile, iso_mount, syslinux_target + ffile)
logging.warning("Warning: Grml releases older than 2011.12 support only one flavour in grub.")
for expr in name, 'distri.cfg', \
- defaults_file, 'grml.png', 'hd.cfg', 'isolinux.cfg', 'isolinux.bin', \
- 'isoprompt.cfg', 'options.cfg', \
- 'prompt.cfg', 'vesamenu.cfg', 'grml.png', '*.c32':
+ defaults_file, 'grml.png', 'hd.cfg', 'isolinux.cfg', 'isolinux.bin', \
+ 'isoprompt.cfg', 'options.cfg', \
+ 'prompt.cfg', 'vesamenu.cfg', 'grml.png', '*.c32':
glob_and_copy(iso_mount + source_dir + expr, syslinux_target)
for filename in glob.glob1(syslinux_target, "*.c32"):
# copy all grub files from ISO
glob_and_copy(iso_mount + '/boot/grub/*', grub_target)
- # finally (after all GRUB files have been been installed) build static loopback.cfg
+ # finally (after all GRUB files have been installed) build static loopback.cfg
build_loopbackcfg(target)
version_files = search_file('grml-version', mountpath, lst_return=True)
if not version_files:
- if mountpath.startswith("/lib/live/mount/medium"):
+ if mountpath.startswith("/run/live/medium"):
logging.critical("Error: could not find grml-version file.")
logging.critical("Looks like your system is running from RAM but required files are not available.")
logging.critical("Please either boot without toram=... or use boot option toram instead of toram=...")
logging.debug("Updating grub configuration")
grub_target = target + '/boot/grub/'
+ secureboot_target = target + '/EFI/ubuntu/'
bootid_re = re.compile("bootid=[\w_-]+")
live_media_path_re = re.compile("live-media-path=[\w_/-]+")
remove_regexes.append(re.compile(regex))
shortname = get_shortname(grml_flavour)
- for filename in glob.glob(grub_target + '*.cfg'):
+ for filename in glob.glob(grub_target + '*.cfg') + glob.glob(secureboot_target + '*.cfg'):
for line in fileinput.input(filename, inplace=1):
line = line.rstrip("\r\n")
if option_re.search(line):
if shortname in filename:
line = live_media_path_re.sub('', line)
line = line.rstrip() + ' live-media-path=/live/%s/ ' % (grml_flavour)
+ if bootopt.strip():
+ line = line.replace(' {} '.format(bootopt.strip()), ' ')
+ if line.endswith(bootopt):
+ line = line[:-len(bootopt)]
line = line.rstrip() + r' bootid=%s %s ' % (UUID, bootopt)
for regex in remove_regexes:
line = regex.sub(' ', line)
def initial_syslinux_config(target):
- """Generates intial syslinux configuration
+ """Generates initial syslinux configuration
@target path of syslinux's configuration files"""
add_syslinux_entry("%s/additional.cfg" % syslinux_target, flavour_filename)
+def handle_secure_boot(target, efi_img):
+ """Provide secure boot support by extracting files from /boot/efi.img
+
+ @target: path where grml's main files should be copied to
+ @efi_img: path to the efi.img file that includes the files for secure boot
+ """
+
+ mkdir(target + '/efi/boot/')
+ efi_mountpoint = tempfile.mkdtemp(prefix="grml2usb", dir=os.path.abspath(options.tmpdir))
+ logging.debug("efi_mountpoint = %s" % efi_mountpoint)
+ register_tmpfile(efi_mountpoint)
+
+ try:
+ logging.debug("mount(%s, %s, ['-o', 'ro', '-t', 'vfat']" % (efi_img, efi_mountpoint))
+ mount(efi_img, efi_mountpoint, ['-o', 'ro', '-t', 'vfat'])
+ except CriticalException as error:
+ logging.critical("Fatal: %s", error)
+ sys.exit(1)
+
+ ubuntu_cfg = search_file('grub.cfg', efi_mountpoint + '/EFI/ubuntu')
+ logging.debug("ubuntu_cfg = %s" % ubuntu_cfg)
+ if not ubuntu_cfg:
+ logging.info("No /EFI/ubuntu/grub.cfg found inside EFI image, looks like Secure Boot support is missing.")
+ else:
+ mkdir(target + '/efi/ubuntu')
+ logging.debug("exec_rsync(%s, %s + '/efi/ubuntu/grub.cfg')" % (ubuntu_cfg, target))
+ exec_rsync(ubuntu_cfg, target + '/efi/ubuntu/grub.cfg')
+
+ logging.debug("exec_rsync(%s + '/EFI/BOOT/grubx64.efi', %s + '/efi/boot/grubx64.efi')'" % (efi_mountpoint, target))
+ exec_rsync(efi_mountpoint + '/EFI/BOOT/grubx64.efi', target + '/efi/boot/grubx64.efi')
+
+ # NOTE - we're overwriting /efi/boot/bootx64.efi from copy_bootloader_files here
+ logging.debug("exec_rsync(%s + '/EFI/BOOT/bootx64.efi', %s + '/efi/boot/bootx64.efi')'" % (efi_mountpoint, target))
+ exec_rsync(efi_mountpoint + '/EFI/BOOT/bootx64.efi', target + '/efi/boot/bootx64.efi')
+
+ try:
+ unmount(efi_mountpoint, "")
+ logging.debug('Unmounted %s' % efi_mountpoint)
+ os.rmdir(efi_mountpoint)
+ logging.debug('Removed directory %s' % efi_mountpoint)
+ except Exception:
+ logging.critical('RuntimeError while umount %s' % efi_mountpoint)
+ sys.exit(1)
+
+
def handle_bootloader_config(grml_flavour, device, target):
"""Main handler for generating bootloader's configuration
if options.force or os.path.exists(os.path.join(image, 'live')):
logging.info("Using %s as install base", image)
else:
- q = raw_input("%s does not look like a Grml system. "
+ q = input("%s does not look like a Grml system. "
"Do you really want to use this image? y/N " % image)
if q.lower() == 'y':
logging.info("Using %s as install base", image)
def install_grml(mountpoint, device):
"""Main logic for copying files of the currently running Grml system.
- @mountpoint: directory where currently running live system resides (usually /lib/live/mount/medium)
+ @mountpoint: directory where currently running live system resides (usually /run/live/medium)
@device: partition where the specified ISO should be installed to"""
device_mountpoint = device
check_for_fat(device)
if not options.skipbootflag:
check_boot_flag(device)
+
+ set_rw(device)
mount(device, device_mountpoint, ['-o', 'utf8,iocharset=iso8859-1'])
except CriticalException as error:
mount(device, device_mountpoint, "")
print("Forcing mkfs.fat16 on %s as requested via option --force." % device)
else:
# make sure the user is aware of what he is doing
- f = raw_input("Are you sure you want to format the specified partition with fat16? y/N ")
+ f = input("Are you sure you want to format the specified partition with fat16? y/N ")
if f == "y" or f == "Y":
logging.info("Note: you can skip this question using the option --force")
else:
if not os.path.isdir(device) and not check_for_usbdevice(device) and not options.force:
print("Warning: the specified device %s does not look like a removable usb device." % device)
- f = raw_input("Do you really want to continue? y/N ")
+ f = input("Do you really want to continue? y/N ")
if f.lower() != "y":
sys.exit(1)
print("Instead of using grml2usb /path/to/iso %s you might" % device)
print("want to use grml2usb /path/to/iso /dev/... instead.")
print("Please check out the grml2usb manpage for details.")
- f = raw_input("Do you really want to continue? y/N ")
+ f = input("Do you really want to continue? y/N ")
if f.lower() != "y":
sys.exit(1)
def check_options(opts):
- """Check compability of provided user opts
+ """Check compatibility of provided user opts
@opts option dict from OptionParser
"""
global GRUB_INSTALL
GRUB_INSTALL = which("grub-install") or which("grub2-install")
if not GRUB_INSTALL:
- logging.critical("Fatal: grub-install not available (please install the "
- + "grub package or drop the --grub option)")
+ logging.critical("Fatal: grub-install not available (please install the " +
+ "grub package or drop the --grub option)")
sys.exit(1)
if options.syslinux:
if not which("syslinux"):
- logging.critical("Fatal: syslinux not available (please install the "
- + "syslinux package or use the --grub option)")
+ logging.critical("Fatal: syslinux not available (please install the " +
+ "syslinux package or use the --grub option)")
sys.exit(1)
if not which("rsync"):
def load_loop():
- """Runs modprobe loop and throws away it's output"""
+ """Runs modprobe loop and throws away its output"""
if not which("modprobe"):
logging.critical("Fatal: modprobe not available, can not continue - sorry.")
logging.critical("Hint: is /sbin missing in PATH?")
sys.exit(1)
proc = subprocess.Popen(["modprobe", "loop"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- proc.wait()
+ proc.communicate()
def main():
if not os.path.isdir(device):
if device[-1:].isdigit():
if int(device[-1:]) > 4 or device[-2:].isdigit():
- logging.critical("Fatal: installation on partition number >4 not supported. (BIOS won't support it.)")
- sys.exit(1)
+ logging.warn("Warning: installing on partition number >4, booting *might* fail depending on your system.")
# provide upgrade path
handle_compat_warning(device)
except Exception as error:
logging.critical("Fatal: %s", str(error))
+ if options.verbose:
+ logging.exception("Exception:")
sys.exit(1)
logging.info("Received KeyboardInterrupt")
cleanup()
-## END OF FILE #################################################################
+# END OF FILE ##################################################################
# vim:foldmethod=indent expandtab ai ft=python tw=120 fileencoding=utf-8