From 15846cbccf63a4e74cce5b8cf0c1931fdcf81ccd Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Wed, 15 May 2024 15:17:16 +0200 Subject: pkg/ipc: use flatrpc flags Flatrpc flags are passed in RPC execution requests, so to avoid conversions and duplicate set of flags use flatrpc flags in pkg/ipc directly. --- pkg/fuzzer/fuzzer.go | 5 ++- pkg/fuzzer/fuzzer_test.go | 7 ++-- pkg/fuzzer/job.go | 17 ++++---- pkg/fuzzer/queue/queue.go | 7 ++-- pkg/ipc/ipc.go | 92 +++++++++++++----------------------------- pkg/ipc/ipc_test.go | 7 ++-- pkg/ipc/ipcconfig/ipcconfig.go | 11 ++--- pkg/runtest/run.go | 18 ++++----- pkg/vminfo/features.go | 34 ++++++++-------- pkg/vminfo/syscalls.go | 4 +- 10 files changed, 86 insertions(+), 116 deletions(-) (limited to 'pkg') 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 "" -- cgit mrf-deployment