multiboot

Documentation

Overview

Package multiboot implements bootloading multiboot kernels as defined by https://www.gnu.org/software/grub/manual/multiboot/multiboot.html.

Package multiboot crafts kexec segments that can be used with the kexec_load system call.

Index

• Constants
• Variables
• func Load(debug bool, kernel io.ReaderAt, cmdline string, modules []Module, ...) error
• func PrepareLoad(debug bool, kernel io.ReaderAt, cmdline string, modules []Module, ...) (uintptr, kexec.Segments, error)
• func Probe(kernel io.ReaderAt) error
• type Description
• type MemoryMap
  • func (m MemoryMap) MarshalJSON() ([]byte, error)
  • func (m MemoryMap) String() string
  • func (m *MemoryMap) UnmarshalJSON(b []byte) error
• type Module
  • func (m Module) Name() string
• type ModuleDesc
• type Modules
  • func LazyOpenModules(cmds []string) Modules
  • func OpenModules(cmds []string) (Modules, error)
  • func (m Modules) Close() error

Constants

const (
	ESXBOOTINFO_INVALID_TYPE  esxBootInfoType = 0
	ESXBOOTINFO_MEMRANGE_TYPE esxBootInfoType = 1
	ESXBOOTINFO_MODULE_TYPE   esxBootInfoType = 2
	ESXBOOTINFO_VBE_TYPE      esxBootInfoType = 3
	ESXBOOTINFO_EFI_TYPE      esxBootInfoType = 4
	ESXBOOTINFO_LOADESX_TYPE  esxBootInfoType = 5
)

const (
	// 64-bit ARM EFI. (Why would we have to tell the next kernel that it's
	// an aarch64 EFI? Shouldn't it know?)
	ESXBOOTINFO_EFI_ARCH64 esxBootInfoEfiFlags = 1 << 0

	// EFI Secure Boot in progress.
	ESXBOOTINFO_EFI_SECURE_BOOT esxBootInfoEfiFlags = 1 << 1

	// UEFI memory map is valid rather than esxBootInfo memory map.
	ESXBOOTINFO_EFI_MMAP esxBootInfoEfiFlags = 1 << 2
)

const (
	// Kernel runs in EL1, not EL2.
	ESXBOOTINFO_ARCH_FLAG_ARM64_EL1 esxBootInfoHeaderFlag = 1 << 0
	// Must pass video info to OS.
	ESXBOOTINFO_FLAG_VIDEO esxBootInfoHeaderFlag = 1 << 2

	// rts_vaddr field is valid.
	ESXBOOTINFO_FLAG_EFI_RTS_OLD esxBootInfoHeaderFlag = 1 << 17
	// rts vaddr and size fields valid.
	ESXBOOTINFO_FLAG_EFI_RTS_NEW esxBootInfoHeaderFlag = 1 << 18
	// LoadESX version field valid.
	ESXBOOTINFO_FLAG_LOADESX_VERSION esxBootInfoHeaderFlag = 1 << 19
	// Video min fields valid.
	ESXBOOTINFO_FLAG_VIDEO_MIN esxBootInfoHeaderFlag = 1 << 20
)

const (
	ESXBOOTINFO_VIDEO_GRAPHIC = 0
	ESXBOOTINFO_VIDEO_TEXT    = 1
)

const DebugPrefix = "MULTIBOOT_DEBUG_INFO:"

DebugPrefix is a prefix that some messages are printed with for tests to parse.

Variables

var (
	// ErrHeaderNotFound indicates that a multiboot header magic was not
	// found in the given binary.
	ErrHeaderNotFound = errors.New("multiboot header not found")

	// ErrFlagsNotSupported indicates that a valid multiboot header
	// contained flags this package does not support (yet).
	ErrFlagsNotSupported = errors.New("multiboot header flags not supported	yet")
)

Functions

func Load

func Load(debug bool, kernel io.ReaderAt, cmdline string, modules []Module, ibft *ibft.IBFT) error

Load parses and loads a multiboot `kernel` using kexec_load.

debug turns on debug logging.

Load can set up an arbitrary number of modules, and takes care of the multiboot info structure, including the memory map.

After Load is called, kexec.Reboot() is ready to be called any time to stop Linux and execute the loaded kernel.

func PrepareLoad

func PrepareLoad(debug bool, kernel io.ReaderAt, cmdline string, modules []Module, ibft *ibft.IBFT) (uintptr, kexec.Segments, error)

PrepareLoad parses and loads a multiboot `kernel` ready for kexec_load. It returns an entry point value and segments.

Load can set up an arbitrary number of modules, and takes care of the multiboot info structure, including the memory map.

func Probe

func Probe(kernel io.ReaderAt) error

Probe checks if `kernel` is multiboot v1 or esxBootInfo kernel. If the `kernel` is gzip'ed, it will decompress it. Only Gzip decmpression is supported at present.

Types

type Description

type Description struct {
	Status string `json:"status"`

	Flags      uint32 `json:"flags"`
	MemLower   uint32 `json:"mem_lower"`
	MemUpper   uint32 `json:"mem_upper"`
	MmapAddr   uint32 `json:"mmap_addr"`
	MmapLength uint32 `json:"mmap_length"`

	Cmdline    string `json:"cmdline"`
	Bootloader string `json:"bootloader"`

	Mmap    []MemoryMap  `json:"mmap"`
	Modules []ModuleDesc `json:"modules"`
}

Description stores representation of multiboot information passed to a final kernel used for for debugging and testing.

type MemoryMap

type MemoryMap struct {
	// Size is the size of the associated structure in bytes.
	Size uint32
	// BaseAddr is the starting address.
	BaseAddr uint64
	// Length is the size of the memory region in bytes.
	Length uint64
	// Type is the variety of address range represented.
	Type uint32
}

MemoryMap represents a reserved range of memory passed via the multiboot Info header.

func (MemoryMap) MarshalJSON

func (m MemoryMap) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler

func (MemoryMap) String

func (m MemoryMap) String() string

String returns a readable representation of a MemoryMap entry.

func (*MemoryMap) UnmarshalJSON

func (m *MemoryMap) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler

type Module

type Module struct {
	Module  io.ReaderAt
	Cmdline string
}

Module describe a module by a ReaderAt and a `Cmdline`

func (Module) Name

func (m Module) Name() string

Name returns the first field of the cmdline, if there is one.

type ModuleDesc

type ModuleDesc struct {
	Start   uint32 `json:"start"`
	End     uint32 `json:"end"`
	Cmdline string `json:"cmdline"`
	SHA256  string `json:"sha256"`
}

ModuleDesc is a debug representation of loaded module.

type Modules

type Modules []Module

Modules is a range of module with a Closer interface

func LazyOpenModules

func LazyOpenModules(cmds []string) Modules

LazyOpenModules assigns modules to be opened as files.

Each module is a path followed by optional command-line arguments, e.g. []string{"./module arg1 arg2", "./module2 arg3 arg4"}.

func OpenModules

func OpenModules(cmds []string) (Modules, error)

OpenModules open modules as files and fill a range of `Module` struct

Each module is a path followed by optional command-line arguments, e.g. []string{"./module arg1 arg2", "./module2 arg3 arg4"}.

func (Modules) Close

func (m Modules) Close() error

Close closes all Modules ReaderAt implementing the io.Closer interface