syzkaller: Index | Files | Directories

package ipc

import ""


Package Files

gate.go ipc.go

func FlagsToSandbox Uses

func FlagsToSandbox(flags EnvFlags) string

type CallFlags Uses

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 Uses

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 Uses

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 Uses

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

func MakeEnv Uses

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

func (*Env) Close Uses

func (env *Env) Close() error

func (*Env) Exec Uses

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 Uses

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

func SandboxToFlags Uses

func SandboxToFlags(sandbox string) (EnvFlags, error)

type ExecFlags Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (g *Gate) Enter() int

func (*Gate) Leave Uses

func (g *Gate) Leave(idx int)

type ProgInfo Uses

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



Package ipc imports 17 packages (graph) and is imported by 10 packages. Updated 2020-07-07. Refresh now. Tools for package owners.