Convert mbr,boot,root <--> disk.img

[damdo]

👋, I was wondering what's the best way to convert (in Go) from/to different disk parts (mbr,boot,root) from/to a disk.img and vice versa. I had a quick look at the packer logic but I couldn't clearly isolate the logic to do that.
Any suggestions? Thanks! :)

[stapelberg]

Can you describe what you need this for? Maybe that allows for an even better recommendation.

The partitioning logic is exposed as https://pkg.go.dev/github.com/gokrazy/tools/packer#Pack.Partition (for rtr7-recovery-init, which installs gokrazy via PXE boot). That should get you most of the way there, though perhaps we need another function to conveniently work with the offsets of each partition.

[damdo]

A bit more context:
I'm playing with the idea of distributing gokrazy builds, and so I'm pushing and pulling them around.

But since uploading several Gigabytes of a disk image is not easy (unless you have a 25 Gbit/s internet connection :P) (I know I could compress/decompress but that needs extra steps and is not computationally trivial, especially on edge devices), I'm building the gokrazy instances into mbr,boot,root rather than into a "full, single" file.

When I pull them down, there are certain use cases for which I'd like to rebuild the full image (e.g. for running in qemu) and so I'm trying to recompose those bits together.

Thank you for pointing me to Pack.Partition, I was able to put together this which does the job for my use case (code below, let me know if I'm doing gross mistakes here :)).
That said as you said, it would be nice to have something for working with this more conveniently, which maybe we could reuse for other purposes too (not sure if we could even use it to refactor the current gokr-packer code).

Here's what I'm rolling with:

package main

import (
	"flag"
	"io"
	"io/ioutil"
	"log"
	"os"

	"github.com/gokrazy/tools/packer"
)

var mbrSource, bootSource, rootSource, destPath string

const MB = 1024 * 1024

var targetStorageBytes = 2147483648

type pack struct {
	packer.Pack
}

func main() {
	flag.StringVar(&mbrSource, "mbr", "mbr.img", "path to the mbr img file")
	flag.StringVar(&bootSource, "boot", "boot.img", "path to the boot img file")
	flag.StringVar(&rootSource, "root", "root.img", "path to the root img file")
	flag.StringVar(&destPath, "out", "disk.img", "path to the output full disk img file")
	flag.Parse()

	// TODO: read hostname from source root img
	p := packer.NewPackForHost("gokrazy")

	// TODO: read these from the source imgs if possible
	p.UsePartuuid = true
	p.UseGPTPartuuid = true
	p.UseGPT = true

	f, err := os.Create(destPath)
	if err != nil {
		log.Fatalln(err)
	}

	if err := f.Truncate(int64(targetStorageBytes)); err != nil {
		log.Fatalln(err)
	}

	if err := p.Partition(f, uint64(targetStorageBytes)); err != nil {
		log.Fatalln(err)
	}

	if _, err := f.Seek(8192*512, io.SeekStart); err != nil {
		log.Fatalln(err)
	}

	bootFile, err := os.Open(bootSource)
	if err != nil {
		log.Fatalln(err)
	}

	if _, err := io.Copy(f, bootFile); err != nil {
		log.Fatalln(err)
	}

	if _, err := f.Seek(0, io.SeekStart); err != nil {
		log.Fatalln(err)
	}

	mbrFile, err := os.Open(mbrSource)
	if err != nil {
		log.Fatalln(err)
	}

	if _, err := io.Copy(f, mbrFile); err != nil {
		log.Fatalln(err)
	}

	if _, err := f.Seek(8192*512+100*MB, io.SeekStart); err != nil {
		log.Fatalln(err)
	}

	tmp, err := ioutil.TempFile("", "gokr-packer")
	if err != nil {
		log.Fatalln(err)
	}
	defer os.Remove(tmp.Name())
	defer tmp.Close()

	rootFile, err := os.Open(rootSource)
	if err != nil {
		log.Fatalln(err)
	}

	if _, err := io.Copy(f, rootFile); err != nil {
		log.Fatalln(err)
	}

	if _, err := tmp.Seek(0, io.SeekStart); err != nil {
		log.Fatalln(err)
	}

	if _, err := io.Copy(f, tmp); err != nil {
		log.Fatalln(err)
	}
}

Thanks!

[stapelberg]

When I pull them down, there are certain use cases for which I'd like to rebuild the full image (e.g. for running in qemu) and so I'm trying to recompose those bits together.

Gotcha.

Yeah, I think re-assembling a disk image from (mbr, boot, root) is something we can implement in the new gok tool, once the instance-centric re-design has landed :)

[arky]

@stapelberg Wonder if the disk image generation has landed in gok command yet?

[stapelberg]

No. Contributions welcome :)