72c3157162
Background: grub2 works in three stages: - The first stage is found in the first 440 bytes of the master boot record, and its only purpose is to load and execute the second stage. This stage is static, and just copied from the rpm without modification. - The second stage is found in the gap between the MBR and the first partition, and may be up to 31kB in size. This stage is specific to the host and must contain the instructions for finding the right file system and subdirectory for the grub2 config and modules on the host, as well as the modules needed to do this. - The third stage is found in the `normal` module, which loads grub2.conf, which in turn may load more modules and perform arbitrary instructions. Problem: grub2-install is responsible for installing all these stages on the target image. This goes against our design, as modifications outside the filesystem should happen in the assembler, but modifications to the filesystem should happen in a stage. In particular, we don't want the contents of the image to differ in any way from the output tree that is stored in our content store (the output of our last stage). This causes a practical problem at the moment, as our selinux stage is ran before the assembler, and as such the grub modules do not get selinux labels applied. It turns out that we could split grub2-install in two as we want, by passing `--no-bootsector` to it to install only the modules, and copy/genereta the two first stages as files under /boot and then run `grub2-bios-setup` to write the stages from /boot into the image where they belong. Regrettably, this does not work as both `grub2-install` and `grub2-bios-setup` introspect the system and block devices they are being run on to generate the right configuration. This is not what we want, as we would like to specifcy the config explicitly and run them independently of the target image. The specific bug we get in both cases is that the canonical path containing our object store cannot be found. Before osbuild this was not a problem, as other installers would instal and assemble everything directly in the target image as a loopback device. Something we explicitly do not want to do. Solution: This patch essentially reimplements grub2-install, or rather the parts of it that we need. One change in behavior from the upstream tool is that we no longer write the level one and level two boot loaders to /boot before moving them into place, but just write them directly where they belong (so they do not end up on the filesystem). The parts that copy files into /boot are now in the grub2 installer and the parts that write the level one/two bootloaders are in the qemu assembler. This achieves a few principles I think we should always adher to: - never run tools from the target image (no chroot) - don't read/copy files from the target image that was written by other stages. We already try to avoid sharing state, and by treating the image as write-only, we avoid accidentally sharing state through the target tree. Based-on-suggestions-from: Javier Martinez Canillas <javierm@redhat.com> With-god-like-debugging-and-fixes-by: Lars Karlitski <lubreni@redhat.com> Signed-off-by: Tom Gundersen <teg@jklm.no>
118 lines
4.6 KiB
Python
Executable file
118 lines
4.6 KiB
Python
Executable file
#!/usr/bin/python3
|
|
|
|
import contextlib
|
|
import json
|
|
import os
|
|
import socket
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import osbuild.remoteloop as remoteloop
|
|
|
|
@contextlib.contextmanager
|
|
def mount(source, dest, *options):
|
|
os.makedirs(dest, 0o755, True)
|
|
subprocess.run(["mount", *options, source, dest], check=True)
|
|
try:
|
|
yield
|
|
finally:
|
|
subprocess.run(["umount", "-R", dest], check=True)
|
|
|
|
@contextlib.contextmanager
|
|
def loop_device(loop_client, image, size, offset=0):
|
|
fd = os.open(image, os.O_RDWR | os.O_DIRECT)
|
|
devname = loop_client.create_device(fd, offset=offset, sizelimit=size)
|
|
os.close(fd)
|
|
path = f"/dev/{devname}"
|
|
try:
|
|
yield path
|
|
finally:
|
|
os.unlink(path)
|
|
|
|
def main(tree, output_dir, options, loop_client):
|
|
fmt = options["format"]
|
|
filename = options["filename"]
|
|
ptuuid = options["ptuuid"]
|
|
root_fs_uuid = options["root_fs_uuid"]
|
|
size = options["size"]
|
|
|
|
# sfdisk works on sectors of 512 bytes and ignores excess space - be explicit about this
|
|
if size % 512 != 0:
|
|
raise ValueError("`size` must be a multiple of sector size (512)")
|
|
|
|
if fmt not in ["raw", "qcow2", "vdi", "vmdk"]:
|
|
raise ValueError("`format` must be one of raw, qcow, vdi, vmdk")
|
|
|
|
image = f"/var/tmp/osbuild-image.raw"
|
|
grub2_core = "/var/tmp/grub2-core.img"
|
|
grub2_load = "/var/tmp/grub2-load.cfg"
|
|
mountpoint = f"/tmp/osbuild-mnt"
|
|
|
|
# Create an empty image file
|
|
subprocess.run(["truncate", "--size", str(size), image], check=True)
|
|
|
|
# Set up the partition table of the image
|
|
partition_table = f"label: mbr\nlabel-id: {ptuuid}\nbootable, type=83"
|
|
subprocess.run(["sfdisk", "-q", image], input=partition_table, encoding='utf-8', check=True)
|
|
|
|
r = subprocess.run(["sfdisk", "--json", image], stdout=subprocess.PIPE, encoding='utf-8', check=True)
|
|
partition_table = json.loads(r.stdout)
|
|
partition = partition_table["partitiontable"]["partitions"][0]
|
|
partition_offset = partition["start"] * 512
|
|
partition_size = partition["size"] * 512
|
|
|
|
with open(grub2_load, "w") as load:
|
|
load.write(f"search.fs_uuid {root_fs_uuid} root \n"
|
|
"set prefix=($root)'/boot/grub2'\n")
|
|
|
|
# Create the level-2 bootloader
|
|
# The purpose of this is to find the grub modules and configuration
|
|
# to be able to start the level-3 bootloader. It contains the modules
|
|
# necessary to do this, but nothing else.
|
|
subprocess.run(["grub2-mkimage",
|
|
"--verbose",
|
|
"--directory", "/usr/lib/grub/i386-pc",
|
|
"--prefix", "/boot/grub2",
|
|
"--format", "i386-pc",
|
|
"--compression", "auto",
|
|
"--config", grub2_load,
|
|
"--output", grub2_core,
|
|
"part_msdos", "ext2", "biosdisk", "search_fs_uuid"],
|
|
check=True)
|
|
|
|
assert os.path.getsize(grub2_core) < partition_offset - 512
|
|
|
|
with open(image, "rb+") as image_f:
|
|
# Install the level-1 bootloader into the start of the MBR
|
|
# The purpose of this is simply to jump into the level-2 bootloader.
|
|
with open("/usr/lib/grub/i386-pc/boot.img", "rb") as boot_f:
|
|
# The boot.img file is 512 bytes, but we must only copy the first 440
|
|
# bytes, as these contain the bootstrapping code. The rest of the
|
|
# first sector contains the partition table, and must not be
|
|
# overwritten.
|
|
image_f.write(boot_f.read(440))
|
|
|
|
# Install the level-2 bootloader into the space after the MBR, before
|
|
# the first partition.
|
|
with open(grub2_core, "rb") as core_f:
|
|
image_f.seek(512)
|
|
shutil.copyfileobj(core_f, image_f)
|
|
|
|
# Populate the first partition of the image with an ext4 fs
|
|
subprocess.run(["mkfs.ext4", "-U", root_fs_uuid, "-E", f"offset={partition_offset}", image,
|
|
f"{int(partition_size / 1024)}k"], input="y", encoding='utf-8', check=True)
|
|
|
|
# Copy the tree into the target image
|
|
with loop_device(loop_client, image, partition_size, partition_offset) as loop, \
|
|
mount(loop, mountpoint):
|
|
subprocess.run(["cp", "-a", f"{tree}/.", mountpoint], check=True)
|
|
|
|
subprocess.run(["qemu-img", "convert", "-O", fmt, "-c", image, f"{output_dir}/{filename}"], check=True)
|
|
|
|
if __name__ == '__main__':
|
|
args = json.load(sys.stdin)
|
|
sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
|
|
sock.setsockopt(socket.SOL_SOCKET, socket.SO_PASSCRED, 1)
|
|
sock.connect("/run/osbuild/api/remoteloop")
|
|
ret = main(args["tree"], args["output_dir"], args["options"], remoteloop.LoopClient(sock))
|
|
sys.exit(ret)
|