syzkaller: github.com/google/syzkaller/prog Index | Files | Directories

package prog

import "github.com/google/syzkaller/prog"

Index

Package Files

alloc.go analysis.go any.go checksum.go clone.go decodeexec.go encoding.go encodingexec.go generation.go hints.go minimization.go mutation.go parse.go prio.go prog.go rand.go resources.go size.go target.go types.go validation.go

Constants

const (
    ExecArgCsumChunkData = uint64(iota)
    ExecArgCsumChunkConst
)
const (
    ExecBufferSize = 2 << 20
    ExecNoCopyout  = ^uint64(0)
)
const (
    // Special reference to the outer struct used in len targets.
    ParentRef = "parent"
    // Special reference directly to syscall arguments used in len targets.
    SyscallRef = "syscall"
)
const (
    ExecArgCsumInet = uint64(iota)
)
const (
    MaxPids = 32
)

func CallSet Uses

func CallSet(data []byte) (map[string]struct{}, error)

CallSet returns a set of all calls in the program. It does very conservative parsing and is intended to parse paste/future serialization formats.

func Debug Uses

func Debug()

func DecodeFallbackSignal Uses

func DecodeFallbackSignal(s uint32) (callID, errno int)

func EncodeData Uses

func EncodeData(buf *bytes.Buffer, data []byte, readable bool)

func ForeachArg Uses

func ForeachArg(c *Call, f func(Arg, *ArgCtx))

func ForeachSubArg Uses

func ForeachSubArg(arg Arg, f func(Arg, *ArgCtx))

func ForeachType Uses

func ForeachType(meta *Syscall, f func(Type))

func IsPad Uses

func IsPad(t Type) bool

func RegisterTarget Uses

func RegisterTarget(target *Target, initArch func(target *Target))

func RequiredFeatures Uses

func RequiredFeatures(p *Prog) (bitmasks, csums bool)

type Arg Uses

type Arg interface {
    Type() Type
    Size() uint64
    // contains filtered or unexported methods
}

func InnerArg Uses

func InnerArg(arg Arg) Arg

Returns inner arg for pointer args.

type ArgCommon Uses

type ArgCommon struct {
    // contains filtered or unexported fields
}

func (*ArgCommon) Type Uses

func (arg *ArgCommon) Type() Type

type ArgCtx Uses

type ArgCtx struct {
    Parent *[]Arg      // GroupArg.Inner (for structs) or Call.Args containing this arg
    Base   *PointerArg // pointer to the base of the heap object containing this arg
    Offset uint64      // offset of this arg from the base
    Stop   bool        // if set by the callback, subargs of this arg are not visited
}

type ArrayKind Uses

type ArrayKind int
const (
    ArrayRandLen ArrayKind = iota
    ArrayRangeLen
)

type ArrayType Uses

type ArrayType struct {
    TypeCommon
    Type       Type
    Kind       ArrayKind
    RangeBegin uint64
    RangeEnd   uint64
}

func (*ArrayType) DefaultArg Uses

func (t *ArrayType) DefaultArg() Arg

func (*ArrayType) String Uses

func (t *ArrayType) String() string

type BinaryFormat Uses

type BinaryFormat int
const (
    FormatNative BinaryFormat = iota
    FormatBigEndian
    FormatStrDec
    FormatStrHex
    FormatStrOct
)

type BufferKind Uses

type BufferKind int
const (
    BufferBlobRand BufferKind = iota
    BufferBlobRange
    BufferString
    BufferFilename
    BufferText
)

type BufferType Uses

type BufferType struct {
    TypeCommon
    Kind       BufferKind
    RangeBegin uint64   // for BufferBlobRange kind
    RangeEnd   uint64   // for BufferBlobRange kind
    Text       TextKind // for BufferText
    SubKind    string
    Values     []string // possible values for BufferString kind
    NoZ        bool     // non-zero terminated BufferString/BufferFilename
}

func (*BufferType) DefaultArg Uses

func (t *BufferType) DefaultArg() Arg

func (*BufferType) String Uses

func (t *BufferType) String() string

type Builder Uses

type Builder struct {
    // contains filtered or unexported fields
}

func MakeProgGen Uses

func MakeProgGen(target *Target) *Builder

func (*Builder) Allocate Uses

func (pg *Builder) Allocate(size uint64) uint64

func (*Builder) AllocateVMA Uses

func (pg *Builder) AllocateVMA(npages uint64) uint64

func (*Builder) Append Uses

func (pg *Builder) Append(c *Call) error

func (*Builder) Finalize Uses

func (pg *Builder) Finalize() (*Prog, error)

type Call Uses

type Call struct {
    Meta    *Syscall
    Args    []Arg
    Ret     *ResultArg
    Comment string
}

type CallFlags Uses

type CallFlags int
const (
    CallExecuted CallFlags = 1 << iota // was started at all
    CallFinished                       // finished executing (rather than blocked forever)
    CallBlocked                        // finished but blocked during execution
)

type CallInfo Uses

type CallInfo struct {
    Flags  CallFlags
    Errno  int
    Signal []uint32
}

type ChoiceTable Uses

type ChoiceTable struct {
    // contains filtered or unexported fields
}

ChooseTable allows to do a weighted choice of a syscall for a given syscall based on call-to-call priorities and a set of enabled syscalls.

func (*ChoiceTable) Choose Uses

func (ct *ChoiceTable) Choose(r *rand.Rand, call int) int

type CompMap Uses

type CompMap map[uint64]map[uint64]bool

Example: for comparisons {(op1, op2), (op1, op3), (op1, op4), (op2, op1)} this map will store the following: m = {

op1: {map[op2]: true, map[op3]: true, map[op4]: true},
op2: {map[op1]: true}

}.

func (CompMap) AddComp Uses

func (m CompMap) AddComp(arg1, arg2 uint64)

func (CompMap) String Uses

func (m CompMap) String() string

type ConstArg Uses

type ConstArg struct {
    ArgCommon
    Val uint64
}

Used for ConstType, IntType, FlagsType, LenType, ProcType and CsumType.

func MakeConstArg Uses

func MakeConstArg(t Type, v uint64) *ConstArg

func (*ConstArg) Size Uses

func (arg *ConstArg) Size() uint64

func (*ConstArg) Value Uses

func (arg *ConstArg) Value() (uint64, uint64)

Value returns value, pid stride and endianness.

type ConstType Uses

type ConstType struct {
    IntTypeCommon
    Val   uint64
    IsPad bool
}

func (*ConstType) DefaultArg Uses

func (t *ConstType) DefaultArg() Arg

func (*ConstType) String Uses

func (t *ConstType) String() string

type ConstValue Uses

type ConstValue struct {
    Name  string
    Value uint64
}

type CsumChunk Uses

type CsumChunk struct {
    Kind  CsumChunkKind
    Arg   Arg    // for CsumChunkArg
    Value uint64 // for CsumChunkConst
    Size  uint64 // for CsumChunkConst
}

type CsumChunkKind Uses

type CsumChunkKind int
const (
    CsumChunkArg CsumChunkKind = iota
    CsumChunkConst
)

type CsumInfo Uses

type CsumInfo struct {
    Kind   CsumKind
    Chunks []CsumChunk
}

type CsumKind Uses

type CsumKind int
const (
    CsumInet CsumKind = iota
    CsumPseudo
)

type CsumType Uses

type CsumType struct {
    IntTypeCommon
    Kind     CsumKind
    Buf      string
    Protocol uint64 // for CsumPseudo
}

func (*CsumType) DefaultArg Uses

func (t *CsumType) DefaultArg() Arg

func (*CsumType) String Uses

func (t *CsumType) String() string

type DataArg Uses

type DataArg struct {
    ArgCommon
    // contains filtered or unexported fields
}

Used for BufferType.

func MakeDataArg Uses

func MakeDataArg(t Type, data []byte) *DataArg

func MakeOutDataArg Uses

func MakeOutDataArg(t Type, size uint64) *DataArg

func (*DataArg) Data Uses

func (arg *DataArg) Data() []byte

func (*DataArg) SetData Uses

func (arg *DataArg) SetData(data []byte)

func (*DataArg) Size Uses

func (arg *DataArg) Size() uint64

type DeserializeMode Uses

type DeserializeMode int
const (
    Strict    DeserializeMode = iota
    NonStrict DeserializeMode = iota
)

type Dir Uses

type Dir int
const (
    DirIn Dir = iota
    DirOut
    DirInOut
)

func (Dir) String Uses

func (dir Dir) String() string

type ExecArg Uses

type ExecArg interface{} // one of ExecArg*

type ExecArgConst Uses

type ExecArgConst struct {
    Size           uint64
    Format         BinaryFormat
    Value          uint64
    BitfieldOffset uint64
    BitfieldLength uint64
    PidStride      uint64
}

type ExecArgCsum Uses

type ExecArgCsum struct {
    Size   uint64
    Kind   uint64
    Chunks []ExecCsumChunk
}

type ExecArgData Uses

type ExecArgData struct {
    Data     []byte
    Readable bool
}

type ExecArgResult Uses

type ExecArgResult struct {
    Size    uint64
    Format  BinaryFormat
    Index   uint64
    DivOp   uint64
    AddOp   uint64
    Default uint64
}

type ExecCall Uses

type ExecCall struct {
    Meta    *Syscall
    Index   uint64
    Args    []ExecArg
    Copyin  []ExecCopyin
    Copyout []ExecCopyout
}

type ExecCopyin Uses

type ExecCopyin struct {
    Addr uint64
    Arg  ExecArg
}

type ExecCopyout Uses

type ExecCopyout struct {
    Index uint64
    Addr  uint64
    Size  uint64
}

type ExecCsumChunk Uses

type ExecCsumChunk struct {
    Kind  uint64
    Value uint64
    Size  uint64
}

type ExecProg Uses

type ExecProg struct {
    Calls []ExecCall
    Vars  []uint64
}

type FlagsType Uses

type FlagsType struct {
    IntTypeCommon
    Vals    []uint64
    BitMask bool
}

func (*FlagsType) DefaultArg Uses

func (t *FlagsType) DefaultArg() Arg

type Gen Uses

type Gen struct {
    // contains filtered or unexported fields
}

func (*Gen) Alloc Uses

func (g *Gen) Alloc(ptrType Type, data Arg) (Arg, []*Call)

func (*Gen) GenerateArg Uses

func (g *Gen) GenerateArg(typ Type, pcalls *[]*Call) Arg

func (*Gen) GenerateSpecialArg Uses

func (g *Gen) GenerateSpecialArg(typ Type, pcalls *[]*Call) Arg

func (*Gen) MutateArg Uses

func (g *Gen) MutateArg(arg0 Arg) (calls []*Call)

func (*Gen) NOutOf Uses

func (g *Gen) NOutOf(n, outOf int) bool

func (*Gen) Rand Uses

func (g *Gen) Rand() *rand.Rand

func (*Gen) Target Uses

func (g *Gen) Target() *Target

type GroupArg Uses

type GroupArg struct {
    ArgCommon
    Inner []Arg
}

Used for StructType and ArrayType. Logical group of args (struct or array).

func MakeGroupArg Uses

func MakeGroupArg(t Type, inner []Arg) *GroupArg

func (*GroupArg) Size Uses

func (arg *GroupArg) Size() uint64

type IntKind Uses

type IntKind int
const (
    IntPlain IntKind = iota
    IntRange
)

type IntType Uses

type IntType struct {
    IntTypeCommon
    Kind       IntKind
    RangeBegin uint64
    RangeEnd   uint64
    Align      uint64
}

func (*IntType) DefaultArg Uses

func (t *IntType) DefaultArg() Arg

type IntTypeCommon Uses

type IntTypeCommon struct {
    TypeCommon
    ArgFormat   BinaryFormat
    BitfieldOff uint64
    BitfieldLen uint64
    BitfieldMdl bool
}

func (*IntTypeCommon) BitfieldLength Uses

func (t *IntTypeCommon) BitfieldLength() uint64

func (*IntTypeCommon) BitfieldMiddle Uses

func (t *IntTypeCommon) BitfieldMiddle() bool

func (*IntTypeCommon) BitfieldOffset Uses

func (t *IntTypeCommon) BitfieldOffset() uint64

func (*IntTypeCommon) Format Uses

func (t *IntTypeCommon) Format() BinaryFormat

func (*IntTypeCommon) String Uses

func (t *IntTypeCommon) String() string

func (*IntTypeCommon) TypeBitSize Uses

func (t *IntTypeCommon) TypeBitSize() uint64

Returns the size in bits for integers in binary format or 64 for string-formatted integers. The return value is used in computing limits and truncating other values.

type KeyedStruct Uses

type KeyedStruct struct {
    Key  StructKey
    Desc *StructDesc
}

type LenType Uses

type LenType struct {
    IntTypeCommon
    BitSize uint64 // want size in multiple of bits instead of array size
    Offset  bool   // offset from the beginning of the parent struct or base object
    Path    []string
}

func (*LenType) DefaultArg Uses

func (t *LenType) DefaultArg() Arg

type LogEntry Uses

type LogEntry struct {
    P         *Prog
    Proc      int  // index of parallel proc
    Start     int  // start offset in log
    End       int  // end offset in log
    Fault     bool // program was executed with fault injection in FaultCall/FaultNth
    FaultCall int
    FaultNth  int
}

LogEntry describes one program in execution log.

type PointerArg Uses

type PointerArg struct {
    ArgCommon
    Address uint64
    VmaSize uint64 // size of the referenced region for vma args
    Res     Arg    // pointee (nil for vma)
}

Used for PtrType and VmaType.

func MakePointerArg Uses

func MakePointerArg(t Type, addr uint64, data Arg) *PointerArg

func MakeSpecialPointerArg Uses

func MakeSpecialPointerArg(t Type, index uint64) *PointerArg

func MakeVmaPointerArg Uses

func MakeVmaPointerArg(t Type, addr, size uint64) *PointerArg

func (*PointerArg) IsSpecial Uses

func (arg *PointerArg) IsSpecial() bool

func (*PointerArg) Size Uses

func (arg *PointerArg) Size() uint64

type ProcType Uses

type ProcType struct {
    IntTypeCommon
    ValuesStart   uint64
    ValuesPerProc uint64
}

func (*ProcType) DefaultArg Uses

func (t *ProcType) DefaultArg() Arg

type Prog Uses

type Prog struct {
    Target   *Target
    Calls    []*Call
    Comments []string
}

func Minimize Uses

func Minimize(p0 *Prog, callIndex0 int, crash bool, pred0 func(*Prog, int) bool) (*Prog, int)

Minimize minimizes program p into an equivalent program using the equivalence predicate pred. It iteratively generates simpler programs and asks pred whether it is equal to the original program or not. If it is equivalent then the simplification attempt is committed and the process continues.

func (*Prog) Clone Uses

func (p *Prog) Clone() *Prog

func (*Prog) FallbackSignal Uses

func (p *Prog) FallbackSignal(info []CallInfo)

func (*Prog) Mutate Uses

func (p *Prog) Mutate(rs rand.Source, ncalls int, ct *ChoiceTable, corpus []*Prog)

Mutate program p.

p: The program to mutate. rs: Random source. ncalls: The allowed maximum calls in mutated program. ct: ChoiceTable for syscalls. corpus: The entire corpus, including original program p.

func (*Prog) MutateWithHints Uses

func (p *Prog) MutateWithHints(callIndex int, comps CompMap, exec func(p *Prog))

Mutates the program using the comparison operands stored in compMaps. For each of the mutants executes the exec callback.

func (*Prog) Serialize Uses

func (p *Prog) Serialize() []byte

func (*Prog) SerializeForExec Uses

func (p *Prog) SerializeForExec(buffer []byte) (int, error)

SerializeForExec serializes program p for execution by process pid into the provided buffer. Returns number of bytes written to the buffer. If the provided buffer is too small for the program an error is returned.

func (*Prog) SerializeVerbose Uses

func (p *Prog) SerializeVerbose() []byte

func (*Prog) String Uses

func (p *Prog) String() string

String generates a very compact program description (mostly for debug output).

type PtrType Uses

type PtrType struct {
    TypeCommon
    Type Type
}

func (*PtrType) DefaultArg Uses

func (t *PtrType) DefaultArg() Arg

func (*PtrType) String Uses

func (t *PtrType) String() string

type ResourceCtor Uses

type ResourceCtor struct {
    Call    int // Index in Target.Syscalls
    Precise bool
}

type ResourceDesc Uses

type ResourceDesc struct {
    Name   string
    Type   Type
    Kind   []string
    Values []uint64
    Ctors  []ResourceCtor
}

type ResourceType Uses

type ResourceType struct {
    TypeCommon
    ArgFormat BinaryFormat
    Desc      *ResourceDesc
}

func (*ResourceType) Default Uses

func (t *ResourceType) Default() uint64

func (*ResourceType) DefaultArg Uses

func (t *ResourceType) DefaultArg() Arg

func (*ResourceType) Format Uses

func (t *ResourceType) Format() BinaryFormat

func (*ResourceType) SpecialValues Uses

func (t *ResourceType) SpecialValues() []uint64

func (*ResourceType) String Uses

func (t *ResourceType) String() string

type ResultArg Uses

type ResultArg struct {
    ArgCommon
    Res   *ResultArg // reference to arg which we use
    OpDiv uint64     // divide result (executed before OpAdd)
    OpAdd uint64     // add to result
    Val   uint64     // value used if Res is nil
    // contains filtered or unexported fields
}

Used for ResourceType. This is the only argument that can be used as syscall return value. Either holds constant value or reference another ResultArg.

func MakeResultArg Uses

func MakeResultArg(t Type, r *ResultArg, v uint64) *ResultArg

func MakeReturnArg Uses

func MakeReturnArg(t Type) *ResultArg

func (*ResultArg) Size Uses

func (arg *ResultArg) Size() uint64

type StructDesc Uses

type StructDesc struct {
    TypeCommon
    Fields    []Type
    AlignAttr uint64
}

func (*StructDesc) FieldName Uses

func (t *StructDesc) FieldName() string

type StructKey Uses

type StructKey struct {
    Name string
    Dir  Dir
}

type StructType Uses

type StructType struct {
    Key     StructKey
    FldName string
    *StructDesc
}

func (*StructType) DefaultArg Uses

func (t *StructType) DefaultArg() Arg

func (*StructType) FieldName Uses

func (t *StructType) FieldName() string

func (*StructType) String Uses

func (t *StructType) String() string

type Syscall Uses

type Syscall struct {
    ID          int
    NR          uint64 // kernel syscall number
    Name        string
    CallName    string
    MissingArgs int // number of trailing args that should be zero-filled
    Args        []Type
    Ret         Type
}

type Target Uses

type Target struct {
    OS         string
    Arch       string
    Revision   string // unique hash representing revision of the descriptions
    PtrSize    uint64
    PageSize   uint64
    NumPages   uint64
    DataOffset uint64

    Syscalls  []*Syscall
    Resources []*ResourceDesc
    Structs   []*KeyedStruct
    Consts    []ConstValue

    // MakeMmap creates call that maps [addr, addr+size) memory range.
    MakeMmap func(addr, size uint64) *Call

    // SanitizeCall neutralizes harmful calls.
    SanitizeCall func(c *Call)

    // AnnotateCall annotates a syscall invocation in C reproducers.
    // The returned string will be placed inside a comment except for the
    // empty string which will omit the comment.
    AnnotateCall func(c ExecCall) string

    // SpecialTypes allows target to do custom generation/mutation for some struct's and union's.
    // Map key is struct/union name for which custom generation/mutation is required.
    // Map value is custom generation/mutation function that will be called
    // for the corresponding type. g is helper object that allows generate random numbers,
    // allocate memory, etc. typ is the struct/union type. old is the old value of the struct/union
    // for mutation, or nil for generation. The function returns a new value of the struct/union,
    // and optionally any calls that need to be inserted before the arg reference.
    SpecialTypes map[string]func(g *Gen, typ Type, old Arg) (Arg, []*Call)

    // Special strings that can matter for the target.
    // Used as fallback when string type does not have own dictionary.
    StringDictionary []string

    // Additional special invalid pointer values besides NULL to use.
    SpecialPointers []uint64

    SyscallMap map[string]*Syscall
    ConstMap   map[string]uint64
    // contains filtered or unexported fields
}

Target describes target OS/arch pair.

func AllTargets Uses

func AllTargets() []*Target

func GetTarget Uses

func GetTarget(OS, arch string) (*Target, error)

func (*Target) ArgContainsAny Uses

func (target *Target) ArgContainsAny(arg0 Arg) (res bool)

func (*Target) BuildChoiceTable Uses

func (target *Target) BuildChoiceTable(prios [][]float32, enabled map[*Syscall]bool) *ChoiceTable

func (*Target) CalculatePriorities Uses

func (target *Target) CalculatePriorities(corpus []*Prog) [][]float32

func (*Target) CallContainsAny Uses

func (target *Target) CallContainsAny(c *Call) (res bool)

func (*Target) Deserialize Uses

func (target *Target) Deserialize(data []byte, mode DeserializeMode) (*Prog, error)

func (*Target) DeserializeExec Uses

func (target *Target) DeserializeExec(exec []byte) (ExecProg, error)

func (*Target) Generate Uses

func (target *Target) Generate(rs rand.Source, ncalls int, ct *ChoiceTable) *Prog

Generate generates a random program of length ~ncalls. calls is a set of allowed syscalls, if nil all syscalls are used.

func (*Target) GenerateAllSyzProg Uses

func (target *Target) GenerateAllSyzProg(rs rand.Source) *Prog

GenerateAllSyzProg generates a program that contains all pseudo syz_ calls for testing.

func (*Target) GenerateSimpleProg Uses

func (target *Target) GenerateSimpleProg() *Prog

GenerateSimpleProg generates the simplest non-empty program for testing (e.g. containing a single mmap).

func (*Target) GenerateUberMmapProg Uses

func (target *Target) GenerateUberMmapProg() *Prog

func (*Target) GetConst Uses

func (target *Target) GetConst(name string) uint64

func (*Target) ParseLog Uses

func (target *Target) ParseLog(data []byte) []*LogEntry

func (*Target) PhysicalAddr Uses

func (target *Target) PhysicalAddr(arg *PointerArg) uint64

func (*Target) TransitivelyEnabledCalls Uses

func (target *Target) TransitivelyEnabledCalls(enabled map[*Syscall]bool) (map[*Syscall]bool, map[*Syscall]string)

type TextKind Uses

type TextKind int
const (
    TextTarget TextKind = iota
    TextX86Real
    TextX86bit16
    TextX86bit32
    TextX86bit64
    TextArm64
)

type Type Uses

type Type interface {
    String() string
    Name() string
    FieldName() string
    Dir() Dir
    Optional() bool
    Varlen() bool
    Size() uint64
    TypeBitSize() uint64
    Format() BinaryFormat
    BitfieldOffset() uint64
    BitfieldLength() uint64
    BitfieldMiddle() bool // returns true for all but last bitfield in a group

    DefaultArg() Arg
    // contains filtered or unexported methods
}

type TypeCommon Uses

type TypeCommon struct {
    TypeName   string
    FldName    string // for struct fields and named args
    TypeSize   uint64 // static size of the type, or 0 for variable size types
    ArgDir     Dir
    IsOptional bool
    IsVarlen   bool
}

func (*TypeCommon) BitfieldLength Uses

func (t *TypeCommon) BitfieldLength() uint64

func (*TypeCommon) BitfieldMiddle Uses

func (t *TypeCommon) BitfieldMiddle() bool

func (*TypeCommon) BitfieldOffset Uses

func (t *TypeCommon) BitfieldOffset() uint64

func (TypeCommon) Dir Uses

func (t TypeCommon) Dir() Dir

func (*TypeCommon) FieldName Uses

func (t *TypeCommon) FieldName() string

func (*TypeCommon) Format Uses

func (t *TypeCommon) Format() BinaryFormat

func (*TypeCommon) Name Uses

func (t *TypeCommon) Name() string

func (*TypeCommon) Optional Uses

func (t *TypeCommon) Optional() bool

func (*TypeCommon) Size Uses

func (t *TypeCommon) Size() uint64

func (*TypeCommon) TypeBitSize Uses

func (t *TypeCommon) TypeBitSize() uint64

func (*TypeCommon) Varlen Uses

func (t *TypeCommon) Varlen() bool

type UnionArg Uses

type UnionArg struct {
    ArgCommon
    Option Arg
}

Used for UnionType.

func MakeUnionArg Uses

func MakeUnionArg(t Type, opt Arg) *UnionArg

func (*UnionArg) Size Uses

func (arg *UnionArg) Size() uint64

type UnionType Uses

type UnionType struct {
    Key     StructKey
    FldName string
    *StructDesc
}

func (*UnionType) DefaultArg Uses

func (t *UnionType) DefaultArg() Arg

func (*UnionType) FieldName Uses

func (t *UnionType) FieldName() string

func (*UnionType) String Uses

func (t *UnionType) String() string

type VmaType Uses

type VmaType struct {
    TypeCommon
    RangeBegin uint64 // in pages
    RangeEnd   uint64
}

func (*VmaType) DefaultArg Uses

func (t *VmaType) DefaultArg() Arg

func (*VmaType) String Uses

func (t *VmaType) String() string

Directories

PathSynopsis
test

Package prog imports 15 packages (graph) and is imported by 70 packages. Updated 2019-12-07. Refresh now. Tools for package owners.