aboutsummaryrefslogtreecommitdiffstats
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/fuzzer/fuzzer.go5
-rw-r--r--pkg/fuzzer/fuzzer_test.go7
-rw-r--r--pkg/fuzzer/job.go17
-rw-r--r--pkg/fuzzer/queue/queue.go7
-rw-r--r--pkg/ipc/ipc.go92
-rw-r--r--pkg/ipc/ipc_test.go7
-rw-r--r--pkg/ipc/ipcconfig/ipcconfig.go11
-rw-r--r--pkg/runtest/run.go18
-rw-r--r--pkg/vminfo/features.go34
-rw-r--r--pkg/vminfo/syscalls.go4
10 files changed, 86 insertions, 116 deletions
diff --git a/pkg/fuzzer/fuzzer.go b/pkg/fuzzer/fuzzer.go
index eaedc951d..92b4c8bf1 100644
--- a/pkg/fuzzer/fuzzer.go
+++ b/pkg/fuzzer/fuzzer.go
@@ -12,6 +12,7 @@ import (
"time"
"github.com/google/syzkaller/pkg/corpus"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/fuzzer/queue"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/stats"
@@ -121,7 +122,7 @@ func (fuzzer *Fuzzer) processResult(req *queue.Request, res *queue.Result, flags
// We do it before unblocking the waiting threads because
// it may result it concurrent modification of req.Prog.
// If we are already triaging this exact prog, this is flaky coverage.
- if req.ExecOpts.ExecFlags&ipc.FlagCollectSignal > 0 && res.Info != nil && !inTriage {
+ if req.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectSignal > 0 && res.Info != nil && !inTriage {
for call, info := range res.Info.Calls {
fuzzer.triageProgCall(req.Prog, &info, call, flags)
}
@@ -325,7 +326,7 @@ func (fuzzer *Fuzzer) RotateMaxSignal(items int) {
fuzzer.Cover.subtract(delta)
}
-func setFlags(execFlags ipc.ExecFlags) ipc.ExecOpts {
+func setFlags(execFlags flatrpc.ExecFlag) ipc.ExecOpts {
return ipc.ExecOpts{
ExecFlags: execFlags,
}
diff --git a/pkg/fuzzer/fuzzer_test.go b/pkg/fuzzer/fuzzer_test.go
index f358aacab..cb58a4e10 100644
--- a/pkg/fuzzer/fuzzer_test.go
+++ b/pkg/fuzzer/fuzzer_test.go
@@ -18,6 +18,7 @@ import (
"github.com/google/syzkaller/pkg/corpus"
"github.com/google/syzkaller/pkg/csource"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/fuzzer/queue"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/ipc/ipcconfig"
@@ -190,10 +191,10 @@ func emulateExec(req *queue.Request) (*queue.Result, string, error) {
cover := uint32(call.Meta.ID*1024) +
crc32.Checksum(serializedLines[i], crc32q)%4
callInfo := ipc.CallInfo{}
- if req.ExecOpts.ExecFlags&ipc.FlagCollectCover > 0 {
+ if req.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectCover > 0 {
callInfo.Cover = []uint32{cover}
}
- if req.ExecOpts.ExecFlags&ipc.FlagCollectSignal > 0 {
+ if req.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectSignal > 0 {
callInfo.Signal = []uint32{cover}
}
info.Calls = append(info.Calls, callInfo)
@@ -285,7 +286,7 @@ func newProc(t *testing.T, target *prog.Target, executor string) *executorProc {
t.Fatal(err)
}
config.Executor = executor
- execOpts.EnvFlags |= ipc.FlagSignal
+ execOpts.EnvFlags |= flatrpc.ExecEnvSignal
env, err := ipc.MakeEnv(config, 0)
if err != nil {
t.Fatal(err)
diff --git a/pkg/fuzzer/job.go b/pkg/fuzzer/job.go
index 174acdc52..4e605f1c2 100644
--- a/pkg/fuzzer/job.go
+++ b/pkg/fuzzer/job.go
@@ -9,6 +9,7 @@ import (
"github.com/google/syzkaller/pkg/corpus"
"github.com/google/syzkaller/pkg/cover"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/fuzzer/queue"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/signal"
@@ -35,7 +36,7 @@ func genProgRequest(fuzzer *Fuzzer, rnd *rand.Rand) *queue.Request {
fuzzer.ChoiceTable())
return &queue.Request{
Prog: p,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
Stat: fuzzer.statExecGenerate,
}
}
@@ -54,7 +55,7 @@ func mutateProgRequest(fuzzer *Fuzzer, rnd *rand.Rand) *queue.Request {
)
return &queue.Request{
Prog: newP,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
Stat: fuzzer.statExecFuzz,
}
}
@@ -69,7 +70,7 @@ func candidateRequest(fuzzer *Fuzzer, input Candidate) (*queue.Request, ProgType
}
return &queue.Request{
Prog: input.Prog,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
Stat: fuzzer.statExecCandidate,
Important: true,
}, flags
@@ -163,7 +164,7 @@ func (job *triageJob) deflake(exec func(*queue.Request, ProgTypes) *queue.Result
}
result := exec(&queue.Request{
Prog: job.p,
- ExecOpts: setFlags(ipc.FlagCollectCover | ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectCover | flatrpc.ExecFlagCollectSignal),
ReturnAllSignal: true,
Stat: stat,
}, progInTriage)
@@ -202,7 +203,7 @@ func (job *triageJob) minimize(newSignal signal.Signal) (stop bool) {
for i := 0; i < minimizeAttempts; i++ {
result := job.execute(&queue.Request{
Prog: p1,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
SignalFilter: newSignal,
SignalFilterCall: call1,
Stat: job.fuzzer.statExecMinimize,
@@ -273,7 +274,7 @@ func (job *smashJob) run(fuzzer *Fuzzer) {
fuzzer.Config.Corpus.Programs())
result := fuzzer.execute(fuzzer.smashQueue, &queue.Request{
Prog: p,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
Stat: fuzzer.statExecSmash,
})
if result.Stop() {
@@ -351,7 +352,7 @@ func (job *hintsJob) run(fuzzer *Fuzzer) {
for i := 0; i < 2; i++ {
result := fuzzer.execute(fuzzer.smashQueue, &queue.Request{
Prog: p,
- ExecOpts: setFlags(ipc.FlagCollectComps),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectComps),
Stat: fuzzer.statExecSeed,
})
if result.Stop() || result.Info == nil {
@@ -374,7 +375,7 @@ func (job *hintsJob) run(fuzzer *Fuzzer) {
func(p *prog.Prog) bool {
result := fuzzer.execute(fuzzer.smashQueue, &queue.Request{
Prog: p,
- ExecOpts: setFlags(ipc.FlagCollectSignal),
+ ExecOpts: setFlags(flatrpc.ExecFlagCollectSignal),
Stat: fuzzer.statExecHint,
})
return !result.Stop()
diff --git a/pkg/fuzzer/queue/queue.go b/pkg/fuzzer/queue/queue.go
index 6ff94b9be..36226299a 100644
--- a/pkg/fuzzer/queue/queue.go
+++ b/pkg/fuzzer/queue/queue.go
@@ -11,6 +11,7 @@ import (
"sync"
"sync/atomic"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/hash"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/signal"
@@ -102,15 +103,15 @@ func (r *Request) Risky() bool {
}
func (r *Request) Validate() error {
- collectSignal := r.ExecOpts.ExecFlags&ipc.FlagCollectSignal > 0
+ collectSignal := r.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectSignal > 0
if r.ReturnAllSignal && !collectSignal {
return fmt.Errorf("ReturnAllSignal is set, but FlagCollectSignal is not")
}
if r.SignalFilter != nil && !collectSignal {
return fmt.Errorf("SignalFilter must be used with FlagCollectSignal")
}
- collectComps := r.ExecOpts.ExecFlags&ipc.FlagCollectComps > 0
- collectCover := r.ExecOpts.ExecFlags&ipc.FlagCollectCover > 0
+ collectComps := r.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectComps > 0
+ collectCover := r.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectCover > 0
if (collectComps) && (collectSignal || collectCover) {
return fmt.Errorf("hint collection is mutually exclusive with signal/coverage")
}
diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go
index d6bae8af1..0e12fa2bd 100644
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@@ -26,46 +26,11 @@ import (
"github.com/google/syzkaller/sys/targets"
)
-// Configuration flags for Config.Flags.
-type EnvFlags uint64
-
-// Note: New / changed flags should be added to parse_env_flags in executor.cc.
-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
- FlagEnableVhciInjection // setup and use /dev/vhci for hci packet injection
- FlagEnableWifi // setup and use mac80211_hwsim for wifi emulation
- FlagDelayKcovMmap // manage kcov memory in an optimized way
- FlagEnableNicVF // setup NIC VF device
-)
-
-// Per-exec flags for ExecOpts.Flags.
-type ExecFlags uint64
-
-const (
- FlagCollectSignal ExecFlags = 1 << iota // collect feedback signals
- FlagCollectCover // collect coverage
- FlagDedupCover // deduplicate coverage in executor
- FlagCollectComps // collect KCOV comparisons
- FlagThreaded // use multiple threads to mitigate blocked syscalls
- FlagEnableCoverageFilter // setup and use bitmap to do coverage filter
-)
-
type ExecOpts struct {
- // Changing ExecFlags between executions does not cause executor process restart.
- // Changing EnvFlags/SandboxArg does cause process restart.
- ExecFlags ExecFlags
- EnvFlags EnvFlags
+ // Changing ExecFlag between executions does not cause executor process restart.
+ // Changing ExecEnv/SandboxArg does cause process restart.
+ ExecFlags flatrpc.ExecFlag
+ EnvFlags flatrpc.ExecEnv
SandboxArg int
}
@@ -168,73 +133,72 @@ const (
extraReplyIndex = 0xffffffff // uint32(-1)
)
-func SandboxToFlags(sandbox string) (EnvFlags, error) {
+func SandboxToFlags(sandbox string) (flatrpc.ExecEnv, error) {
switch sandbox {
case "none":
return 0, nil
case "setuid":
- return FlagSandboxSetuid, nil
+ return flatrpc.ExecEnvSandboxSetuid, nil
case "namespace":
- return FlagSandboxNamespace, nil
+ return flatrpc.ExecEnvSandboxNamespace, nil
case "android":
- return FlagSandboxAndroid, nil
+ return flatrpc.ExecEnvSandboxAndroid, nil
default:
return 0, fmt.Errorf("sandbox must contain one of none/setuid/namespace/android")
}
}
-func FlagsToSandbox(flags EnvFlags) string {
- if flags&FlagSandboxSetuid != 0 {
+func FlagsToSandbox(flags flatrpc.ExecEnv) string {
+ if flags&flatrpc.ExecEnvSandboxSetuid != 0 {
return "setuid"
- } else if flags&FlagSandboxNamespace != 0 {
+ } else if flags&flatrpc.ExecEnvSandboxNamespace != 0 {
return "namespace"
- } else if flags&FlagSandboxAndroid != 0 {
+ } else if flags&flatrpc.ExecEnvSandboxAndroid != 0 {
return "android"
}
return "none"
}
-// nolint: gocyclo
-func FeaturesToFlags(features flatrpc.Feature, manual csource.Features) EnvFlags {
+func FeaturesToFlags(features flatrpc.Feature, manual csource.Features) flatrpc.ExecEnv {
for feat := range flatrpc.EnumNamesFeature {
opt := FlatRPCFeaturesToCSource[feat]
if opt != "" && manual != nil && !manual[opt].Enabled {
features &= ^feat
}
}
- var flags EnvFlags
+ var flags flatrpc.ExecEnv
if manual == nil || manual["net_reset"].Enabled {
- flags |= FlagEnableNetReset
+ flags |= flatrpc.ExecEnvEnableNetReset
}
if manual == nil || manual["cgroups"].Enabled {
- flags |= FlagEnableCgroups
+ flags |= flatrpc.ExecEnvEnableCgroups
}
if manual == nil || manual["close_fds"].Enabled {
- flags |= FlagEnableCloseFds
+ flags |= flatrpc.ExecEnvEnableCloseFds
}
if features&flatrpc.FeatureExtraCoverage != 0 {
- flags |= FlagExtraCover
+ flags |= flatrpc.ExecEnvExtraCover
}
if features&flatrpc.FeatureDelayKcovMmap != 0 {
- flags |= FlagDelayKcovMmap
+ flags |= flatrpc.ExecEnvDelayKcovMmap
}
if features&flatrpc.FeatureNetInjection != 0 {
- flags |= FlagEnableTun
+ flags |= flatrpc.ExecEnvEnableTun
}
if features&flatrpc.FeatureNetDevices != 0 {
- flags |= FlagEnableNetDev
+ flags |= flatrpc.ExecEnvEnableNetDev
}
if features&flatrpc.FeatureDevlinkPCI != 0 {
- flags |= FlagEnableDevlinkPCI
+ flags |= flatrpc.ExecEnvEnableDevlinkPCI
}
if features&flatrpc.FeatureNicVF != 0 {
- flags |= FlagEnableNicVF
+ flags |= flatrpc.ExecEnvEnableNicVF
}
if features&flatrpc.FeatureVhciInjection != 0 {
- flags |= FlagEnableVhciInjection
+ flags |= flatrpc.ExecEnvEnableVhciInjection
}
if features&flatrpc.FeatureWifiEmulation != 0 {
- flags |= FlagEnableWifi
+ flags |= flatrpc.ExecEnvEnableWifi
}
return flags
}
@@ -481,7 +445,7 @@ func (env *Env) parseOutput(opts *ExecOpts, ncalls int) (*ProgInfo, error) {
if len(extraParts) == 0 {
return info, nil
}
- info.Extra = convertExtra(extraParts, opts.ExecFlags&FlagDedupCover > 0)
+ info.Extra = convertExtra(extraParts, opts.ExecFlags&flatrpc.ExecFlagDedupCover != 0)
return info, nil
}
@@ -593,7 +557,7 @@ func readUint32Array(outp *[]byte, size uint32) ([]uint32, bool) {
type command struct {
pid int
config *Config
- flags EnvFlags
+ flags flatrpc.ExecEnv
sandboxArg int
timeout time.Duration
cmd *exec.Cmd
@@ -723,7 +687,7 @@ func (env *Env) makeCommand(opts *ExecOpts, tmpDir string) (*command, error) {
cmd.Env = append(append([]string{}, os.Environ()...), "ASAN_OPTIONS=handle_segv=0 allow_user_segv_handler=1")
cmd.Stdin = outrp
cmd.Stdout = inwp
- if c.flags&FlagDebug != 0 {
+ if c.flags&flatrpc.ExecEnvDebug != 0 {
close(c.readDone)
cmd.Stderr = os.Stdout
} else {
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index af4eaf24a..30e97660f 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -12,6 +12,7 @@ import (
"time"
"github.com/google/syzkaller/pkg/csource"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/image"
. "github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/ipc/ipcconfig"
@@ -80,7 +81,7 @@ func TestExecute(t *testing.T) {
bin := csource.BuildExecutor(t, target, "../..")
- flags := []ExecFlags{0, FlagThreaded}
+ flags := []flatrpc.ExecFlag{0, flatrpc.ExecFlagThreaded}
for _, flag := range flags {
t.Logf("testing flags 0x%x", flag)
cfg := &Config{
@@ -189,7 +190,7 @@ func TestZlib(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- opts.EnvFlags |= FlagDebug
+ opts.EnvFlags |= flatrpc.ExecEnvDebug
cfg.Executor = csource.BuildExecutor(t, target, "../..")
env, err := MakeEnv(cfg, 0)
if err != nil {
@@ -247,7 +248,7 @@ func TestExecutorCommonExt(t *testing.T) {
t.Fatal(err)
}
cfg.Executor = bin
- opts.EnvFlags |= FlagDebug
+ opts.EnvFlags |= flatrpc.ExecEnvDebug
env, err := MakeEnv(cfg, 0)
if err != nil {
t.Fatalf("failed to create env: %v", err)
diff --git a/pkg/ipc/ipcconfig/ipcconfig.go b/pkg/ipc/ipcconfig/ipcconfig.go
index 1a91b28fb..343697c8f 100644
--- a/pkg/ipc/ipcconfig/ipcconfig.go
+++ b/pkg/ipc/ipcconfig/ipcconfig.go
@@ -6,6 +6,7 @@ package ipcconfig
import (
"flag"
+ "github.com/google/syzkaller/pkg/flatrpc"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/prog"
"github.com/google/syzkaller/sys/targets"
@@ -32,19 +33,19 @@ func Default(target *prog.Target) (*ipc.Config, *ipc.ExecOpts, error) {
c.RateLimit = sysTarget.HostFuzzer && target.OS != targets.TestOS
opts := &ipc.ExecOpts{
- ExecFlags: ipc.FlagDedupCover,
+ ExecFlags: flatrpc.ExecFlagDedupCover,
}
if *flagThreaded {
- opts.ExecFlags |= ipc.FlagThreaded
+ opts.ExecFlags |= flatrpc.ExecFlagThreaded
}
if *flagSignal {
- opts.ExecFlags |= ipc.FlagCollectSignal
+ opts.ExecFlags |= flatrpc.ExecFlagCollectSignal
}
if *flagSignal {
- opts.EnvFlags |= ipc.FlagSignal
+ opts.EnvFlags |= flatrpc.ExecEnvSignal
}
if *flagDebug {
- opts.EnvFlags |= ipc.FlagDebug
+ opts.EnvFlags |= flatrpc.ExecEnvDebug
}
sandboxFlags, err := ipc.SandboxToFlags(*flagSandbox)
if err != nil {
diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go
index a3df53f5a..29fa9d0cf 100644
--- a/pkg/runtest/run.go
+++ b/pkg/runtest/run.go
@@ -424,16 +424,16 @@ func (ctx *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bo
}
opts.EnvFlags |= sandboxFlags
if threaded {
- opts.ExecFlags |= ipc.FlagThreaded
+ opts.ExecFlags |= flatrpc.ExecFlagThreaded
}
if cov {
- opts.EnvFlags |= ipc.FlagSignal
- opts.ExecFlags |= ipc.FlagCollectSignal
- opts.ExecFlags |= ipc.FlagCollectCover
+ opts.EnvFlags |= flatrpc.ExecEnvSignal
+ opts.ExecFlags |= flatrpc.ExecFlagCollectSignal
+ opts.ExecFlags |= flatrpc.ExecFlagCollectCover
}
opts.EnvFlags |= ipc.FeaturesToFlags(ctx.Features, nil)
if ctx.Debug {
- opts.EnvFlags |= ipc.FlagDebug
+ opts.EnvFlags |= flatrpc.ExecEnvDebug
}
req := &runRequest{
Request: &queue.Request{
@@ -484,9 +484,9 @@ func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, tim
if err != nil {
return nil, fmt.Errorf("failed to build C program: %w", err)
}
- var ipcFlags ipc.ExecFlags
+ var ipcFlags flatrpc.ExecFlag
if threaded {
- ipcFlags |= ipc.FlagThreaded
+ ipcFlags |= flatrpc.ExecFlagThreaded
}
req := &runRequest{
Request: &queue.Request{
@@ -551,7 +551,7 @@ func checkCallResult(req *runRequest, isC bool, run, call int, info ipc.ProgInfo
// C code does not detect blocked/non-finished calls.
continue
}
- if req.ExecOpts.ExecFlags&ipc.FlagThreaded == 0 {
+ if req.ExecOpts.ExecFlags&flatrpc.ExecFlagThreaded == 0 {
// In non-threaded mode blocked syscalls will block main thread
// and we won't detect blocked/unfinished syscalls.
continue
@@ -577,7 +577,7 @@ func checkCallResult(req *runRequest, isC bool, run, call int, info ipc.ProgInfo
if isC || inf.Flags&ipc.CallExecuted == 0 {
return nil
}
- if req.ExecOpts.EnvFlags&ipc.FlagSignal != 0 {
+ if req.ExecOpts.EnvFlags&flatrpc.ExecEnvSignal != 0 {
// Signal is always deduplicated, so we may not get any signal
// on a second invocation of the same syscall.
// For calls that are not meant to collect synchronous coverage we
diff --git a/pkg/vminfo/features.go b/pkg/vminfo/features.go
index 0cfa980ee..3b7bae8d5 100644
--- a/pkg/vminfo/features.go
+++ b/pkg/vminfo/features.go
@@ -118,24 +118,24 @@ func (ctx *checkContext) finishFeatures(featureInfos []*flatrpc.FeatureInfo) (Fe
// featureToFlags creates ipc flags required to test the feature on a simple program.
// For features that has setup procedure in the executor, we just execute with the default flags.
-func (ctx *checkContext) featureToFlags(feat flatrpc.Feature) (ipc.EnvFlags, ipc.ExecFlags) {
+func (ctx *checkContext) featureToFlags(feat flatrpc.Feature) (flatrpc.ExecEnv, flatrpc.ExecFlag) {
envFlags := ctx.sandbox
// These don't have a corresponding feature and are always enabled.
- envFlags |= ipc.FlagEnableCloseFds | ipc.FlagEnableCgroups | ipc.FlagEnableNetReset
- execFlags := ipc.FlagThreaded
+ envFlags |= flatrpc.ExecEnvEnableCloseFds | flatrpc.ExecEnvEnableCgroups | flatrpc.ExecEnvEnableNetReset
+ execFlags := flatrpc.ExecFlagThreaded
switch feat {
case flatrpc.FeatureCoverage:
- envFlags |= ipc.FlagSignal
- execFlags |= ipc.FlagCollectSignal | ipc.FlagCollectCover
+ envFlags |= flatrpc.ExecEnvSignal
+ execFlags |= flatrpc.ExecFlagCollectSignal | flatrpc.ExecFlagCollectCover
case flatrpc.FeatureComparisons:
- envFlags |= ipc.FlagSignal
- execFlags |= ipc.FlagCollectComps
+ envFlags |= flatrpc.ExecEnvSignal
+ execFlags |= flatrpc.ExecFlagCollectComps
case flatrpc.FeatureExtraCoverage:
- envFlags |= ipc.FlagSignal | ipc.FlagExtraCover
- execFlags |= ipc.FlagCollectSignal | ipc.FlagCollectCover
+ envFlags |= flatrpc.ExecEnvSignal | flatrpc.ExecEnvExtraCover
+ execFlags |= flatrpc.ExecFlagCollectSignal | flatrpc.ExecFlagCollectCover
case flatrpc.FeatureDelayKcovMmap:
- envFlags |= ipc.FlagSignal | ipc.FlagDelayKcovMmap
- execFlags |= ipc.FlagCollectSignal | ipc.FlagCollectCover
+ envFlags |= flatrpc.ExecEnvSignal | flatrpc.ExecEnvDelayKcovMmap
+ execFlags |= flatrpc.ExecFlagCollectSignal | flatrpc.ExecFlagCollectCover
case flatrpc.FeatureSandboxSetuid:
// We use setuid sandbox feature to test that the simple program
// succeeds under the actual sandbox (not necessary setuid).
@@ -145,19 +145,19 @@ func (ctx *checkContext) featureToFlags(feat flatrpc.Feature) (ipc.EnvFlags, ipc
case flatrpc.FeatureFault:
case flatrpc.FeatureLeak:
case flatrpc.FeatureNetInjection:
- envFlags |= ipc.FlagEnableTun
+ envFlags |= flatrpc.ExecEnvEnableTun
case flatrpc.FeatureNetDevices:
- envFlags |= ipc.FlagEnableNetDev
+ envFlags |= flatrpc.ExecEnvEnableNetDev
case flatrpc.FeatureKCSAN:
case flatrpc.FeatureDevlinkPCI:
- envFlags |= ipc.FlagEnableDevlinkPCI
+ envFlags |= flatrpc.ExecEnvEnableDevlinkPCI
case flatrpc.FeatureNicVF:
- envFlags |= ipc.FlagEnableNicVF
+ envFlags |= flatrpc.ExecEnvEnableNicVF
case flatrpc.FeatureUSBEmulation:
case flatrpc.FeatureVhciInjection:
- envFlags |= ipc.FlagEnableVhciInjection
+ envFlags |= flatrpc.ExecEnvEnableVhciInjection
case flatrpc.FeatureWifiEmulation:
- envFlags |= ipc.FlagEnableWifi
+ envFlags |= flatrpc.ExecEnvEnableWifi
case flatrpc.FeatureLRWPANEmulation:
case flatrpc.FeatureBinFmtMisc:
case flatrpc.FeatureSwap:
diff --git a/pkg/vminfo/syscalls.go b/pkg/vminfo/syscalls.go
index 1e9714c9b..f6ab24a04 100644
--- a/pkg/vminfo/syscalls.go
+++ b/pkg/vminfo/syscalls.go
@@ -33,7 +33,7 @@ type checkContext struct {
impl checker
cfg *mgrconfig.Config
target *prog.Target
- sandbox ipc.EnvFlags
+ sandbox flatrpc.ExecEnv
executor queue.Executor
fs filesystem
// Once checking of a syscall is finished, the result is sent to syscalls.
@@ -222,7 +222,7 @@ func (ctx *checkContext) onlySandboxNone() string {
}
func (ctx *checkContext) onlySandboxNoneOrNamespace() string {
- if ctx.sandbox != 0 && ctx.sandbox != ipc.FlagSandboxNamespace {
+ if ctx.sandbox != 0 && ctx.sandbox != flatrpc.ExecEnvSandboxNamespace {
return "only supported under root with sandbox=none/namespace"
}
return ""
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-03-12 04:55:48 +0000