ipc

package
v0.0.0-...-8742a2b Latest Latest
Warning

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

Go to latest
Published: May 9, 2020 License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FlagsToSandbox

func FlagsToSandbox(flags EnvFlags) string

Types

type CallFlags

type CallFlags uint32
const (
	CallExecuted      CallFlags = 1 << iota // was started at all
	CallFinished                            // finished executing (rather than blocked forever)
	CallBlocked                             // finished but blocked during execution
	CallFaultInjected                       // fault was injected into this call
)

type CallInfo

type CallInfo struct {
	Flags  CallFlags
	Signal []uint32 // feedback signal, filled if FlagSignal is set
	Cover  []uint32 // per-call coverage, filled if FlagSignal is set and cover == true,
	// if dedup == false, then cov effectively contains a trace, otherwise duplicates are removed
	Comps prog.CompMap // per-call comparison operands
	Errno int          // call errno (0 if the call was successful)
}

type Config

type Config struct {
	// Path to executor binary.
	Executor string

	UseShmem      bool // use shared memory instead of pipes for communication
	UseForkServer bool // use extended protocol with handshake

	// Flags are configuation flags, defined above.
	Flags EnvFlags

	// Timeout is the execution timeout for a single program.
	Timeout time.Duration
}

Config is the configuration for Env.

type Env

type Env struct {
	StatExecs    uint64
	StatRestarts uint64
	// contains filtered or unexported fields
}

func MakeEnv

func MakeEnv(config *Config, pid int) (*Env, error)

func (*Env) Close

func (env *Env) Close() error

func (*Env) Exec

func (env *Env) Exec(opts *ExecOpts, p *prog.Prog) (output []byte, info *ProgInfo, hanged bool, err0 error)

Exec starts executor binary to execute program p and returns information about the execution: output: process output info: per-call info hanged: program hanged and was killed err0: failed to start the process or bug in executor itself

type EnvFlags

type EnvFlags uint64

Configuration flags for Config.Flags.

const (
	FlagDebug            EnvFlags = 1 << iota // debug output from executor
	FlagSignal                                // collect feedback signals (coverage)
	FlagSandboxSetuid                         // impersonate nobody user
	FlagSandboxNamespace                      // use namespaces for sandboxing
	FlagSandboxAndroid                        // use Android sandboxing for the untrusted_app domain
	FlagExtraCover                            // collect extra coverage
	FlagEnableTun                             // setup and use /dev/tun for packet injection
	FlagEnableNetDev                          // setup more network devices for testing
	FlagEnableNetReset                        // reset network namespace between programs
	FlagEnableCgroups                         // setup cgroups for testing
	FlagEnableCloseFds                        // close fds after each program
	FlagEnableDevlinkPCI                      // setup devlink PCI device
)

Note: New / changed flags should be added to parse_env_flags in executor.cc

func SandboxToFlags

func SandboxToFlags(sandbox string) (EnvFlags, error)

type ExecFlags

type ExecFlags uint64

Per-exec flags for ExecOpts.Flags:

const (
	FlagCollectCover ExecFlags = 1 << iota // collect coverage
	FlagDedupCover                         // deduplicate coverage in executor
	FlagInjectFault                        // inject a fault in this execution (see ExecOpts)
	FlagCollectComps                       // collect KCOV comparisons
	FlagThreaded                           // use multiple threads to mitigate blocked syscalls
	FlagCollide                            // collide syscalls to provoke data races
)

type ExecOpts

type ExecOpts struct {
	Flags     ExecFlags
	FaultCall int // call index for fault injection (0-based)
	FaultNth  int // fault n-th operation in the call (0-based)
}

type Gate

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

Gate limits concurrency level and window to the given value. Limitation of concurrency window means that if a very old activity is still running it will not let new activities to start even if concurrency level is low.

func NewGate

func NewGate(c int, f func()) *Gate

If f is not nil, it will be called after each batch of c activities.

func (*Gate) Enter

func (g *Gate) Enter() int

func (*Gate) Leave

func (g *Gate) Leave(idx int)

type ProgInfo

type ProgInfo struct {
	Calls []CallInfo
	Extra CallInfo // stores Signal and Cover collected from background threads
}

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL