logo

live-bootstrap

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

rootfs.py (14194B)

    

  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
  19. import signal
  20. import threading
  22. from lib.generator import Generator, stage0_arch_map
  23. from lib.simple_mirror import SimpleMirror
  24. from lib.target import Target
  25. from lib.utils import run, run_as_root
  27. def create_configuration_file(args):
  28.     """
  29.     Creates bootstrap.cfg file which would contain options used to
  30.     customize bootstrap.
  31.     """
  32.     config_path = os.path.join('steps', 'bootstrap.cfg')
  33.     with open(config_path, "w", encoding="utf_8") as config:
  34.         config.write(f"ARCH={args.arch}\n")
  35.         config.write(f"ARCH_DIR={stage0_arch_map.get(args.arch, args.arch)}\n")
  36.         config.write(f"FORCE_TIMESTAMPS={args.force_timestamps}\n")
  37.         config.write(f"CHROOT={args.chroot or args.bwrap}\n")
  38.         config.write(f"UPDATE_CHECKSUMS={args.update_checksums}\n")
  39.         config.write(f"JOBS={args.cores}\n")
  40.         config.write(f"SWAP_SIZE={args.swap}\n")
  41.         config.write(f"FINAL_JOBS={args.cores}\n")
  42.         config.write(f"INTERNAL_CI={args.internal_ci or False}\n")
  43.         config.write(f"INTERACTIVE={args.interactive}\n")
  44.         config.write(f"BARE_METAL={args.bare_metal or (args.qemu and args.interactive)}\n")
  45.         if (args.bare_metal or args.qemu) and not args.kernel:
  46.             if args.repo or args.external_sources:
  47.                 config.write("DISK=sdb1\n")
  48.             else:
  49.                 config.write("DISK=sda\n")
  50.             config.write("KERNEL_BOOTSTRAP=True\n")
  51.         else:
  52.             config.write("DISK=sda1\n")
  53.             config.write("KERNEL_BOOTSTRAP=False\n")
  54.         config.write(f"BUILD_KERNELS={args.update_checksums or args.build_kernels}\n")
  55.         config.write(f"CONFIGURATOR={args.configurator}\n")
  56.         if not args.external_sources:
  57.             if args.mirrors:
  58.                 config.write(f'MIRRORS="{" ".join(args.mirrors)}"\n')
  59.                 config.write(f"MIRRORS_LEN={len(args.mirrors)}\n")
  60.             else:
  61.                 config.write("MIRRORS_LEN=0\n")
  63. # pylint: disable=too-many-statements,too-many-branches
  64. def main():
  65.     """
  66.     A few command line arguments to customize bootstrap.
  67.     This function also creates object which prepares directory
  68.     structure with bootstrap seeds and all sources.
  69.     """
  70.     parser = argparse.ArgumentParser()
  71.     parser.add_argument("-a", "--arch", help="Bootstrap architecture",
  72.                         default="x86")
  73.     parser.add_argument("-c", "--chroot", help="Run inside chroot",
  74.                         action="store_true")
  75.     parser.add_argument("-bw", "--bwrap", help="Run inside a bwrap sandbox",
  76.                         action="store_true")
  77.     parser.add_argument("-t", "--target", help="Target directory",
  78.                         default="target")
  79.     parser.add_argument("--tmpfs", help="Use a tmpfs on target",
  80.                         action="store_true")
  81.     parser.add_argument("--tmpfs-size", help="Size of the tmpfs",
  82.                         default="8G")
  83.     parser.add_argument("--cores", help="Cores to use for building",
  84.                          default=2)
  85.     parser.add_argument("--force-timestamps",
  86.                         help="Force all files timestamps to be 0 unix time",
  87.                         action="store_true")
  88.     parser.add_argument("--update-checksums",
  89.                         help="Update checksum files",
  90.                         action="store_true")
  91.     parser.add_argument("--external-sources",
  92.                         help="Download sources externally from live-bootstrap",
  93.                         action="store_true")
  94.     parser.add_argument("--build-kernels",
  95.                         help="Also build kernels in chroot and bwrap builds",
  96.                         action="store_true")
  97.     parser.add_argument("--no-create-config",
  98.                         help="Do not automatically create config file",
  99.                         action="store_true")
  100.     parser.add_argument("-i", "--interactive",
  101.                         help="Use interactive prompts to resolve issues during bootstrap",
  102.                         action="store_true")
  103.     parser.add_argument("--configurator",
  104.                         help="Run the interactive configurator",
  105.                         action="store_true")
  106.     parser.add_argument("-m", "--mirrors",
  107.                         help="Mirrors to download distfiles from",
  108.                         nargs='+')
  109.     parser.add_argument("-r", "--repo",
  110.                         help="Path to prebuilt binary packages", nargs=None)
  111.     parser.add_argument("--early-preseed",
  112.                         help="Skip early stages of live-bootstrap", nargs=None)
  113.     parser.add_argument("--internal-ci", help="INTERNAL for github CI")
  114.     parser.add_argument("-s", "--swap", help="Swap space to allocate in Linux",
  115.                         default=0)
  117.     # QEMU arguments
  118.     parser.add_argument("-q", "--qemu", help="Use QEMU",
  119.                         action="store_true")
  120.     parser.add_argument("-qc", "--qemu-cmd", help="QEMU command to run",
  121.                         default="qemu-system-x86_64")
  122.     parser.add_argument("-qr", "--qemu-ram", help="Memory (in megabytes) allocated to QEMU VM",
  123.                         default=4096)
  124.     parser.add_argument("-qs", "--target-size", help="Size of the target image (for QEMU only)",
  125.                         default="16G")
  126.     parser.add_argument("-qk", "--kernel", help="Custom early kernel to use")
  128.     parser.add_argument("-b", "--bare-metal", help="Build images for bare metal",
  129.                         action="store_true")
  131.     args = parser.parse_args()
  133.     # Mode validation
  134.     def check_types():
  135.         count = 0
  136.         if args.qemu:
  137.             count += 1
  138.         if args.chroot:
  139.             count += 1
  140.         if args.bwrap:
  141.             count += 1
  142.         if args.bare_metal:
  143.             count += 1
  144.         return count
  146.     if check_types() > 1:
  147.         raise ValueError("No more than one of qemu, chroot, bwrap, bare metal"
  148.                          "may be used.")
  149.     if check_types() == 0:
  150.         raise ValueError("One of qemu, chroot, bwrap, or bare metal must be selected.")
  152.     # Arch validation
  153.     if args.arch != "x86":
  154.         print("Only x86 is supported at the moment, other arches are for development only.")
  156.     # Tmpfs validation
  157.     if args.bwrap and args.tmpfs:
  158.         raise ValueError("tmpfs cannot be used with bwrap.")
  160.     # Cores validation
  161.     if int(args.cores) < 1:
  162.         raise ValueError("Must use one or more cores.")
  164.     # Target image size validation
  165.     if args.qemu:
  166.         if int(str(args.target_size).rstrip('gGmM')) < 1:
  167.             raise ValueError("Please specify a positive target size for qemu.")
  168.         args.target_size = (int(str(args.target_size).rstrip('gGmM')) *
  169.             (1024 if str(args.target_size).lower().endswith('g') else 1))
  170.     else:
  171.         args.target_size = 0
  173.     # Swap file size validation
  174.     if args.qemu or args.bare_metal:
  175.         args.swap = (int(str(args.swap).rstrip('gGmM')) *
  176.             (1024 if str(args.swap).lower().endswith('g') else 1))
  177.     else:
  178.         args.swap = 0
  180.     # Set constant umask
  181.     os.umask(0o022)
  183.     # file:// mirrors
  184.     mirror_servers = []
  185.     if args.mirrors:
  186.         for i, mirror in enumerate(args.mirrors):
  187.             if mirror.startswith("file://"):
  188.                 path = mirror.removeprefix("file://")
  189.                 if not path.startswith("/"):
  190.                     raise ValueError("A file:// mirror must be an absolute path.")
  192.                 server = SimpleMirror(path)
  193.                 args.mirrors[i] = f"http://127.0.0.1:{server.port}"
  194.                 mirror_servers.append(server)
  196.     # bootstrap.cfg
  197.     try:
  198.         os.remove(os.path.join('steps', 'bootstrap.cfg'))
  199.     except FileNotFoundError:
  200.         pass
  201.     if not args.no_create_config:
  202.         create_configuration_file(args)
  203.     else:
  204.         with open(os.path.join('steps', 'bootstrap.cfg'), 'a', encoding='UTF-8'):
  205.             pass
  207.     # target
  208.     target = Target(path=args.target)
  209.     if args.tmpfs:
  210.         target.tmpfs(size=args.tmpfs_size)
  212.     for server in mirror_servers:
  213.         thread = threading.Thread(target=server.serve_forever)
  214.         thread.start()
  216.     def cleanup(*_):
  217.         for server in mirror_servers:
  218.             server.shutdown()
  219.     signal.signal(signal.SIGINT, cleanup)
  221.     generator = Generator(arch=args.arch,
  222.                           external_sources=args.external_sources,
  223.                           repo_path=args.repo,
  224.                           early_preseed=args.early_preseed,
  225.                           mirrors=args.mirrors)
  227.     bootstrap(args, generator, target, args.target_size, cleanup)
  228.     cleanup()
  230. def bootstrap(args, generator, target, size, cleanup):
  231.     """Kick off bootstrap process."""
  232.     print(f"Bootstrapping {args.arch}", flush=True)
  233.     if args.chroot:
  234.         find_chroot = """
  235. import shutil
  236. print(shutil.which('chroot'))
  237. """
  238.         chroot_binary = run_as_root('python3', '-c', find_chroot,
  239.                                     capture_output=True).stdout.decode().strip()
  241.         generator.prepare(target, using_kernel=False)
  243.         arch = stage0_arch_map.get(args.arch, args.arch)
  244.         init = os.path.join(os.sep, 'bootstrap-seeds', 'POSIX', arch, 'kaem-optional-seed')
  245.         run_as_root('env', '-i', 'PATH=/bin', chroot_binary, generator.target_dir, init,
  246.                     cleanup=cleanup)
  248.     elif args.bwrap:
  249.         init = '/init'
  250.         if not args.internal_ci or args.internal_ci == "pass1":
  251.             generator.prepare(target, using_kernel=False)
  253.             arch = stage0_arch_map.get(args.arch, args.arch)
  254.             init = os.path.join(os.sep, 'bootstrap-seeds', 'POSIX', arch, 'kaem-optional-seed')
  255.         else:
  256.             generator.reuse(target)
  258.         run('env', '-i', 'bwrap', '--unshare-user',
  259.                                   '--uid', '0',
  260.                                   '--gid', '0',
  261.                                   '--unshare-net' if args.external_sources else None,
  262.                                   '--setenv', 'PATH', '/usr/bin',
  263.                                   '--bind', generator.target_dir, '/',
  264.                                   '--dir', '/dev',
  265.                                   '--dev-bind', '/dev/null', '/dev/null',
  266.                                   '--dev-bind', '/dev/zero', '/dev/zero',
  267.                                   '--dev-bind', '/dev/random', '/dev/random',
  268.                                   '--dev-bind', '/dev/urandom', '/dev/urandom',
  269.                                   '--dev-bind', '/dev/ptmx', '/dev/ptmx',
  270.                                   '--dev-bind', '/dev/tty', '/dev/tty',
  271.                                   '--tmpfs', '/dev/shm',
  272.                                   '--proc', '/proc',
  273.                                   '--bind', '/sys', '/sys',
  274.                                   '--tmpfs', '/tmp',
  275.                                   init,
  276.             cleanup=cleanup)
  278.     elif args.bare_metal:
  279.         if args.kernel:
  280.             generator.prepare(target, using_kernel=True, target_size=size)
  281.             path = os.path.join(args.target, os.path.relpath(generator.target_dir, args.target))
  282.             print("Please:")
  283.             print(f"  1. Take {path}/initramfs and your kernel, boot using this.")
  284.             print(f"  2. Take {path}/disk.img and put this on a writable storage medium.")
  285.         else:
  286.             generator.prepare(target, kernel_bootstrap=True, target_size=size)
  287.             path = os.path.join(args.target, os.path.relpath(generator.target_dir, args.target))
  288.             print("Please:")
  289.             print(f"  1. Take {path}.img and write it to a boot drive and then boot it.")
  291.     else:
  292.         if args.kernel:
  293.             generator.prepare(target, using_kernel=True, target_size=size)
  295.             arg_list = [
  296.                 '-enable-kvm',
  297.                 '-m', str(args.qemu_ram) + 'M',
  298.                 '-smp', str(args.cores),
  299.                 '-drive', 'file=' + target.get_disk("disk") + ',format=raw'
  300.             ]
  301.             if target.get_disk("external") is not None:
  302.                 arg_list += [
  303.                     '-drive', 'file=' + target.get_disk("external") + ',format=raw',
  304.                 ]
  305.             arg_list += [
  306.                 '-nic', 'user,ipv6=off,model=e1000',
  307.                 '-kernel', args.kernel,
  308.                 '-append',
  309.             ]
  310.             if args.interactive:
  311.                 arg_list += ['consoleblank=0 earlyprintk=vga root=/dev/sda1 '
  312.                              'rootfstype=ext3 init=/init rw']
  313.             else:
  314.                 arg_list += ['console=ttyS0 earlycon=uart8250,io,0x3f8,115200n8 '
  315.                              'root=/dev/sda1 rootfstype=ext3 init=/init rw']
  316.         else:
  317.             generator.prepare(target, kernel_bootstrap=True, target_size=size)
  318.             arg_list = [
  319.                 '-enable-kvm',
  320.                 '-m', str(args.qemu_ram) + 'M',
  321.                 '-smp', str(args.cores),
  322.                 '-drive', 'file=' + generator.target_dir + '.img' + ',format=raw'
  323.             ]
  324.             if target.get_disk("external") is not None:
  325.                 arg_list += [
  326.                     '-drive', 'file=' + target.get_disk("external") + ',format=raw',
  327.                 ]
  328.             arg_list += [
  329.                 '-machine', 'kernel-irqchip=split',
  330.                 '-nic', 'user,ipv6=off,model=e1000'
  331.             ]
  332.         if not args.interactive:
  333.             arg_list += ['-no-reboot', '-nographic']
  334.         run(args.qemu_cmd, *arg_list, cleanup=cleanup)
  336. if __name__ == "__main__":
  337.     main()