logo

live-bootstrap

Mirror of <https://github.com/fosslinux/live-bootstrap>

rootfs.py (12785B)

    

  1. #!/usr/bin/env python3
  2. """
  3. A helper application used to start bootstrapping process.
  4. It has a few modes of operation, you can create initramfs with
  5. binary seeds and sources that you can boot into or alternatively
  6. you can run bootstap inside chroot.
  7. """
  9. # SPDX-License-Identifier: GPL-3.0-or-later
  10. # SPDX-FileCopyrightText: 2022 Dor Askayo <dor.askayo@gmail.com>
  11. # SPDX-FileCopyrightText: 2021 Andrius Štikonas <andrius@stikonas.eu>
  12. # SPDX-FileCopyrightText: 2021 Bastian Bittorf <bb@npl.de>
  13. # SPDX-FileCopyrightText: 2021 Melg Eight <public.melg8@gmail.com>
  14. # SPDX-FileCopyrightText: 2021-23 fosslinux <fosslinux@aussies.space>
  15. # SPDX-FileCopyrightText: 2023-24 Gábor Stefanik <netrolller.3d@gmail.com>
  17. import argparse
  18. import os
  20. from lib.utils import run, run_as_root
  21. from lib.target import Target
  22. from lib.generator import Generator, stage0_arch_map
  24. def create_configuration_file(args):
  25.     """
  26.     Creates bootstrap.cfg file which would contain options used to
  27.     customize bootstrap.
  28.     """
  29.     config_path = os.path.join('steps', 'bootstrap.cfg')
  30.     with open(config_path, "w", encoding="utf_8") as config:
  31.         config.write(f"ARCH={args.arch}\n")
  32.         config.write(f"ARCH_DIR={stage0_arch_map.get(args.arch, args.arch)}\n")
  33.         config.write(f"FORCE_TIMESTAMPS={args.force_timestamps}\n")
  34.         config.write(f"CHROOT={args.chroot or args.bwrap}\n")
  35.         config.write(f"UPDATE_CHECKSUMS={args.update_checksums}\n")
  36.         config.write(f"JOBS={args.cores}\n")
  37.         config.write(f"SWAP_SIZE={args.swap}\n")
  38.         config.write(f"FINAL_JOBS={args.cores}\n")
  39.         config.write(f"INTERNAL_CI={args.internal_ci or False}\n")
  40.         config.write(f"INTERACTIVE={args.interactive}\n")
  41.         config.write(f"BARE_METAL={args.bare_metal or (args.qemu and args.interactive)}\n")
  42.         if (args.bare_metal or args.qemu) and not args.kernel:
  43.             if args.repo or args.external_sources:
  44.                 config.write("DISK=sdb1\n")
  45.             else:
  46.                 config.write("DISK=sda\n")
  47.             config.write("KERNEL_BOOTSTRAP=True\n")
  48.         else:
  49.             config.write("DISK=sda1\n")
  50.             config.write("KERNEL_BOOTSTRAP=False\n")
  51.         config.write(f"BUILD_KERNELS={args.update_checksums or args.build_kernels}\n")
  52.         config.write(f"CONFIGURATOR={args.configurator}\n")
  54. # pylint: disable=too-many-statements,too-many-branches
  55. def main():
  56.     """
  57.     A few command line arguments to customize bootstrap.
  58.     This function also creates object which prepares directory
  59.     structure with bootstrap seeds and all sources.
  60.     """
  61.     parser = argparse.ArgumentParser()
  62.     parser.add_argument("-a", "--arch", help="Bootstrap architecture",
  63.                         default="x86")
  64.     parser.add_argument("-c", "--chroot", help="Run inside chroot",
  65.                         action="store_true")
  66.     parser.add_argument("-bw", "--bwrap", help="Run inside a bwrap sandbox",
  67.                         action="store_true")
  68.     parser.add_argument("-t", "--target", help="Target directory",
  69.                         default="target")
  70.     parser.add_argument("--tmpfs", help="Use a tmpfs on target",
  71.                         action="store_true")
  72.     parser.add_argument("--tmpfs-size", help="Size of the tmpfs",
  73.                         default="8G")
  74.     parser.add_argument("--cores", help="Cores to use for building",
  75.                          default=2)
  76.     parser.add_argument("--force-timestamps",
  77.                         help="Force all files timestamps to be 0 unix time",
  78.                         action="store_true")
  79.     parser.add_argument("--update-checksums",
  80.                         help="Update checksum files",
  81.                         action="store_true")
  82.     parser.add_argument("--external-sources",
  83.                         help="Download sources externally from live-bootstrap",
  84.                         action="store_true")
  85.     parser.add_argument("--build-kernels",
  86.                         help="Also build kernels in chroot and bwrap builds",
  87.                         action="store_true")
  88.     parser.add_argument("--no-create-config",
  89.                         help="Do not automatically create config file",
  90.                         action="store_true")
  91.     parser.add_argument("-i", "--interactive",
  92.                         help="Use interactive prompts to resolve issues during bootstrap",
  93.                         action="store_true")
  94.     parser.add_argument("--configurator",
  95.                         help="Run the interactive configurator",
  96.                         action="store_true")
  97.     parser.add_argument("-r", "--repo",
  98.                         help="Path to prebuilt binary packages", nargs=None)
  99.     parser.add_argument("--early-preseed",
  100.                         help="Skip early stages of live-bootstrap", nargs=None)
  101.     parser.add_argument("--internal-ci", help="INTERNAL for github CI")
  102.     parser.add_argument("-s", "--swap", help="Swap space to allocate in Linux",
  103.                         default=0)
  105.     # QEMU arguments
  106.     parser.add_argument("-q", "--qemu", help="Use QEMU",
  107.                         action="store_true")
  108.     parser.add_argument("-qc", "--qemu-cmd", help="QEMU command to run",
  109.                         default="qemu-system-x86_64")
  110.     parser.add_argument("-qr", "--qemu-ram", help="Memory (in megabytes) allocated to QEMU VM",
  111.                         default=4096)
  112.     parser.add_argument("-qs", "--target-size", help="Size of the target image (for QEMU only)",
  113.                         default="16G")
  114.     parser.add_argument("-qk", "--kernel", help="Custom early kernel to use")
  116.     parser.add_argument("-b", "--bare-metal", help="Build images for bare metal",
  117.                         action="store_true")
  119.     args = parser.parse_args()
  121.     # Mode validation
  122.     def check_types():
  123.         count = 0
  124.         if args.qemu:
  125.             count += 1
  126.         if args.chroot:
  127.             count += 1
  128.         if args.bwrap:
  129.             count += 1
  130.         if args.bare_metal:
  131.             count += 1
  132.         return count
  134.     if check_types() > 1:
  135.         raise ValueError("No more than one of qemu, chroot, bwrap, bare metal"
  136.                          "may be used.")
  137.     if check_types() == 0:
  138.         raise ValueError("One of qemu, chroot, bwrap, or bare metal must be selected.")
  140.     # Arch validation
  141.     if args.arch != "x86":
  142.         print("Only x86 is supported at the moment, other arches are for development only.")
  144.     # Tmpfs validation
  145.     if args.bwrap and args.tmpfs:
  146.         raise ValueError("tmpfs cannot be used with bwrap.")
  148.     # Cores validation
  149.     if int(args.cores) < 1:
  150.         raise ValueError("Must use one or more cores.")
  152.     # Target image size validation
  153.     if args.qemu:
  154.         if int(str(args.target_size).rstrip('gGmM')) < 1:
  155.             raise ValueError("Please specify a positive target size for qemu.")
  156.         args.target_size = (int(str(args.target_size).rstrip('gGmM')) *
  157.             (1024 if str(args.target_size).lower().endswith('g') else 1))
  158.     else:
  159.         args.target_size = 0
  161.     # Swap file size validation
  162.     if args.qemu or args.bare_metal:
  163.         args.swap = (int(str(args.swap).rstrip('gGmM')) *
  164.             (1024 if str(args.swap).lower().endswith('g') else 1))
  165.     else:
  166.         args.swap = 0
  168.     # Set constant umask
  169.     os.umask(0o022)
  171.     # bootstrap.cfg
  172.     try:
  173.         os.remove(os.path.join('steps', 'bootstrap.cfg'))
  174.     except FileNotFoundError:
  175.         pass
  176.     if not args.no_create_config:
  177.         create_configuration_file(args)
  178.     else:
  179.         with open(os.path.join('steps', 'bootstrap.cfg'), 'a', encoding='UTF-8'):
  180.             pass
  182.     # target
  183.     target = Target(path=args.target)
  184.     if args.tmpfs:
  185.         target.tmpfs(size=args.tmpfs_size)
  187.     generator = Generator(arch=args.arch,
  188.                           external_sources=args.external_sources,
  189.                           repo_path=args.repo,
  190.                           early_preseed=args.early_preseed)
  192.     bootstrap(args, generator, target, args.target_size)
  194. def bootstrap(args, generator, target, size):
  195.     """Kick off bootstrap process."""
  196.     print(f"Bootstrapping {args.arch}", flush=True)
  197.     if args.chroot:
  198.         find_chroot = """
  199. import shutil
  200. print(shutil.which('chroot'))
  201. """
  202.         chroot_binary = run_as_root('python3', '-c', find_chroot,
  203.                                     capture_output=True).stdout.decode().strip()
  205.         generator.prepare(target, using_kernel=False)
  207.         arch = stage0_arch_map.get(args.arch, args.arch)
  208.         init = os.path.join(os.sep, 'bootstrap-seeds', 'POSIX', arch, 'kaem-optional-seed')
  209.         run_as_root('env', '-i', 'PATH=/bin', chroot_binary, generator.target_dir, init)
  211.     elif args.bwrap:
  212.         init = '/init'
  213.         if not args.internal_ci or args.internal_ci == "pass1":
  214.             generator.prepare(target, using_kernel=False)
  216.             arch = stage0_arch_map.get(args.arch, args.arch)
  217.             init = os.path.join(os.sep, 'bootstrap-seeds', 'POSIX', arch, 'kaem-optional-seed')
  218.         else:
  219.             generator.reuse(target)
  221.         run('env', '-i', 'bwrap', '--unshare-user',
  222.                                   '--uid', '0',
  223.                                   '--gid', '0',
  224.                                   '--unshare-net' if args.external_sources else None,
  225.                                   '--setenv', 'PATH', '/usr/bin',
  226.                                   '--bind', generator.target_dir, '/',
  227.                                   '--dir', '/dev',
  228.                                   '--dev-bind', '/dev/null', '/dev/null',
  229.                                   '--dev-bind', '/dev/zero', '/dev/zero',
  230.                                   '--dev-bind', '/dev/random', '/dev/random',
  231.                                   '--dev-bind', '/dev/urandom', '/dev/urandom',
  232.                                   '--dev-bind', '/dev/ptmx', '/dev/ptmx',
  233.                                   '--dev-bind', '/dev/tty', '/dev/tty',
  234.                                   '--tmpfs', '/dev/shm',
  235.                                   '--proc', '/proc',
  236.                                   '--bind', '/sys', '/sys',
  237.                                   '--tmpfs', '/tmp',
  238.                                   init)
  240.     elif args.bare_metal:
  241.         if args.kernel:
  242.             generator.prepare(target, using_kernel=True, target_size=size)
  243.             path = os.path.join(args.target, os.path.relpath(generator.target_dir, args.target))
  244.             print("Please:")
  245.             print(f"  1. Take {path}/initramfs and your kernel, boot using this.")
  246.             print(f"  2. Take {path}/disk.img and put this on a writable storage medium.")
  247.         else:
  248.             generator.prepare(target, kernel_bootstrap=True, target_size=size)
  249.             path = os.path.join(args.target, os.path.relpath(generator.target_dir, args.target))
  250.             print("Please:")
  251.             print(f"  1. Take {path}.img and write it to a boot drive and then boot it.")
  253.     else:
  254.         if args.kernel:
  255.             generator.prepare(target, using_kernel=True, target_size=size)
  257.             arg_list = [
  258.                 '-enable-kvm',
  259.                 '-m', str(args.qemu_ram) + 'M',
  260.                 '-smp', str(args.cores),
  261.                 '-drive', 'file=' + target.get_disk("disk") + ',format=raw'
  262.             ]
  263.             if target.get_disk("external") is not None:
  264.                 arg_list += [
  265.                     '-drive', 'file=' + target.get_disk("external") + ',format=raw',
  266.                 ]
  267.             arg_list += [
  268.                 '-nic', 'user,ipv6=off,model=e1000',
  269.                 '-kernel', args.kernel,
  270.                 '-append',
  271.             ]
  272.             if args.interactive:
  273.                 arg_list += ['consoleblank=0 earlyprintk=vga root=/dev/sda1 '
  274.                              'rootfstype=ext3 init=/init rw']
  275.             else:
  276.                 arg_list += ['console=ttyS0 earlycon=uart8250,io,0x3f8,115200n8 '
  277.                              'root=/dev/sda1 rootfstype=ext3 init=/init rw']
  278.         else:
  279.             generator.prepare(target, kernel_bootstrap=True, target_size=size)
  280.             arg_list = [
  281.                 '-enable-kvm',
  282.                 '-m', str(args.qemu_ram) + 'M',
  283.                 '-smp', str(args.cores),
  284.                 '-drive', 'file=' + generator.target_dir + '.img' + ',format=raw'
  285.             ]
  286.             if target.get_disk("external") is not None:
  287.                 arg_list += [
  288.                     '-drive', 'file=' + target.get_disk("external") + ',format=raw',
  289.                 ]
  290.             arg_list += [
  291.                 '-machine', 'kernel-irqchip=split',
  292.                 '-nic', 'user,ipv6=off,model=e1000'
  293.             ]
  294.         if not args.interactive:
  295.             arg_list += ['-no-reboot', '-nographic']
  296.         run(args.qemu_cmd, *arg_list)
  298. if __name__ == "__main__":
  299.     main()