From a16aed1db22739e7dea8098c79bc1963b871b5ec Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Wed, 21 Jan 2026 20:00:38 +0100 Subject: all: fix context.Context usage --- pkg/aflow/execute.go | 32 +++++------ pkg/cover/file.go | 6 +-- pkg/covermerger/covermerger.go | 14 ++--- pkg/flatrpc/conn.go | 8 +-- pkg/manager/diff.go | 42 +++++++-------- pkg/rpcserver/local.go | 38 ++++++------- pkg/rpcserver/rpcserver.go | 4 +- pkg/runtest/run.go | 118 ++++++++++++++++++++--------------------- 8 files changed, 131 insertions(+), 131 deletions(-) (limited to 'pkg') diff --git a/pkg/aflow/execute.go b/pkg/aflow/execute.go index 3e1a6a112..405498800 100644 --- a/pkg/aflow/execute.go +++ b/pkg/aflow/execute.go @@ -25,46 +25,46 @@ import ( // The workdir argument should point to a dir owned by aflow to store private data, // it can be shared across parallel executions in the same process, and preferably // preserved across process restarts for caching purposes. -func (flow *Flow) Execute(c context.Context, model, workdir string, inputs map[string]any, +func (flow *Flow) Execute(ctx context.Context, model, workdir string, inputs map[string]any, cache *Cache, onEvent onEvent) (map[string]any, error) { if err := flow.checkInputs(inputs); err != nil { return nil, fmt.Errorf("flow inputs are missing: %w", err) } - ctx := &Context{ - Context: c, + c := &Context{ + Context: ctx, Workdir: osutil.Abs(workdir), llmModel: model, cache: cache, state: maps.Clone(inputs), onEvent: onEvent, } - defer ctx.close() - if s := c.Value(stubContextKey); s != nil { - ctx.stubContext = *s.(*stubContext) + defer c.close() + if s := ctx.Value(stubContextKey); s != nil { + c.stubContext = *s.(*stubContext) } - if ctx.timeNow == nil { - ctx.timeNow = time.Now + if c.timeNow == nil { + c.timeNow = time.Now } - if ctx.generateContent == nil { - ctx.generateContent = ctx.generateContentGemini + if c.generateContent == nil { + c.generateContent = c.generateContentGemini } span := &trajectory.Span{ Type: trajectory.SpanFlow, Name: flow.Name, } - if err := ctx.startSpan(span); err != nil { + if err := c.startSpan(span); err != nil { return nil, err } - flowErr := flow.Root.execute(ctx) + flowErr := flow.Root.execute(c) if flowErr == nil { - span.Results = flow.extractOutputs(ctx.state) + span.Results = flow.extractOutputs(c.state) } - if err := ctx.finishSpan(span, flowErr); err != nil { + if err := c.finishSpan(span, flowErr); err != nil { return nil, err } - if ctx.spanNesting != 0 { + if c.spanNesting != 0 { // Since we finish all spans, even on errors, we should end up at 0. - panic(fmt.Sprintf("unbalanced spans (%v)", ctx.spanNesting)) + panic(fmt.Sprintf("unbalanced spans (%v)", c.spanNesting)) } return span.Results, nil } diff --git a/pkg/cover/file.go b/pkg/cover/file.go index 97b6be6b7..6c54a32ed 100644 --- a/pkg/cover/file.go +++ b/pkg/cover/file.go @@ -51,7 +51,7 @@ func RendFileCoverage(repo, forCommit, filePath string, fileProvider covermerger } // nolint:revive -func GetMergeResult(c context.Context, ns, repo, forCommit, sourceCommit, filePath string, +func GetMergeResult(ctx context.Context, ns, repo, forCommit, sourceCommit, filePath string, proxy covermerger.FuncProxyURI, tp coveragedb.TimePeriod) (*covermerger.MergeResult, error) { config := &covermerger.Config{ Jobs: 1, @@ -63,14 +63,14 @@ func GetMergeResult(c context.Context, ns, repo, forCommit, sourceCommit, filePa } fromDate, toDate := tp.DatesFromTo() - csvReader, err := covermerger.InitNsRecords(c, ns, filePath, sourceCommit, fromDate, toDate) + csvReader, err := covermerger.InitNsRecords(ctx, ns, filePath, sourceCommit, fromDate, toDate) if err != nil { return nil, fmt.Errorf("failed to covermerger.InitNsRecords: %w", err) } defer csvReader.Close() ch := make(chan *covermerger.FileMergeResult, 1) - if err := covermerger.MergeCSVData(c, config, csvReader, ch); err != nil { + if err := covermerger.MergeCSVData(ctx, config, csvReader, ch); err != nil { return nil, fmt.Errorf("error merging coverage: %w", err) } diff --git a/pkg/covermerger/covermerger.go b/pkg/covermerger/covermerger.go index 82ebe1766..cd279e319 100644 --- a/pkg/covermerger/covermerger.go +++ b/pkg/covermerger/covermerger.go @@ -263,7 +263,7 @@ type FileMergeResult struct { *MergeResult } -func MergeCSVData(c context.Context, config *Config, reader io.Reader, results chan<- *FileMergeResult) error { +func MergeCSVData(ctx context.Context, config *Config, reader io.Reader, results chan<- *FileMergeResult) error { var schema []string csvReader := csv.NewReader(reader) if fields, err := csvReader.Read(); err != nil { @@ -295,13 +295,13 @@ func MergeCSVData(c context.Context, config *Config, reader io.Reader, results c return } select { - case <-c.Done(): + case <-ctx.Done(): return case recordsChan <- record: } } }() - errMerging := mergeChanData(c, config, recordsChan, results) + errMerging := mergeChanData(ctx, config, recordsChan, results) errStream := <-errStreamChan if errMerging != nil || errStream != nil { return fmt.Errorf("errors merging stream data:\nmerger err: %w\nstream reader err: %w", @@ -315,10 +315,10 @@ type FileRecords struct { records []*FileRecord } -func mergeChanData(c context.Context, cfg *Config, recordChan <-chan *FileRecord, results chan<- *FileMergeResult, +func mergeChanData(ctx context.Context, cfg *Config, recordChan <-chan *FileRecord, results chan<- *FileMergeResult, ) error { g := errgroup.Group{} - frecordChan := groupFileRecords(recordChan, c) + frecordChan := groupFileRecords(ctx, recordChan) for i := 0; i < cfg.Jobs; i++ { g.Go(func() error { @@ -328,7 +328,7 @@ func mergeChanData(c context.Context, cfg *Config, recordChan <-chan *FileRecord return fmt.Errorf("failed to batchFileData(%s): %w", frecord.fileName, err) } select { - case <-c.Done(): + case <-ctx.Done(): return nil case results <- &FileMergeResult{ FilePath: frecord.fileName, @@ -341,7 +341,7 @@ func mergeChanData(c context.Context, cfg *Config, recordChan <-chan *FileRecord return g.Wait() } -func groupFileRecords(recordChan <-chan *FileRecord, ctx context.Context) chan FileRecords { +func groupFileRecords(ctx context.Context, recordChan <-chan *FileRecord) chan FileRecords { frecordChan := make(chan FileRecords) go func() { defer close(frecordChan) diff --git a/pkg/flatrpc/conn.go b/pkg/flatrpc/conn.go index 47b265493..e8ad1461f 100644 --- a/pkg/flatrpc/conn.go +++ b/pkg/flatrpc/conn.go @@ -45,11 +45,11 @@ func Listen(addr string) (*Serv, error) { // Serve accepts incoming connections and calls handler for each of them. // An error returned from the handler stops the server and aborts the whole processing. -func (s *Serv) Serve(baseCtx context.Context, handler func(context.Context, *Conn) error) error { - eg, ctx := errgroup.WithContext(baseCtx) +func (s *Serv) Serve(ctx context.Context, handler func(context.Context, *Conn) error) error { + eg, groupCtx := errgroup.WithContext(ctx) go func() { // If the context is cancelled, stop the server. - <-ctx.Done() + <-groupCtx.Done() s.Close() }() for { @@ -66,7 +66,7 @@ func (s *Serv) Serve(baseCtx context.Context, handler func(context.Context, *Con continue } eg.Go(func() error { - connCtx, cancel := context.WithCancel(ctx) + connCtx, cancel := context.WithCancel(groupCtx) defer cancel() c := NewConn(conn) diff --git a/pkg/manager/diff.go b/pkg/manager/diff.go index f972748d3..df2724206 100644 --- a/pkg/manager/diff.go +++ b/pkg/manager/diff.go @@ -150,39 +150,39 @@ const ( corpusTriageToMonitor = 0.99 ) -func (dc *diffContext) Loop(baseCtx context.Context) error { - g, ctx := errgroup.WithContext(baseCtx) +func (dc *diffContext) Loop(ctx context.Context) error { + g, groupCtx := errgroup.WithContext(ctx) reproLoop := NewReproLoop(dc, dc.new.pool.Total()-dc.new.cfg.FuzzingVMs, false) if dc.http != nil { dc.http.ReproLoop = reproLoop g.Go(func() error { - return dc.http.Serve(ctx) + return dc.http.Serve(groupCtx) }) } g.Go(func() error { select { - case <-ctx.Done(): + case <-groupCtx.Done(): return nil - case <-dc.waitCorpusTriage(ctx, corpusTriageToRepro): + case <-dc.waitCorpusTriage(groupCtx, corpusTriageToRepro): case <-dc.cfg.TriageDeadline(): log.Logf(0, "timed out waiting for coprus triage") } log.Logf(0, "starting bug reproductions") - reproLoop.Loop(ctx) + reproLoop.Loop(groupCtx) return nil }) - g.Go(func() error { return dc.monitorPatchedCoverage(ctx) }) - g.Go(func() error { return dc.base.Loop(ctx) }) - g.Go(func() error { return dc.new.Loop(ctx) }) + g.Go(func() error { return dc.monitorPatchedCoverage(groupCtx) }) + g.Go(func() error { return dc.base.Loop(groupCtx) }) + g.Go(func() error { return dc.new.Loop(groupCtx) }) runner := &reproRunner{done: make(chan reproRunnerResult, 2), kernel: dc.base} statTimer := time.NewTicker(5 * time.Minute) loop: for { select { - case <-ctx.Done(): + case <-groupCtx.Done(): break loop case <-statTimer.C: vals := make(map[string]int) @@ -193,13 +193,13 @@ loop: log.Logf(0, "STAT %s", data) case rep := <-dc.base.crashes: log.Logf(1, "base crash: %v", rep.Title) - dc.reportBaseCrash(ctx, rep) + dc.reportBaseCrash(groupCtx, rep) case ret := <-runner.done: // We have run the reproducer on the base instance. // A sanity check: the base kernel might have crashed with the same title // since the moment we have stared the reproduction / running on the repro base. - ignored := dc.ignoreCrash(ctx, ret.reproReport.Title) + ignored := dc.ignoreCrash(groupCtx, ret.reproReport.Title) if ret.crashReport == nil && ignored { // Report it as error so that we could at least find it in the logs. log.Errorf("resulting crash of an approved repro result is to be ignored: %s", @@ -207,7 +207,7 @@ loop: } else if ret.crashReport == nil { dc.store.BaseNotCrashed(ret.reproReport.Title) select { - case <-ctx.Done(): + case <-groupCtx.Done(): case dc.patchedOnly <- &UniqueBug{ Report: ret.reproReport, Repro: ret.repro, @@ -226,7 +226,7 @@ loop: }) } } else { - dc.reportBaseCrash(ctx, ret.crashReport) + dc.reportBaseCrash(groupCtx, ret.crashReport) log.Logf(0, "crashes both: %s / %s", ret.reproReport.Title, ret.crashReport.Title) } case ret := <-dc.doneRepro: @@ -239,7 +239,7 @@ loop: log.Logf(1, "found repro for %q (orig title: %q, reliability: %2.f), took %.2f minutes", ret.Repro.Report.Title, origTitle, ret.Repro.Reliability, ret.Stats.TotalTime.Minutes()) g.Go(func() error { - runner.Run(ctx, ret.Repro, ret.Crash.FullRepro) + runner.Run(groupCtx, ret.Repro, ret.Crash.FullRepro) return nil }) } else { @@ -486,27 +486,27 @@ func setup(name string, cfg *mgrconfig.Config, debug bool) (*kernelContext, erro return kernelCtx, nil } -func (kc *kernelContext) Loop(baseCtx context.Context) error { +func (kc *kernelContext) Loop(ctx context.Context) error { defer log.Logf(1, "%s: kernel context loop terminated", kc.name) if err := kc.serv.Listen(); err != nil { return fmt.Errorf("failed to start rpc server: %w", err) } - eg, ctx := errgroup.WithContext(baseCtx) - kc.ctx = ctx + eg, groupCtx := errgroup.WithContext(ctx) + kc.ctx = groupCtx eg.Go(func() error { defer log.Logf(1, "%s: rpc server terminaled", kc.name) - return kc.serv.Serve(ctx) + return kc.serv.Serve(groupCtx) }) eg.Go(func() error { defer log.Logf(1, "%s: pool terminated", kc.name) - kc.pool.Loop(ctx) + kc.pool.Loop(groupCtx) return nil }) eg.Go(func() error { for { select { - case <-ctx.Done(): + case <-groupCtx.Done(): return nil case err := <-kc.pool.BootErrors: title := "unknown" diff --git a/pkg/rpcserver/local.go b/pkg/rpcserver/local.go index c406cb9ed..4a0dd5389 100644 --- a/pkg/rpcserver/local.go +++ b/pkg/rpcserver/local.go @@ -114,35 +114,35 @@ type local struct { setupDone chan bool } -func (ctx *local) MachineChecked(features flatrpc.Feature, syscalls map[*prog.Syscall]bool) (queue.Source, error) { - <-ctx.setupDone - ctx.serv.TriagedCorpus() - return ctx.cfg.MachineChecked(features, syscalls), nil +func (l *local) MachineChecked(features flatrpc.Feature, syscalls map[*prog.Syscall]bool) (queue.Source, error) { + <-l.setupDone + l.serv.TriagedCorpus() + return l.cfg.MachineChecked(features, syscalls), nil } -func (ctx *local) BugFrames() ([]string, []string) { +func (l *local) BugFrames() ([]string, []string) { return nil, nil } -func (ctx *local) MaxSignal() signal.Signal { - return signal.FromRaw(ctx.cfg.MaxSignal, 0) +func (l *local) MaxSignal() signal.Signal { + return signal.FromRaw(l.cfg.MaxSignal, 0) } -func (ctx *local) CoverageFilter(modules []*vminfo.KernelModule) ([]uint64, error) { - return ctx.cfg.CoverFilter, nil +func (l *local) CoverageFilter(modules []*vminfo.KernelModule) ([]uint64, error) { + return l.cfg.CoverFilter, nil } -func (ctx *local) Serve(context context.Context) error { - return ctx.serv.Serve(context) +func (l *local) Serve(ctx context.Context) error { + return l.serv.Serve(ctx) } -func (ctx *local) RunInstance(baseCtx context.Context, id int) error { - connErr := ctx.serv.CreateInstance(id, nil, nil) - defer ctx.serv.ShutdownInstance(id, true) +func (l *local) RunInstance(ctx context.Context, id int) error { + connErr := l.serv.CreateInstance(id, nil, nil) + defer l.serv.ShutdownInstance(id, true) - cfg := ctx.cfg + cfg := l.cfg bin := cfg.Executor - args := []string{"runner", fmt.Sprint(id), "localhost", fmt.Sprint(ctx.serv.Port())} + args := []string{"runner", fmt.Sprint(id), "localhost", fmt.Sprint(l.serv.Port())} if cfg.GDB { bin = "gdb" args = append([]string{ @@ -152,7 +152,7 @@ func (ctx *local) RunInstance(baseCtx context.Context, id int) error { cfg.Executor, }, args...) } - cmd := exec.CommandContext(baseCtx, bin, args...) + cmd := exec.CommandContext(ctx, bin, args...) cmd.Dir = cfg.Dir if cfg.OutputWriter != nil { cmd.Stdout = cfg.OutputWriter @@ -169,7 +169,7 @@ func (ctx *local) RunInstance(baseCtx context.Context, id int) error { } var retErr error select { - case <-baseCtx.Done(): + case <-ctx.Done(): case err := <-connErr: if err != nil { retErr = fmt.Errorf("connection error: %w", err) @@ -181,7 +181,7 @@ func (ctx *local) RunInstance(baseCtx context.Context, id int) error { retErr = fmt.Errorf("executor process exited: %w", err) } // Note that we ignore the error if we killed the process because of the context. - if baseCtx.Err() == nil { + if ctx.Err() == nil { return retErr } return nil diff --git a/pkg/rpcserver/rpcserver.go b/pkg/rpcserver/rpcserver.go index b0ab14c17..04c5d877f 100644 --- a/pkg/rpcserver/rpcserver.go +++ b/pkg/rpcserver/rpcserver.go @@ -408,11 +408,11 @@ func (serv *server) handleMachineInfo(infoReq *flatrpc.InfoRequestRawT) (handsha }, nil } -func (serv *server) connectionLoop(baseCtx context.Context, runner *Runner) error { +func (serv *server) connectionLoop(ctx context.Context, runner *Runner) error { // To "cancel" the runner's loop we need to call runner.Stop(). // At the same time, we don't want to leak the goroutine that monitors it, // so we derive a new context and cancel it on function exit. - ctx, cancel := context.WithCancel(baseCtx) + ctx, cancel := context.WithCancel(ctx) defer cancel() go func() { <-ctx.Done() diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go index 7b3f1517f..716ebbc56 100644 --- a/pkg/runtest/run.go +++ b/pkg/runtest/run.go @@ -73,21 +73,21 @@ type Context struct { buildSem chan bool } -func (ctx *Context) Init() { +func (rt *Context) Init() { // Run usually runs in a separate goroutine concurrently with request consumer (Next calls), // so at least executor needs to be initialized before Run. - ctx.executor = queue.DynamicOrder() - ctx.buildSem = make(chan bool, runtime.GOMAXPROCS(0)) + rt.executor = queue.DynamicOrder() + rt.buildSem = make(chan bool, runtime.GOMAXPROCS(0)) } -func (ctx *Context) log(msg string, args ...any) { - ctx.LogFunc(fmt.Sprintf(msg, args...)) +func (rt *Context) log(msg string, args ...any) { + rt.LogFunc(fmt.Sprintf(msg, args...)) } -func (ctx *Context) Run(waitCtx context.Context) error { - ctx.generatePrograms() +func (rt *Context) Run(ctx context.Context) error { + rt.generatePrograms() var ok, fail, broken, skip int - for _, req := range ctx.requests { + for _, req := range rt.requests { result := "" verbose := false if req.broken != "" { @@ -103,7 +103,7 @@ func (ctx *Context) Run(waitCtx context.Context) error { result = fmt.Sprintf("SKIP (%v)", req.skip) verbose = true } else { - req.Request.Wait(waitCtx) + req.Request.Wait(ctx) if req.err != nil { fail++ result = fmt.Sprintf("FAIL: %v", @@ -117,25 +117,25 @@ func (ctx *Context) Run(waitCtx context.Context) error { result = "OK" } } - if !verbose || ctx.Verbose { - ctx.log("%-38v: %v", req.name, result) + if !verbose || rt.Verbose { + rt.log("%-38v: %v", req.name, result) } if req.Request != nil && req.Type == flatrpc.RequestTypeBinary && req.BinaryFile != "" { os.Remove(req.BinaryFile) } } - ctx.log("ok: %v, broken: %v, skip: %v, fail: %v", ok, broken, skip, fail) + rt.log("ok: %v, broken: %v, skip: %v, fail: %v", ok, broken, skip, fail) if fail != 0 { return fmt.Errorf("tests failed") } return nil } -func (ctx *Context) Next() *queue.Request { - return ctx.executor.Next() +func (rt *Context) Next() *queue.Request { + return rt.executor.Next() } -func (ctx *Context) onDone(req *runRequest, res *queue.Result) bool { +func (rt *Context) onDone(req *runRequest, res *queue.Result) bool { // The tests depend on timings and may be flaky, esp on overloaded/slow machines. // We don't want to fix this by significantly bumping all timeouts, // because if a program fails all the time with the default timeouts, @@ -163,37 +163,37 @@ func (ctx *Context) onDone(req *runRequest, res *queue.Result) bool { } // We need at least `failed - ok + 1` more runs <=> `failed + ok + need` in total, // which simplifies to `failed * 2 + 1`. - retries := ctx.Retries + retries := rt.Retries if retries%2 == 0 { retries++ } if req.failed*2+1 <= retries { // We can still retry the execution. - ctx.submit(req) + rt.submit(req) return false } // Give up and fail on this request. return true } -func (ctx *Context) generatePrograms() error { +func (rt *Context) generatePrograms() error { cover := []bool{false} - if ctx.Features&flatrpc.FeatureCoverage != 0 { + if rt.Features&flatrpc.FeatureCoverage != 0 { cover = append(cover, true) } var sandboxes []string - for sandbox := range ctx.EnabledCalls { + for sandbox := range rt.EnabledCalls { sandboxes = append(sandboxes, sandbox) } sort.Strings(sandboxes) - files, err := progFileList(ctx.Dir, ctx.Tests) + files, err := progFileList(rt.Dir, rt.Tests) if err != nil { return err } for _, file := range files { - if err := ctx.generateFile(sandboxes, cover, file); err != nil { + if err := rt.generateFile(sandboxes, cover, file); err != nil { // Treat invalid programs as failing. - ctx.createTest(&runRequest{ + rt.createTest(&runRequest{ name: file, failing: err.Error(), }) @@ -220,21 +220,21 @@ func progFileList(dir, filter string) ([]string, error) { return res, nil } -func (ctx *Context) generateFile(sandboxes []string, cover []bool, filename string) error { - p, requires, results, err := parseProg(ctx.Target, ctx.Dir, filename, nil) +func (rt *Context) generateFile(sandboxes []string, cover []bool, filename string) error { + p, requires, results, err := parseProg(rt.Target, rt.Dir, filename, nil) if err != nil { return err } if p == nil { return nil } - sysTarget := targets.Get(ctx.Target.OS, ctx.Target.Arch) + sysTarget := targets.Get(rt.Target.OS, rt.Target.Arch) nextSandbox: for _, sandbox := range sandboxes { name := fmt.Sprintf("%v %v", filename, sandbox) for _, call := range p.Calls { - if !ctx.EnabledCalls[sandbox][call.Meta] { - ctx.createTest(&runRequest{ + if !rt.EnabledCalls[sandbox][call.Meta] { + rt.createTest(&runRequest{ name: name, skip: fmt.Sprintf("unsupported call %v", call.Meta.Name), }) @@ -242,10 +242,10 @@ nextSandbox: } } properties := map[string]bool{ - "manual": ctx.Tests != "", // "manual" tests run only if selected by the filter explicitly. - "sandbox=" + sandbox: true, - "bigendian": sysTarget.BigEndian, - "arch=" + ctx.Target.Arch: true, + "manual": rt.Tests != "", // "manual" tests run only if selected by the filter explicitly. + "sandbox=" + sandbox: true, + "bigendian": sysTarget.BigEndian, + "arch=" + rt.Target.Arch: true, } for _, threaded := range []bool{false, true} { if threaded { @@ -271,11 +271,11 @@ nextSandbox: properties["cover"] = cov properties["C"] = false properties["executor"] = true - req, err := ctx.createSyzTest(p, sandbox, threaded, cov) + req, err := rt.createSyzTest(p, sandbox, threaded, cov) if err != nil { return err } - ctx.produceTest(req, name, properties, requires, results) + rt.produceTest(req, name, properties, requires, results) } if sysTarget.HostFuzzer { // For HostFuzzer mode, we need to cross-compile @@ -287,17 +287,17 @@ nextSandbox: name += " C" if !sysTarget.ExecutorUsesForkServer && times > 1 { // Non-fork loop implementation does not support repetition. - ctx.createTest(&runRequest{ + rt.createTest(&runRequest{ name: name, broken: "non-forking loop", }) continue } - req, err := ctx.createCTest(p, sandbox, threaded, times) + req, err := rt.createCTest(p, sandbox, threaded, times) if err != nil { return err } - ctx.produceTest(req, name, properties, requires, results) + rt.produceTest(req, name, properties, requires, results) } } } @@ -368,37 +368,37 @@ func parseProg(target *prog.Target, dir, filename string, requires map[string]bo return p, properties, info, nil } -func (ctx *Context) produceTest(req *runRequest, name string, properties, +func (rt *Context) produceTest(req *runRequest, name string, properties, requires map[string]bool, results *flatrpc.ProgInfo) { req.name = name req.results = results if !manager.MatchRequirements(properties, requires) { req.skip = "excluded by constraints" } - ctx.createTest(req) + rt.createTest(req) } -func (ctx *Context) createTest(req *runRequest) { - req.executor = ctx.executor.Append() - ctx.requests = append(ctx.requests, req) +func (rt *Context) createTest(req *runRequest) { + req.executor = rt.executor.Append() + rt.requests = append(rt.requests, req) if req.skip != "" || req.broken != "" || req.failing != "" { return } if req.sourceOpts == nil { - ctx.submit(req) + rt.submit(req) return } go func() { - ctx.buildSem <- true + rt.buildSem <- true defer func() { - <-ctx.buildSem + <-rt.buildSem }() src, err := csource.Write(req.Prog, *req.sourceOpts) if err != nil { req.err = fmt.Errorf("failed to create C source: %w", err) req.Request.Done(&queue.Result{}) } - bin, err := csource.Build(ctx.Target, src) + bin, err := csource.Build(rt.Target, src) if err != nil { req.err = fmt.Errorf("failed to build C program: %w", err) req.Request.Done(&queue.Result{}) @@ -406,18 +406,18 @@ func (ctx *Context) createTest(req *runRequest) { } req.Type = flatrpc.RequestTypeBinary req.BinaryFile = bin - ctx.submit(req) + rt.submit(req) }() } -func (ctx *Context) submit(req *runRequest) { +func (rt *Context) submit(req *runRequest) { req.OnDone(func(_ *queue.Request, res *queue.Result) bool { - return ctx.onDone(req, res) + return rt.onDone(req, res) }) req.executor.Submit(req.Request) } -func (ctx *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bool) (*runRequest, error) { +func (rt *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bool) (*runRequest, error) { var opts flatrpc.ExecOpts sandboxFlags, err := flatrpc.SandboxToFlags(sandbox) if err != nil { @@ -432,8 +432,8 @@ func (ctx *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bo opts.ExecFlags |= flatrpc.ExecFlagCollectSignal opts.ExecFlags |= flatrpc.ExecFlagCollectCover } - opts.EnvFlags |= csource.FeaturesToFlags(ctx.Features, nil) - if ctx.Debug { + opts.EnvFlags |= csource.FeaturesToFlags(rt.Features, nil) + if rt.Debug { opts.EnvFlags |= flatrpc.ExecEnvDebug } req := &runRequest{ @@ -445,7 +445,7 @@ func (ctx *Context) createSyzTest(p *prog.Prog, sandbox string, threaded, cov bo return req, nil } -func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, times int) (*runRequest, error) { +func (rt *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, times int) (*runRequest, error) { opts := csource.Options{ Threaded: threaded, Repeat: times > 1, @@ -457,22 +457,22 @@ func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, tim HandleSegv: true, Cgroups: p.Target.OS == targets.Linux && sandbox != "", Trace: true, - Swap: ctx.Features&flatrpc.FeatureSwap != 0, + Swap: rt.Features&flatrpc.FeatureSwap != 0, } if sandbox != "" { - if ctx.Features&flatrpc.FeatureNetInjection != 0 { + if rt.Features&flatrpc.FeatureNetInjection != 0 { opts.NetInjection = true } - if ctx.Features&flatrpc.FeatureNetDevices != 0 { + if rt.Features&flatrpc.FeatureNetDevices != 0 { opts.NetDevices = true } - if ctx.Features&flatrpc.FeatureVhciInjection != 0 { + if rt.Features&flatrpc.FeatureVhciInjection != 0 { opts.VhciInjection = true } - if ctx.Features&flatrpc.FeatureWifiEmulation != 0 { + if rt.Features&flatrpc.FeatureWifiEmulation != 0 { opts.Wifi = true } - if ctx.Features&flatrpc.FeatureLRWPANEmulation != 0 { + if rt.Features&flatrpc.FeatureLRWPANEmulation != 0 { opts.IEEE802154 = true } } -- cgit mrf-deployment