kexec

package
v6.0.0+incompatible Latest Latest
Warning

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

 Go to latest Published: Aug 14, 2019 License: BSD-3-Clause Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	RangeRAM      RangeType = "System RAM"
	RangeDefault            = "Default"
	RangeACPI               = "ACPI Tables"
	RangeNVS                = "ACPI Non-volatile Storage"
	RangeReserved           = "Reserved"
)
View Source 
const M1 = 1 << 20

M1 is 1 Megabyte in bits.

View Source 
const MaxAddr = ^uintptr(0)

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 bit 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) 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 uint) (Range, error)

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

func (*Memory) LoadElfSegments 

func (m *Memory) LoadElfSegments(r io.ReaderAt) 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) 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) FilterByType 

func (m MemoryMap) FilterByType(typ RangeType) Ranges

Filter 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 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.

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.

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 AlignPhys 

func AlignPhys(s Segment) Segment

AlignPhys fixes s to the kexec_load preconditions.

s's physical addresses must be multiples of the page size.

E.g. if page size is 0x1000: 

Segment {
  Buf:  {Start: 0x1011, Size: 0x1022}
  Phys: {Start: 0x2011, Size: 0x1022}
}

has to become 

Segment {
  Buf:  {Start: 0x1000, Size: 0x1033}
  Phys: {Start: 0x2000, Size: 0x2000}
}

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 Dedup 

func Dedup(segs Segments) Segments

Dedup deduplicates overlapping and merges adjacent segments in segs.

func (*Segments) Insert 

func (segs *Segments) Insert(s Segment)

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

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.