kexec

package
v3.0.0-...-66753ca Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 20, 2023 License: BSD-3-Clause Imports: 19 Imported by: 0

Documentation

Overview

Package kexec implements kexec load and file load syscall API.

Index

Constants

View Source 
const (
	PayloadTypeRAM      = 1
	PayloadTypeDefault  = 2
	PayloadTypeACPI     = 3
	PayloadTypeNVS      = 4
	PayloadTypeReserved = 5
)

Payload memory type (PayloadMemType) in UefiPayload

View Source 
const M1 = 1 << 20

M1 is 1 Megabyte in bits.

View Source 
const MaxAddr = ^uintptr(0)

MaxAddr is the highest address in a 64bit address space.

Variables

This section is empty.

Functions

func FileLoad 

func FileLoad(kernel, ramfs *os.File, cmdline string) error

FileLoad loads the given kernel as the new kernel with the given ramfs and cmdline.

The kexec_file_load(2) syscall is x86-64 and arm64 only.

func Load 

func Load(entry uintptr, segments Segments, flags uint64) error

Load loads the given segments into memory to be executed on a kexec-reboot.

It is assumed that segments is made up of the next kernel's code and text segments, and that `entry` is the entry point, either kernel entry point or trampoline.

Load will align segments to page boundaries and deduplicate overlapping ranges.

func Reboot 

func Reboot() error

Reboot executes a kernel previously loaded with FileInit.

Types

type ErrKexec 

type ErrKexec struct {
	Entry    uintptr
	Segments []Segment
	Flags    uint64
	Errno    syscall.Errno
}

ErrKexec is returned by Load if the kexec failed. It describes entry point, flags, errno and kernel layout.

func (ErrKexec) Error 

func (e ErrKexec) Error() string

Error implements error.

type ErrNotEnoughSpace 

type ErrNotEnoughSpace struct {
	Size uint
}

ErrNotEnoughSpace is returned by the FindSpace family of functions if no range is large enough to accommodate the request.

func (ErrNotEnoughSpace) Error 

func (e ErrNotEnoughSpace) Error() string

type Memory 

type Memory struct {
	// Phys defines the layout of physical memory.
	//
	// Phys is used to tell loaded operating systems what memory is usable
	// as RAM, and what memory is reserved (for ACPI or other reasons).
	Phys MemoryMap

	// Segments are the segments used to load a new operating system.
	//
	// Each segment also contains a physical memory region it maps to.
	Segments Segments
}

Memory provides routines to work with physical memory ranges.

func (*Memory) AddKexecSegment 

func (m *Memory) AddKexecSegment(d []byte) (Range, error)

AddKexecSegment adds d to a new kexec segment

func (*Memory) AddKexecSegmentExplicit 

func (m *Memory) AddKexecSegmentExplicit(d []byte, sz, offset, alignSizeBytes uint) (Range, error)

AddKexecSegmentExplicit adds d to a new kexec segment, but allows asking for extra space, secifying alignment size, and setting text_offset.

func (*Memory) AddPhysSegment 

func (m *Memory) AddPhysSegment(d []byte, limit Range) (Range, error)

AddPhysSegment reserves len(d) bytes in the physical memmap within limit and adds a kexec segment with d in that range.

func (Memory) AvailableRAM 

func (m Memory) AvailableRAM() Ranges

AvailableRAM returns page-aligned unused regions of RAM.

AvailableRAM takes all RAM-marked pages in the memory map and subtracts the kexec segments already allocated. RAM segments begin at a page boundary.

E.g if page size is 4K and RAM segments are 

[{start:0 size:8192} {start:8192 size:8000}]

and kexec segments are 

[{start:40 size:50} {start:8000 size:2000}]

result should be 

[{start:0 size:40} {start:4096 end:8000 - 4096}]

func (Memory) FindSpace 

func (m Memory) FindSpace(sz, alignSizeBytes uint) (Range, error)

FindSpace returns pointer to the physical memory, where array of size sz can be stored during next AddKexecSegment call.

Align up to at least a page size if alignSizeBytes is smaller.

func (*Memory) LoadElfSegments 

func (m *Memory) LoadElfSegments(r io.ReaderAt) (Object, error)

LoadElfSegments loads loadable ELF segments.

func (*Memory) ParseMemoryMap 

func (m *Memory) ParseMemoryMap() error

ParseMemoryMap reads firmware provided memory map from /sys/firmware/memmap.

func (*Memory) ParseMemoryMapFromFDT 

func (m *Memory) ParseMemoryMapFromFDT(fdt *dt.FDT) error

ParseMemoryMapFromFDT reads firmware provided memory map from an FDT.

func (*Memory) ReservePhys 

func (m *Memory) ReservePhys(sz uint, limit Range) (Range, error)

ReservePhys reserves page-aligned sz bytes in the physical memmap within the given limit address range.

type MemoryMap 

type MemoryMap []TypedRange

MemoryMap defines the layout of physical memory.

MemoryMap defines which ranges in memory are usable RAM and which are reserved for various reasons.

func ParseMemoryMap 

func ParseMemoryMap() (MemoryMap, error)

ParseMemoryMap reads firmware provided memory map from /sys/firmware/memmap.

func (*MemoryMap) AsPayloadParam 

func (m *MemoryMap) AsPayloadParam() PayloadMemoryMapParam

AsPayloadParam converts MemoryMap to a PayloadMemoryMapParam

func (MemoryMap) FilterByType 

func (m MemoryMap) FilterByType(typ RangeType) Ranges

FilterByType only returns ranges of the given typ.

func (*MemoryMap) Insert 

func (m *MemoryMap) Insert(r TypedRange)

Insert a new TypedRange into the memory map, removing chunks of other ranges as necessary.

Assumes that TypedRange is a valid range -- no checking.

type Object 

type Object interface {
	Progs() []*elf.Prog
	Entry() uint64
}

Object is an object file, specific to kexec uses. It is used to get Progs and Entry from an object. elf.Prog is generic enough that we can use it to define loadable segments for non-ELF objects, such as Plan 9 a.out

func ObjectNewFile 

func ObjectNewFile(r io.ReaderAt) (Object, error)

ObjectNewFile reads from input stream and returns a specific object. It tries elf first, then plan9.

type PayloadMemType 

type PayloadMemType uint32

PayloadMemType defines type of a memory map entry

type PayloadMemoryMapParam 

type PayloadMemoryMapParam []payloadMemoryMapEntry

PayloadMemoryMapParam is payload's MemoryMap parameter

type Range 

type Range struct {
	// Start is the inclusive start of the range.
	Start uintptr

	// Size is the number of elements in the range.
	//
	// Start+Size is the exclusive end of the range.
	Size uint
}

Range represents a contiguous uintptr interval [Start, Start+Size).

func RangeFromInterval 

func RangeFromInterval(start, end uintptr) Range

RangeFromInterval returns a Range representing [start, end).

func (Range) Adjacent 

func (r Range) Adjacent(r2 Range) bool

Adjacent returns true if r and r2 do not overlap, but are immediately next to each other.

func (Range) Contains 

func (r Range) Contains(p uintptr) bool

Contains returns true iff p is in the interval described by r.

func (Range) Disjunct 

func (r Range) Disjunct(r2 Range) bool

Disjunct returns true if r and r2 do not overlap.

func (Range) End 

func (r Range) End() uintptr

End returns the uintptr *after* the end of the interval.

func (Range) Intersect 

func (r Range) Intersect(r2 Range) *Range

Intersect returns the continuous range of points common to r and r2 if there is one.

func (Range) IsSupersetOf 

func (r Range) IsSupersetOf(r2 Range) bool

IsSupersetOf returns true if r2 in r.

func (Range) Minus 

func (r Range) Minus(r2 Range) []Range

Minus removes all points in r2 from r.

func (Range) Overlaps 

func (r Range) Overlaps(r2 Range) bool

Overlaps returns true if r and r2 overlap.

func (Range) String 

func (r Range) String() string

String returns [Start, Start+Size) as a string.

type RangeType 

type RangeType string

RangeType defines type of a TypedRange based on the Linux kernel string provided by firmware memory map. 

const (
	RangeRAM      RangeType = "System RAM"
	RangeDefault  RangeType = "Default"
	RangeACPI     RangeType = "ACPI Tables"
	RangeNVS      RangeType = "ACPI Non-volatile Storage"
	RangeReserved RangeType = "Reserved"
)

These are the range types we know Linux uses.

func (RangeType) String 

func (r RangeType) String() string

String implements fmt.Stringer.

type Ranges 

type Ranges []Range

Ranges is a list of non-overlapping ranges.

func (Ranges) FindSpace 

func (rs Ranges) FindSpace(sz uint) (space Range, err error)

FindSpace finds a continguous piece of sz points within Ranges and returns the Range pointing to it.

If alignSizeBytes is zero, align up by page size.

func (Ranges) FindSpaceAbove 

func (rs Ranges) FindSpaceAbove(sz uint, minAddr uintptr) (space Range, err error)

FindSpaceAbove finds a continguous piece of sz points within Ranges and returns a space.Start >= minAddr.

func (Ranges) FindSpaceIn 

func (rs Ranges) FindSpaceIn(sz uint, limit Range) (space Range, err error)

FindSpaceIn finds a continguous piece of sz points within Ranges and returns a Range where space.Start >= limit.Start, with space.End() < limit.End().

func (Ranges) Minus 

func (rs Ranges) Minus(r Range) Ranges

Minus removes all points in r from all ranges in rs.

func (Ranges) Sort 

func (rs Ranges) Sort()

Sort sorts ranges by their start point.

type Segment 

type Segment struct {
	// Buf is a buffer in user space.
	Buf Range

	// Phys is a physical address of kernel.
	Phys Range
}

Segment defines kernel memory layout.

func AlignPhysStart 

func AlignPhysStart(s Segment) Segment

AlignPhysStart aligns s.Phys.Start to the page size. AlignPhysStart does not align the size of the segment.

func NewSegment 

func NewSegment(buf []byte, phys Range) Segment

NewSegment creates new Segment. Segments should be created using NewSegment method to prevent data pointed by Segment.Buf to be collected by garbage collector.

func (Segment) String 

func (s Segment) String() string

type Segments 

type Segments []Segment

Segments is a collection of segments.

func AlignAndMerge 

func AlignAndMerge(segs Segments) (Segments, error)

AlignAndMerge adjusts segs to the preconditions of kexec_load.

Pre-conditions: segs physical ranges are disjoint. Post-conditions: segs physical start addresses & size aligned to page size.

func (Segments) GetPhys 

func (segs Segments) GetPhys(r Range) []byte

GetPhys gets the buffer corresponding to the physical address range r.

func (*Segments) Insert 

func (segs *Segments) Insert(s Segment)

Insert inserts s assuming it does not overlap with an existing segment.

func (Segments) IsSupersetOf 

func (segs Segments) IsSupersetOf(o Segments) error

IsSupersetOf checks whether all segments in o are present in s and contain the same buffer content.

func (Segments) Phys 

func (segs Segments) Phys() Ranges

Phys returns all physical address ranges.

func (Segments) PhysContains 

func (segs Segments) PhysContains(p uintptr) bool

PhysContains returns whether p exists in any of segs' physical memory ranges.

type TypedRange 

type TypedRange struct {
	Range
	Type RangeType
}

TypedRange represents range of physical memory.

func (TypedRange) String 

func (tr TypedRange) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.