diff options
33 files changed, 292 insertions, 340 deletions
diff --git a/pkg/corpus/corpus.go b/pkg/corpus/corpus.go index 46e388366..5b2b9983f 100644 --- a/pkg/corpus/corpus.go +++ b/pkg/corpus/corpus.go @@ -53,7 +53,7 @@ func NewMonitoredCorpus(ctx context.Context, updates chan<- NewItemEvent) *Corpu // sysalls. In that case, there will be several ItemUpdate entities. type ItemUpdate struct { Call int - RawCover []uint32 + RawCover []uint64 } // Item objects are to be treated as immutable, otherwise it's just @@ -66,7 +66,7 @@ type Item struct { ProgData []byte // to save some Serialize() calls HasAny bool // whether the prog contains squashed arguments Signal signal.Signal - Cover []uint32 + Cover []uint64 Updates []ItemUpdate } @@ -78,15 +78,15 @@ type NewInput struct { Prog *prog.Prog Call int Signal signal.Signal - Cover []uint32 - RawCover []uint32 + Cover []uint64 + RawCover []uint64 } type NewItemEvent struct { Sig string Exists bool ProgData []byte - NewCover []uint32 + NewCover []uint64 } func (corpus *Corpus) Save(inp NewInput) { diff --git a/pkg/corpus/corpus_test.go b/pkg/corpus/corpus_test.go index 62aad1e04..90b11717a 100644 --- a/pkg/corpus/corpus_test.go +++ b/pkg/corpus/corpus_test.go @@ -62,16 +62,16 @@ func TestCorpusCoverage(t *testing.T) { rs := rand.NewSource(0) inp := generateInput(target, rs, 5, 5) - inp.Cover = []uint32{10, 11} + inp.Cover = []uint64{10, 11} go corpus.Save(inp) event := <-ch - assert.Equal(t, []uint32{10, 11}, event.NewCover) + assert.Equal(t, []uint64{10, 11}, event.NewCover) inp.Call = 1 - inp.Cover = []uint32{11, 12} + inp.Cover = []uint64{11, 12} go corpus.Save(inp) event = <-ch - assert.Equal(t, []uint32{12}, event.NewCover) + assert.Equal(t, []uint64{12}, event.NewCover) // Check the total corpus size. assert.Equal(t, corpus.StatCover.Val(), 3) @@ -101,9 +101,9 @@ func TestCorpusSaveConcurrency(t *testing.T) { func generateInput(target *prog.Target, rs rand.Source, ncalls, sizeSig int) NewInput { p := target.Generate(rs, ncalls, target.DefaultChoiceTable()) - var raw []uint32 + var raw []uint64 for i := 1; i <= sizeSig; i++ { - raw = append(raw, uint32(i)) + raw = append(raw, uint64(i)) } return NewInput{ Prog: p, diff --git a/pkg/cover/backend/backend.go b/pkg/cover/backend/backend.go index 78e90b6c0..5aa6a221c 100644 --- a/pkg/cover/backend/backend.go +++ b/pkg/cover/backend/backend.go @@ -14,7 +14,7 @@ type Impl struct { Symbols []*Symbol Frames []Frame Symbolize func(pcs map[*Module][]uint64) ([]Frame, error) - RestorePC func(pc uint32) uint64 + RestorePC func(pc uint64) uint64 CallbackPoints []uint64 PreciseCoverage bool } diff --git a/pkg/cover/backend/dwarf.go b/pkg/cover/backend/dwarf.go index 9cad576be..3f64cf752 100644 --- a/pkg/cover/backend/dwarf.go +++ b/pkg/cover/backend/dwarf.go @@ -152,7 +152,6 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) { var allSymbols []*Symbol var allRanges []pcRange var allUnits []*CompileUnit - var pcBase uint64 preciseCoverage := true for _, module := range modules { errc := make(chan error, 1) @@ -169,9 +168,6 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) { return } allSymbols = append(allSymbols, result.Symbols...) - if module.Name == "" { - pcBase = info.textAddr - } allCoverPoints[0] = append(allCoverPoints[0], result.CoverPoints[0]...) allCoverPoints[1] = append(allCoverPoints[1], result.CoverPoints[1]...) if module.Name == "" && len(result.CoverPoints[0]) == 0 { @@ -220,10 +216,6 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) { if len(allSymbols) == 0 || len(allUnits) == 0 { return nil, fmt.Errorf("failed to parse DWARF (set CONFIG_DEBUG_INFO=y on linux)") } - if target.OS == targets.FreeBSD { - // On FreeBSD .text address in ELF is 0, but .text is actually mapped at 0xffffffff. - pcBase = ^uint64(0) - } var interner symbolizer.Interner impl := &Impl{ Units: allUnits, @@ -231,16 +223,16 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) { Symbolize: func(pcs map[*Module][]uint64) ([]Frame, error) { return symbolize(target, &interner, objDir, srcDir, buildDir, splitBuildDelimiters, pcs) }, - RestorePC: makeRestorePC(params, pcBase), + RestorePC: makeRestorePC(params), CallbackPoints: allCoverPoints[0], PreciseCoverage: preciseCoverage, } return impl, nil } -func makeRestorePC(params *dwarfParams, pcBase uint64) func(pc uint32) uint64 { - return func(pcLow uint32) uint64 { - return PreviousInstructionPC(params.target, RestorePC(pcLow, uint32(pcBase>>32))) +func makeRestorePC(params *dwarfParams) func(pc uint64) uint64 { + return func(pc uint64) uint64 { + return PreviousInstructionPC(params.target, pc) } } diff --git a/pkg/cover/backend/gvisor.go b/pkg/cover/backend/gvisor.go index 2e662f4bd..65a3da9a2 100644 --- a/pkg/cover/backend/gvisor.go +++ b/pkg/cover/backend/gvisor.go @@ -48,8 +48,8 @@ func makeGvisor(target *targets.Target, objDir, srcDir, buildDir string, modules impl := &Impl{ Units: units, Frames: frames, - RestorePC: func(pc uint32) uint64 { - return uint64(pc) + RestorePC: func(pc uint64) uint64 { + return pc }, } return impl, nil diff --git a/pkg/cover/backend/pc.go b/pkg/cover/backend/pc.go index 78bb380a6..10462c243 100644 --- a/pkg/cover/backend/pc.go +++ b/pkg/cover/backend/pc.go @@ -9,10 +9,6 @@ import ( "github.com/google/syzkaller/sys/targets" ) -func RestorePC(pc, base uint32) uint64 { - return uint64(base)<<32 + uint64(pc) -} - func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 { offset := instructionLen(target.Arch) pc -= offset diff --git a/pkg/cover/canonicalizer.go b/pkg/cover/canonicalizer.go index 3c21c0947..7241a7478 100644 --- a/pkg/cover/canonicalizer.go +++ b/pkg/cover/canonicalizer.go @@ -15,7 +15,7 @@ type Canonicalizer struct { modules map[string]KernelModule // Contains a sorted list of the canonical module addresses. - moduleKeys []uint32 + moduleKeys []uint64 } type CanonicalizerInstance struct { @@ -28,20 +28,20 @@ type CanonicalizerInstance struct { // Contains the current conversion maps used. type Convert struct { - conversionHash map[uint32]*canonicalizerModule - moduleKeys []uint32 + conversionHash map[uint64]*canonicalizerModule + moduleKeys []uint64 } type convertContext struct { errCount int - errPC uint32 + errPC uint64 convert *Convert } // Contains the offset and final address of each module. type canonicalizerModule struct { offset int - endAddr uint32 + endAddr uint64 // Discard coverage from current module. // Set to true if module is not present in canonical. discard bool @@ -59,7 +59,7 @@ func NewCanonicalizer(modules []KernelModule, flagSignal bool) *Canonicalizer { } // Store sorted canonical address keys. - canonicalModuleKeys := make([]uint32, len(modules)) + canonicalModuleKeys := make([]uint64, len(modules)) setModuleKeys(canonicalModuleKeys, modules) return &Canonicalizer{ modules: canonicalModules, @@ -72,35 +72,35 @@ func (can *Canonicalizer) NewInstance(modules []KernelModule) *CanonicalizerInst return &CanonicalizerInstance{} } // Save sorted list of module offsets. - moduleKeys := make([]uint32, len(modules)) + moduleKeys := make([]uint64, len(modules)) setModuleKeys(moduleKeys, modules) // Create a hash between the "canonical" module addresses and each VM instance. - instToCanonicalMap := make(map[uint32]*canonicalizerModule) - canonicalToInstMap := make(map[uint32]*canonicalizerModule) + instToCanonicalMap := make(map[uint64]*canonicalizerModule) + canonicalToInstMap := make(map[uint64]*canonicalizerModule) for _, module := range modules { discard := false - canonicalAddr := uint32(0) + canonicalAddr := uint64(0) canonicalModule, found := can.modules[module.Name] if !found || canonicalModule.Size != module.Size { log.Errorf("kernel build has changed; instance module %v differs from canonical", module.Name) discard = true } if found { - canonicalAddr = uint32(canonicalModule.Addr) + canonicalAddr = canonicalModule.Addr } - instAddr := uint32(module.Addr) + instAddr := module.Addr canonicalToInstMap[canonicalAddr] = &canonicalizerModule{ offset: int(instAddr) - int(canonicalAddr), - endAddr: uint32(module.Size) + canonicalAddr, + endAddr: module.Size + canonicalAddr, discard: discard, } instToCanonicalMap[instAddr] = &canonicalizerModule{ offset: int(canonicalAddr) - int(instAddr), - endAddr: uint32(module.Size) + instAddr, + endAddr: module.Size + instAddr, discard: discard, } } @@ -118,26 +118,26 @@ func (can *Canonicalizer) NewInstance(modules []KernelModule) *CanonicalizerInst } } -func (ci *CanonicalizerInstance) Canonicalize(elems []uint32) []uint32 { +func (ci *CanonicalizerInstance) Canonicalize(elems []uint64) []uint64 { if ci.canonical.moduleKeys == nil { return elems } return ci.canonicalize.convertPCs(elems) } -func (ci *CanonicalizerInstance) Decanonicalize(elems []uint32) []uint32 { +func (ci *CanonicalizerInstance) Decanonicalize(elems []uint64) []uint64 { if ci.canonical.moduleKeys == nil { return elems } return ci.decanonicalize.convertPCs(elems) } -func (ci *CanonicalizerInstance) DecanonicalizeFilter(bitmap map[uint32]uint32) map[uint32]uint32 { +func (ci *CanonicalizerInstance) DecanonicalizeFilter(bitmap map[uint64]uint32) map[uint64]uint32 { // Skip conversion if modules or filter are not used. if ci.canonical.moduleKeys == nil || len(bitmap) == 0 { return bitmap } - instBitmap := make(map[uint32]uint32) + instBitmap := make(map[uint64]uint32) convCtx := &convertContext{convert: ci.decanonicalize} for pc, val := range bitmap { if newPC, ok := ci.decanonicalize.convertPC(pc); ok { @@ -153,18 +153,16 @@ func (ci *CanonicalizerInstance) DecanonicalizeFilter(bitmap map[uint32]uint32) } // Store sorted list of addresses. Used to binary search when converting PCs. -func setModuleKeys(moduleKeys []uint32, modules []KernelModule) { +func setModuleKeys(moduleKeys []uint64, modules []KernelModule) { for idx, module := range modules { - // Truncate PCs to uint32, assuming that they fit into 32 bits. - // True for x86_64 and arm64 without KASLR. - moduleKeys[idx] = uint32(module.Addr) + moduleKeys[idx] = module.Addr } // Sort modules by address. sort.Slice(moduleKeys, func(i, j int) bool { return moduleKeys[i] < moduleKeys[j] }) } -func findModule(pc uint32, moduleKeys []uint32) (moduleIdx int) { +func findModule(pc uint64, moduleKeys []uint64) (moduleIdx int) { moduleIdx, _ = sort.Find(len(moduleKeys), func(moduleIdx int) int { if pc < moduleKeys[moduleIdx] { return -1 @@ -175,9 +173,9 @@ func findModule(pc uint32, moduleKeys []uint32) (moduleIdx int) { return moduleIdx - 1 } -func (convert *Convert) convertPCs(pcs []uint32) []uint32 { +func (convert *Convert) convertPCs(pcs []uint64) []uint64 { // Convert coverage. - var ret []uint32 + var ret []uint64 convCtx := &convertContext{convert: convert} for _, pc := range pcs { if newPC, ok := convert.convertPC(pc); ok { @@ -192,7 +190,7 @@ func (convert *Convert) convertPCs(pcs []uint32) []uint32 { return ret } -func (convert *Convert) convertPC(pc uint32) (uint32, bool) { +func (convert *Convert) convertPC(pc uint64) (uint64, bool) { moduleIdx := findModule(pc, convert.moduleKeys) // Check if address is above the first module offset. if moduleIdx >= 0 { @@ -205,7 +203,7 @@ func (convert *Convert) convertPC(pc uint32) (uint32, bool) { if module.discard { return pc, false } - pc = uint32(int(pc) + module.offset) + pc = uint64(int(pc) + module.offset) } } return pc, true @@ -219,7 +217,7 @@ func (cc *convertContext) discarded() string { return fmt.Sprintf("%v; not found in module map", errMsg) } -func (cc *convertContext) discard(pc uint32) { +func (cc *convertContext) discard(pc uint64) { cc.errCount += 1 if cc.errPC == 0 { cc.errPC = pc diff --git a/pkg/cover/canonicalizer_test.go b/pkg/cover/canonicalizer_test.go index b826008be..1619a08fa 100644 --- a/pkg/cover/canonicalizer_test.go +++ b/pkg/cover/canonicalizer_test.go @@ -20,12 +20,12 @@ type RPCServer struct { type Fuzzer struct { instModules *CanonicalizerInstance - cov []uint32 - goalCov []uint32 - bitmap map[uint32]uint32 - goalBitmap map[uint32]uint32 - sign []uint32 - goalSign []uint32 + cov []uint64 + goalCov []uint64 + bitmap map[uint64]uint32 + goalBitmap map[uint64]uint32 + sign []uint64 + goalSign []uint64 } type canonicalizeValue int @@ -43,31 +43,31 @@ func TestNilModules(t *testing.T) { serv.connect("f1", nil, true) serv.connect("f2", nil, true) - serv.fuzzers["f1"].cov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} - serv.fuzzers["f1"].goalCov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f1"].cov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f1"].goalCov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} - serv.fuzzers["f2"].cov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f2"].cov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} - serv.fuzzers["f1"].bitmap = map[uint32]uint32{ + serv.fuzzers["f1"].bitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f1"].goalBitmap = map[uint32]uint32{ + serv.fuzzers["f1"].goalBitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f2"].bitmap = map[uint32]uint32{ + serv.fuzzers["f2"].bitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f2"].goalBitmap = map[uint32]uint32{ + serv.fuzzers["f2"].goalBitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, @@ -78,9 +78,9 @@ func TestNilModules(t *testing.T) { t.Fatalf("failed in canonicalization: %v", err) } - serv.fuzzers["f1"].goalCov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f1"].goalCov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} serv.fuzzers["f1"].goalSign = serv.fuzzers["f1"].goalCov - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} serv.fuzzers["f2"].goalSign = serv.fuzzers["f2"].goalCov if err := serv.runTest(Decanonicalize); err != "" { t.Fatalf("failed in decanonicalization: %v", err) @@ -103,7 +103,7 @@ func TestDisabledSignals(t *testing.T) { f2Modules := initModules(f2ModuleAddresses, f2ModuleSizes) serv.connect("f2", f2Modules, false) - pcs := []uint32{0x00010000, 0x00020000, 0x00030000, 0x00040000} + pcs := []uint64{0x00010000, 0x00020000, 0x00030000, 0x00040000} serv.fuzzers["f1"].cov = pcs serv.fuzzers["f1"].goalCov = pcs @@ -140,37 +140,37 @@ func TestModules(t *testing.T) { // f1 is the "canonical" fuzzer as it is first one instantiated. // This means that all coverage output should be the same as the inputs. - serv.fuzzers["f1"].cov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, + serv.fuzzers["f1"].cov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, 0x00035000, 0x00040000, 0x00045000, 0x00050000, 0x00055000} - serv.fuzzers["f1"].goalCov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, + serv.fuzzers["f1"].goalCov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, 0x00035000, 0x00040000, 0x00045000, 0x00050000, 0x00055000} // The modules addresss are inverted between: (2 and 4), (3 and 5), // affecting the output canonical coverage values in these ranges. - serv.fuzzers["f2"].cov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, + serv.fuzzers["f2"].cov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, 0x00035000, 0x00040000, 0x00045000, 0x00050000, 0x00055000} - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00015000, 0x00040000, 0x00025000, 0x00045000, + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00015000, 0x00040000, 0x00025000, 0x00045000, 0x0004a000, 0x00020000, 0x00030000, 0x0003b000, 0x00055000} - serv.fuzzers["f1"].bitmap = map[uint32]uint32{ + serv.fuzzers["f1"].bitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f1"].goalBitmap = map[uint32]uint32{ + serv.fuzzers["f1"].goalBitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f2"].bitmap = map[uint32]uint32{ + serv.fuzzers["f2"].bitmap = map[uint64]uint32{ 0x00010011: 1, 0x00020FFF: 2, 0x00030000: 3, 0x00040000: 4, } - serv.fuzzers["f2"].goalBitmap = map[uint32]uint32{ + serv.fuzzers["f2"].goalBitmap = map[uint64]uint32{ 0x00010011: 1, 0x00040FFF: 2, 0x00045000: 3, @@ -181,9 +181,9 @@ func TestModules(t *testing.T) { t.Fatalf("failed in canonicalization: %v", err) } - serv.fuzzers["f1"].goalCov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, + serv.fuzzers["f1"].goalCov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, 0x00035000, 0x00040000, 0x00045000, 0x00050000, 0x00055000} - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000, 0x00030000, 0x00035000, 0x00040000, 0x00045000, 0x00050000, 0x00055000} if err := serv.runTest(Decanonicalize); err != "" { t.Fatalf("failed in decanonicalization: %v", err) @@ -209,21 +209,21 @@ func TestChangingModules(t *testing.T) { // Module 2 is not present in the "canonical" fuzzer, so coverage values // in this range should be deleted. - serv.fuzzers["f2"].cov = []uint32{0x00010000, 0x00015000, 0x00020000, 0x00025000} - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00015000, 0x00025000} + serv.fuzzers["f2"].cov = []uint64{0x00010000, 0x00015000, 0x00020000, 0x00025000} + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00015000, 0x00025000} if err := serv.runTest(Canonicalize); err != "" { t.Fatalf("failed in canonicalization: %v", err) } - serv.fuzzers["f2"].goalCov = []uint32{0x00010000, 0x00015000, 0x00025000} + serv.fuzzers["f2"].goalCov = []uint64{0x00010000, 0x00015000, 0x00025000} if err := serv.runTest(Decanonicalize); err != "" { t.Fatalf("failed in decanonicalization: %v", err) } } func (serv *RPCServer) runTest(val canonicalizeValue) string { - var cov []uint32 + var cov []uint64 for name, fuzzer := range serv.fuzzers { if val == Canonicalize { cov = fuzzer.instModules.Canonicalize(fuzzer.cov) diff --git a/pkg/cover/cover.go b/pkg/cover/cover.go index 814ae4fb6..d863dcde6 100644 --- a/pkg/cover/cover.go +++ b/pkg/cover/cover.go @@ -4,9 +4,9 @@ // Package cover provides types for working with coverage information (arrays of covered PCs). package cover -type Cover map[uint32]struct{} +type Cover map[uint64]struct{} -func (cov *Cover) Merge(raw []uint32) { +func (cov *Cover) Merge(raw []uint64) { c := *cov if c == nil { c = make(Cover) @@ -18,7 +18,7 @@ func (cov *Cover) Merge(raw []uint32) { } // Merge merges raw into coverage and returns newly added PCs. Overwrites/mutates raw. -func (cov *Cover) MergeDiff(raw []uint32) []uint32 { +func (cov *Cover) MergeDiff(raw []uint64) []uint64 { c := *cov if c == nil { c = make(Cover) @@ -36,8 +36,8 @@ func (cov *Cover) MergeDiff(raw []uint32) []uint32 { return raw[:n] } -func (cov Cover) Serialize() []uint32 { - res := make([]uint32, 0, len(cov)) +func (cov Cover) Serialize() []uint64 { + res := make([]uint64, 0, len(cov)) for pc := range cov { res = append(res, pc) } diff --git a/pkg/cover/cover_test.go b/pkg/cover/cover_test.go index d5f214ff5..169dbf08c 100644 --- a/pkg/cover/cover_test.go +++ b/pkg/cover/cover_test.go @@ -14,35 +14,35 @@ import ( func TestMergeDiff(t *testing.T) { type Test struct { - init []uint32 - merge []uint32 - diff []uint32 - result []uint32 + init []uint64 + merge []uint64 + diff []uint64 + result []uint64 } tests := []Test{ { init: nil, merge: nil, diff: nil, - result: []uint32{}, + result: []uint64{}, }, { - init: []uint32{0, 1, 3, 4}, + init: []uint64{0, 1, 3, 4}, merge: nil, diff: nil, - result: []uint32{0, 1, 3, 4}, + result: []uint64{0, 1, 3, 4}, }, { init: nil, - merge: []uint32{0, 1, 3, 4}, - diff: []uint32{0, 1, 3, 4}, - result: []uint32{0, 1, 3, 4}, + merge: []uint64{0, 1, 3, 4}, + diff: []uint64{0, 1, 3, 4}, + result: []uint64{0, 1, 3, 4}, }, { - init: []uint32{0, 1, 3, 4}, - merge: []uint32{4, 7, 1, 9}, - diff: []uint32{7, 9}, - result: []uint32{0, 1, 3, 4, 7, 9}, + init: []uint64{0, 1, 3, 4}, + merge: []uint64{4, 7, 1, 9}, + diff: []uint64{7, 9}, + result: []uint64{0, 1, 3, 4, 7, 9}, }, } for i, test := range tests { diff --git a/pkg/cover/html.go b/pkg/cover/html.go index 5a78b75f8..935a19efc 100644 --- a/pkg/cover/html.go +++ b/pkg/cover/html.go @@ -25,7 +25,7 @@ import ( type CoverHandlerParams struct { Progs []Prog - CoverFilter map[uint32]uint32 + CoverFilter map[uint64]uint32 Debug bool Force bool } @@ -297,7 +297,7 @@ func (rg *ReportGenerator) DoFilterPCs(w io.Writer, params CoverHandlerParams) e continue } uniquePCs[pc] = true - if params.CoverFilter[uint32(pc)] != 0 { + if params.CoverFilter[pc] != 0 { pcs = append(pcs, pc) } } @@ -620,12 +620,12 @@ func (rg *ReportGenerator) DoCSV(w io.Writer, params CoverHandlerParams) error { return writer.WriteAll(data) } -func fixUpPCs(target string, progs []Prog, coverFilter map[uint32]uint32) []Prog { +func fixUpPCs(target string, progs []Prog, coverFilter map[uint64]uint32) []Prog { if coverFilter != nil { for i, prog := range progs { var nPCs []uint64 for _, pc := range prog.PCs { - if coverFilter[uint32(pc)] != 0 { + if coverFilter[pc] != 0 { nPCs = append(nPCs, pc) } } diff --git a/pkg/cover/report.go b/pkg/cover/report.go index b0113ca14..06c1e13f5 100644 --- a/pkg/cover/report.go +++ b/pkg/cover/report.go @@ -30,8 +30,6 @@ type Prog struct { type KernelModule = backend.KernelModule -var RestorePC = backend.RestorePC - func MakeReportGenerator(cfg *mgrconfig.Config, subsystem []mgrconfig.Subsystem, modules []KernelModule, rawCover bool) (*ReportGenerator, error) { impl, err := backend.Make(cfg.SysTarget, cfg.Type, cfg.KernelObj, diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs index c628d9b53..cdddef965 100644 --- a/pkg/flatrpc/flatrpc.fbs +++ b/pkg/flatrpc/flatrpc.fbs @@ -149,15 +149,15 @@ table ExecRequestRaw { prog_data :[uint8]; exec_opts :ExecOptsRaw; flags :RequestFlag; - signal_filter :[uint32]; + signal_filter :[uint64]; signal_filter_call :int32; // Repeat the program that many times (0 means 1). repeat :int32; } table SignalUpdateRaw { - new_max :[uint32]; - drop_max :[uint32]; + new_max :[uint64]; + drop_max :[uint64]; } // Notification from the executor that it started executing the program 'id'. @@ -184,10 +184,10 @@ table CallInfoRaw { // Call errno (0 if the call was successful). error :int32; // Feedback signal, filled if ExecFlag.CollectSignal is set. - signal :[uint32]; + signal :[uint64]; // Code coverage, filled if ExecFlag.CollectCover is set. // If ExecFlag.DedupCover is set, then duplicates are removed, otherwise it contains a trace. - cover :[uint32]; + cover :[uint64]; // Comparison operands. comps :[ComparisonRaw]; } diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go index 12e9a773d..2ef9b2595 100644 --- a/pkg/flatrpc/flatrpc.go +++ b/pkg/flatrpc/flatrpc.go @@ -1688,7 +1688,7 @@ type ExecRequestRawT struct { ProgData []byte `json:"prog_data"` ExecOpts *ExecOptsRawT `json:"exec_opts"` Flags RequestFlag `json:"flags"` - SignalFilter []uint32 `json:"signal_filter"` + SignalFilter []uint64 `json:"signal_filter"` SignalFilterCall int32 `json:"signal_filter_call"` Repeat int32 `json:"repeat"` } @@ -1706,7 +1706,7 @@ func (t *ExecRequestRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffset signalFilterLength := len(t.SignalFilter) ExecRequestRawStartSignalFilterVector(builder, signalFilterLength) for j := signalFilterLength - 1; j >= 0; j-- { - builder.PrependUint32(t.SignalFilter[j]) + builder.PrependUint64(t.SignalFilter[j]) } signalFilterOffset = builder.EndVector(signalFilterLength) } @@ -1728,7 +1728,7 @@ func (rcv *ExecRequestRaw) UnPackTo(t *ExecRequestRawT) { t.ExecOpts = rcv.ExecOpts(nil).UnPack() t.Flags = rcv.Flags() signalFilterLength := rcv.SignalFilterLength() - t.SignalFilter = make([]uint32, signalFilterLength) + t.SignalFilter = make([]uint64, signalFilterLength) for j := 0; j < signalFilterLength; j++ { t.SignalFilter[j] = rcv.SignalFilter(j) } @@ -1843,11 +1843,11 @@ func (rcv *ExecRequestRaw) MutateFlags(n RequestFlag) bool { return rcv._tab.MutateUint64Slot(10, uint64(n)) } -func (rcv *ExecRequestRaw) SignalFilter(j int) uint32 { +func (rcv *ExecRequestRaw) SignalFilter(j int) uint64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) } return 0 } @@ -1860,11 +1860,11 @@ func (rcv *ExecRequestRaw) SignalFilterLength() int { return 0 } -func (rcv *ExecRequestRaw) MutateSignalFilter(j int, n uint32) bool { +func (rcv *ExecRequestRaw) MutateSignalFilter(j int, n uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) } return false } @@ -1915,7 +1915,7 @@ func ExecRequestRawAddSignalFilter(builder *flatbuffers.Builder, signalFilter fl builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(signalFilter), 0) } func ExecRequestRawStartSignalFilterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) + return builder.StartVector(8, numElems, 8) } func ExecRequestRawAddSignalFilterCall(builder *flatbuffers.Builder, signalFilterCall int32) { builder.PrependInt32Slot(5, signalFilterCall, 0) @@ -1928,8 +1928,8 @@ func ExecRequestRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { } type SignalUpdateRawT struct { - NewMax []uint32 `json:"new_max"` - DropMax []uint32 `json:"drop_max"` + NewMax []uint64 `json:"new_max"` + DropMax []uint64 `json:"drop_max"` } func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { @@ -1941,7 +1941,7 @@ func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse newMaxLength := len(t.NewMax) SignalUpdateRawStartNewMaxVector(builder, newMaxLength) for j := newMaxLength - 1; j >= 0; j-- { - builder.PrependUint32(t.NewMax[j]) + builder.PrependUint64(t.NewMax[j]) } newMaxOffset = builder.EndVector(newMaxLength) } @@ -1950,7 +1950,7 @@ func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse dropMaxLength := len(t.DropMax) SignalUpdateRawStartDropMaxVector(builder, dropMaxLength) for j := dropMaxLength - 1; j >= 0; j-- { - builder.PrependUint32(t.DropMax[j]) + builder.PrependUint64(t.DropMax[j]) } dropMaxOffset = builder.EndVector(dropMaxLength) } @@ -1962,12 +1962,12 @@ func (t *SignalUpdateRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffse func (rcv *SignalUpdateRaw) UnPackTo(t *SignalUpdateRawT) { newMaxLength := rcv.NewMaxLength() - t.NewMax = make([]uint32, newMaxLength) + t.NewMax = make([]uint64, newMaxLength) for j := 0; j < newMaxLength; j++ { t.NewMax[j] = rcv.NewMax(j) } dropMaxLength := rcv.DropMaxLength() - t.DropMax = make([]uint32, dropMaxLength) + t.DropMax = make([]uint64, dropMaxLength) for j := 0; j < dropMaxLength; j++ { t.DropMax[j] = rcv.DropMax(j) } @@ -2009,11 +2009,11 @@ func (rcv *SignalUpdateRaw) Table() flatbuffers.Table { return rcv._tab } -func (rcv *SignalUpdateRaw) NewMax(j int) uint32 { +func (rcv *SignalUpdateRaw) NewMax(j int) uint64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) } return 0 } @@ -2026,20 +2026,20 @@ func (rcv *SignalUpdateRaw) NewMaxLength() int { return 0 } -func (rcv *SignalUpdateRaw) MutateNewMax(j int, n uint32) bool { +func (rcv *SignalUpdateRaw) MutateNewMax(j int, n uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) } return false } -func (rcv *SignalUpdateRaw) DropMax(j int) uint32 { +func (rcv *SignalUpdateRaw) DropMax(j int) uint64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) } return 0 } @@ -2052,11 +2052,11 @@ func (rcv *SignalUpdateRaw) DropMaxLength() int { return 0 } -func (rcv *SignalUpdateRaw) MutateDropMax(j int, n uint32) bool { +func (rcv *SignalUpdateRaw) MutateDropMax(j int, n uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) } return false } @@ -2068,13 +2068,13 @@ func SignalUpdateRawAddNewMax(builder *flatbuffers.Builder, newMax flatbuffers.U builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(newMax), 0) } func SignalUpdateRawStartNewMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) + return builder.StartVector(8, numElems, 8) } func SignalUpdateRawAddDropMax(builder *flatbuffers.Builder, dropMax flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dropMax), 0) } func SignalUpdateRawStartDropMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) + return builder.StartVector(8, numElems, 8) } func SignalUpdateRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() @@ -2212,8 +2212,8 @@ func ExecutingMessageRawEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { type CallInfoRawT struct { Flags CallFlag `json:"flags"` Error int32 `json:"error"` - Signal []uint32 `json:"signal"` - Cover []uint32 `json:"cover"` + Signal []uint64 `json:"signal"` + Cover []uint64 `json:"cover"` Comps []*ComparisonRawT `json:"comps"` } @@ -2226,7 +2226,7 @@ func (t *CallInfoRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { signalLength := len(t.Signal) CallInfoRawStartSignalVector(builder, signalLength) for j := signalLength - 1; j >= 0; j-- { - builder.PrependUint32(t.Signal[j]) + builder.PrependUint64(t.Signal[j]) } signalOffset = builder.EndVector(signalLength) } @@ -2235,7 +2235,7 @@ func (t *CallInfoRawT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT { coverLength := len(t.Cover) CallInfoRawStartCoverVector(builder, coverLength) for j := coverLength - 1; j >= 0; j-- { - builder.PrependUint32(t.Cover[j]) + builder.PrependUint64(t.Cover[j]) } coverOffset = builder.EndVector(coverLength) } @@ -2261,12 +2261,12 @@ func (rcv *CallInfoRaw) UnPackTo(t *CallInfoRawT) { t.Flags = rcv.Flags() t.Error = rcv.Error() signalLength := rcv.SignalLength() - t.Signal = make([]uint32, signalLength) + t.Signal = make([]uint64, signalLength) for j := 0; j < signalLength; j++ { t.Signal[j] = rcv.Signal(j) } coverLength := rcv.CoverLength() - t.Cover = make([]uint32, coverLength) + t.Cover = make([]uint64, coverLength) for j := 0; j < coverLength; j++ { t.Cover[j] = rcv.Cover(j) } @@ -2339,11 +2339,11 @@ func (rcv *CallInfoRaw) MutateError(n int32) bool { return rcv._tab.MutateInt32Slot(6, n) } -func (rcv *CallInfoRaw) Signal(j int) uint32 { +func (rcv *CallInfoRaw) Signal(j int) uint64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) } return 0 } @@ -2356,20 +2356,20 @@ func (rcv *CallInfoRaw) SignalLength() int { return 0 } -func (rcv *CallInfoRaw) MutateSignal(j int, n uint32) bool { +func (rcv *CallInfoRaw) MutateSignal(j int, n uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) } return false } -func (rcv *CallInfoRaw) Cover(j int) uint32 { +func (rcv *CallInfoRaw) Cover(j int) uint64 { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4)) + return rcv._tab.GetUint64(a + flatbuffers.UOffsetT(j*8)) } return 0 } @@ -2382,11 +2382,11 @@ func (rcv *CallInfoRaw) CoverLength() int { return 0 } -func (rcv *CallInfoRaw) MutateCover(j int, n uint32) bool { +func (rcv *CallInfoRaw) MutateCover(j int, n uint64) bool { o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) if o != 0 { a := rcv._tab.Vector(o) - return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n) + return rcv._tab.MutateUint64(a+flatbuffers.UOffsetT(j*8), n) } return false } @@ -2423,13 +2423,13 @@ func CallInfoRawAddSignal(builder *flatbuffers.Builder, signal flatbuffers.UOffs builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(signal), 0) } func CallInfoRawStartSignalVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) + return builder.StartVector(8, numElems, 8) } func CallInfoRawAddCover(builder *flatbuffers.Builder, cover flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(cover), 0) } func CallInfoRawStartCoverVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { - return builder.StartVector(4, numElems, 4) + return builder.StartVector(8, numElems, 8) } func CallInfoRawAddComps(builder *flatbuffers.Builder, comps flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(comps), 0) diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h index 5721ea90f..649319e08 100644 --- a/pkg/flatrpc/flatrpc.h +++ b/pkg/flatrpc/flatrpc.h @@ -1459,7 +1459,7 @@ struct ExecRequestRawT : public flatbuffers::NativeTable { std::vector<uint8_t> prog_data{}; std::unique_ptr<rpc::ExecOptsRaw> exec_opts{}; rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0); - std::vector<uint32_t> signal_filter{}; + std::vector<uint64_t> signal_filter{}; int32_t signal_filter_call = 0; int32_t repeat = 0; ExecRequestRawT() = default; @@ -1492,8 +1492,8 @@ struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { rpc::RequestFlag flags() const { return static_cast<rpc::RequestFlag>(GetField<uint64_t>(VT_FLAGS, 0)); } - const flatbuffers::Vector<uint32_t> *signal_filter() const { - return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIGNAL_FILTER); + const flatbuffers::Vector<uint64_t> *signal_filter() const { + return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_SIGNAL_FILTER); } int32_t signal_filter_call() const { return GetField<int32_t>(VT_SIGNAL_FILTER_CALL, 0); @@ -1535,7 +1535,7 @@ struct ExecRequestRawBuilder { void add_flags(rpc::RequestFlag flags) { fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_FLAGS, static_cast<uint64_t>(flags), 0); } - void add_signal_filter(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal_filter) { + void add_signal_filter(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal_filter) { fbb_.AddOffset(ExecRequestRaw::VT_SIGNAL_FILTER, signal_filter); } void add_signal_filter_call(int32_t signal_filter_call) { @@ -1561,7 +1561,7 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw( flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data = 0, const rpc::ExecOptsRaw *exec_opts = nullptr, rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0), - flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal_filter = 0, + flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal_filter = 0, int32_t signal_filter_call = 0, int32_t repeat = 0) { ExecRequestRawBuilder builder_(_fbb); @@ -1581,11 +1581,11 @@ inline flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect( const std::vector<uint8_t> *prog_data = nullptr, const rpc::ExecOptsRaw *exec_opts = nullptr, rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0), - const std::vector<uint32_t> *signal_filter = nullptr, + const std::vector<uint64_t> *signal_filter = nullptr, int32_t signal_filter_call = 0, int32_t repeat = 0) { auto prog_data__ = prog_data ? _fbb.CreateVector<uint8_t>(*prog_data) : 0; - auto signal_filter__ = signal_filter ? _fbb.CreateVector<uint32_t>(*signal_filter) : 0; + auto signal_filter__ = signal_filter ? _fbb.CreateVector<uint64_t>(*signal_filter) : 0; return rpc::CreateExecRequestRaw( _fbb, id, @@ -1601,8 +1601,8 @@ flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(flatbuffers::FlatBuffer struct SignalUpdateRawT : public flatbuffers::NativeTable { typedef SignalUpdateRaw TableType; - std::vector<uint32_t> new_max{}; - std::vector<uint32_t> drop_max{}; + std::vector<uint64_t> new_max{}; + std::vector<uint64_t> drop_max{}; }; struct SignalUpdateRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { @@ -1612,11 +1612,11 @@ struct SignalUpdateRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { VT_NEW_MAX = 4, VT_DROP_MAX = 6 }; - const flatbuffers::Vector<uint32_t> *new_max() const { - return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_NEW_MAX); + const flatbuffers::Vector<uint64_t> *new_max() const { + return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_NEW_MAX); } - const flatbuffers::Vector<uint32_t> *drop_max() const { - return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DROP_MAX); + const flatbuffers::Vector<uint64_t> *drop_max() const { + return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_DROP_MAX); } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && @@ -1635,10 +1635,10 @@ struct SignalUpdateRawBuilder { typedef SignalUpdateRaw Table; flatbuffers::FlatBufferBuilder &fbb_; flatbuffers::uoffset_t start_; - void add_new_max(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> new_max) { + void add_new_max(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> new_max) { fbb_.AddOffset(SignalUpdateRaw::VT_NEW_MAX, new_max); } - void add_drop_max(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> drop_max) { + void add_drop_max(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> drop_max) { fbb_.AddOffset(SignalUpdateRaw::VT_DROP_MAX, drop_max); } explicit SignalUpdateRawBuilder(flatbuffers::FlatBufferBuilder &_fbb) @@ -1654,8 +1654,8 @@ struct SignalUpdateRawBuilder { inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw( flatbuffers::FlatBufferBuilder &_fbb, - flatbuffers::Offset<flatbuffers::Vector<uint32_t>> new_max = 0, - flatbuffers::Offset<flatbuffers::Vector<uint32_t>> drop_max = 0) { + flatbuffers::Offset<flatbuffers::Vector<uint64_t>> new_max = 0, + flatbuffers::Offset<flatbuffers::Vector<uint64_t>> drop_max = 0) { SignalUpdateRawBuilder builder_(_fbb); builder_.add_drop_max(drop_max); builder_.add_new_max(new_max); @@ -1664,10 +1664,10 @@ inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw( inline flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRawDirect( flatbuffers::FlatBufferBuilder &_fbb, - const std::vector<uint32_t> *new_max = nullptr, - const std::vector<uint32_t> *drop_max = nullptr) { - auto new_max__ = new_max ? _fbb.CreateVector<uint32_t>(*new_max) : 0; - auto drop_max__ = drop_max ? _fbb.CreateVector<uint32_t>(*drop_max) : 0; + const std::vector<uint64_t> *new_max = nullptr, + const std::vector<uint64_t> *drop_max = nullptr) { + auto new_max__ = new_max ? _fbb.CreateVector<uint64_t>(*new_max) : 0; + auto drop_max__ = drop_max ? _fbb.CreateVector<uint64_t>(*drop_max) : 0; return rpc::CreateSignalUpdateRaw( _fbb, new_max__, @@ -1765,8 +1765,8 @@ struct CallInfoRawT : public flatbuffers::NativeTable { typedef CallInfoRaw TableType; rpc::CallFlag flags = static_cast<rpc::CallFlag>(0); int32_t error = 0; - std::vector<uint32_t> signal{}; - std::vector<uint32_t> cover{}; + std::vector<uint64_t> signal{}; + std::vector<uint64_t> cover{}; std::vector<rpc::ComparisonRaw> comps{}; }; @@ -1786,11 +1786,11 @@ struct CallInfoRaw FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { int32_t error() const { return GetField<int32_t>(VT_ERROR, 0); } - const flatbuffers::Vector<uint32_t> *signal() const { - return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIGNAL); + const flatbuffers::Vector<uint64_t> *signal() const { + return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_SIGNAL); } - const flatbuffers::Vector<uint32_t> *cover() const { - return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_COVER); + const flatbuffers::Vector<uint64_t> *cover() const { + return GetPointer<const flatbuffers::Vector<uint64_t> *>(VT_COVER); } const flatbuffers::Vector<const rpc::ComparisonRaw *> *comps() const { return GetPointer<const flatbuffers::Vector<const rpc::ComparisonRaw *> *>(VT_COMPS); @@ -1822,10 +1822,10 @@ struct CallInfoRawBuilder { void add_error(int32_t error) { fbb_.AddElement<int32_t>(CallInfoRaw::VT_ERROR, error, 0); } - void add_signal(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal) { + void add_signal(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal) { fbb_.AddOffset(CallInfoRaw::VT_SIGNAL, signal); } - void add_cover(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> cover) { + void add_cover(flatbuffers::Offset<flatbuffers::Vector<uint64_t>> cover) { fbb_.AddOffset(CallInfoRaw::VT_COVER, cover); } void add_comps(flatbuffers::Offset<flatbuffers::Vector<const rpc::ComparisonRaw *>> comps) { @@ -1846,8 +1846,8 @@ inline flatbuffers::Offset<CallInfoRaw> CreateCallInfoRaw( flatbuffers::FlatBufferBuilder &_fbb, rpc::CallFlag flags = static_cast<rpc::CallFlag>(0), int32_t error = 0, - flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal = 0, - flatbuffers::Offset<flatbuffers::Vector<uint32_t>> cover = 0, + flatbuffers::Offset<flatbuffers::Vector<uint64_t>> signal = 0, + flatbuffers::Offset<flatbuffers::Vector<uint64_t>> cover = 0, flatbuffers::Offset<flatbuffers::Vector<const rpc::ComparisonRaw *>> comps = 0) { CallInfoRawBuilder builder_(_fbb); builder_.add_comps(comps); @@ -1862,11 +1862,11 @@ inline flatbuffers::Offset<CallInfoRaw> CreateCallInfoRawDirect( flatbuffers::FlatBufferBuilder &_fbb, rpc::CallFlag flags = static_cast<rpc::CallFlag>(0), int32_t error = 0, - const std::vector<uint32_t> *signal = nullptr, - const std::vector<uint32_t> *cover = nullptr, + const std::vector<uint64_t> *signal = nullptr, + const std::vector<uint64_t> *cover = nullptr, const std::vector<rpc::ComparisonRaw> *comps = nullptr) { - auto signal__ = signal ? _fbb.CreateVector<uint32_t>(*signal) : 0; - auto cover__ = cover ? _fbb.CreateVector<uint32_t>(*cover) : 0; + auto signal__ = signal ? _fbb.CreateVector<uint64_t>(*signal) : 0; + auto cover__ = cover ? _fbb.CreateVector<uint64_t>(*cover) : 0; auto comps__ = comps ? _fbb.CreateVectorOfStructs<rpc::ComparisonRaw>(*comps) : 0; return rpc::CreateCallInfoRaw( _fbb, diff --git a/pkg/fuzzer/cover.go b/pkg/fuzzer/cover.go index 03580128d..c34a3b219 100644 --- a/pkg/fuzzer/cover.go +++ b/pkg/fuzzer/cover.go @@ -34,7 +34,7 @@ func (cover *Cover) AddMaxSignal(sign signal.Signal) { cover.dropSignal.Subtract(sign) } -func (cover *Cover) addRawMaxSignal(signal []uint32, prio uint8) signal.Signal { +func (cover *Cover) addRawMaxSignal(signal []uint64, prio uint8) signal.Signal { cover.mu.Lock() defer cover.mu.Unlock() diff := cover.maxSignal.DiffRaw(signal, prio) diff --git a/pkg/fuzzer/fuzzer_test.go b/pkg/fuzzer/fuzzer_test.go index 9ac3376ac..206469fda 100644 --- a/pkg/fuzzer/fuzzer_test.go +++ b/pkg/fuzzer/fuzzer_test.go @@ -144,9 +144,9 @@ func TestRotate(t *testing.T) { }, rand.New(testutil.RandSource(t)), target) fakeSignal := func(size int) signal.Signal { - var pc []uint32 + var pc []uint64 for i := 0; i < size; i++ { - pc = append(pc, uint32(i)) + pc = append(pc, uint64(i)) } return signal.FromRaw(pc, 0) } @@ -188,8 +188,8 @@ func emulateExec(req *queue.Request) (*queue.Result, string, error) { serializedLines := bytes.Split(req.Prog.Serialize(), []byte("\n")) var info flatrpc.ProgInfo for i, call := range req.Prog.Calls { - cover := []uint32{uint32(call.Meta.ID*1024) + - crc32.Checksum(serializedLines[i], crc32q)%4} + cover := []uint64{uint64(call.Meta.ID*1024) + + uint64(crc32.Checksum(serializedLines[i], crc32q)%4)} callInfo := &flatrpc.CallInfo{} if req.ExecOpts.ExecFlags&flatrpc.ExecFlagCollectCover > 0 { callInfo.Cover = cover diff --git a/pkg/fuzzer/job.go b/pkg/fuzzer/job.go index a5a22b2e8..dd3dc4a1a 100644 --- a/pkg/fuzzer/job.go +++ b/pkg/fuzzer/job.go @@ -136,7 +136,7 @@ type deflakedCover struct { stableSignal signal.Signal newStableSignal signal.Signal cover cover.Cover - rawCover []uint32 + rawCover []uint64 } func (job *triageJob) deflake(exec func(*queue.Request, ProgTypes) *queue.Result, stat *stats.Val, @@ -241,7 +241,7 @@ func reexecutionSuccess(info *flatrpc.ProgInfo, oldInfo *flatrpc.CallInfo, call return info.Extra != nil && len(info.Extra.Signal) != 0 } -func getSignalAndCover(p *prog.Prog, info *flatrpc.ProgInfo, call int) (signal.Signal, []uint32) { +func getSignalAndCover(p *prog.Prog, info *flatrpc.ProgInfo, call int) (signal.Signal, []uint64) { inf := info.Extra if call != -1 { inf = info.Calls[call] diff --git a/pkg/fuzzer/job_test.go b/pkg/fuzzer/job_test.go index 70d083be5..cbb99daec 100644 --- a/pkg/fuzzer/job_test.go +++ b/pkg/fuzzer/job_test.go @@ -25,14 +25,14 @@ func TestDeflakeFail(t *testing.T) { testJob := &triageJob{ p: prog, info: &flatrpc.CallInfo{}, - newSignal: signal.FromRaw([]uint32{0, 1, 2, 3, 4}, 0), + newSignal: signal.FromRaw([]uint64{0, 1, 2, 3, 4}, 0), } run := 0 ret, stop := testJob.deflake(func(_ *queue.Request, _ ProgTypes) *queue.Result { run++ // For first, we return 0 and 1. For second, 1 and 2. And so on. - return fakeResult(0, []uint32{uint32(run), uint32(run + 1)}, []uint32{10, 20}) + return fakeResult(0, []uint64{uint64(run), uint64(run + 1)}, []uint64{10, 20}) }, nil, false) assert.False(t, stop) assert.Equal(t, 5, run) @@ -51,21 +51,21 @@ func TestDeflakeSuccess(t *testing.T) { testJob := &triageJob{ p: prog, info: &flatrpc.CallInfo{}, - newSignal: signal.FromRaw([]uint32{0, 1, 2}, 0), + newSignal: signal.FromRaw([]uint64{0, 1, 2}, 0), } run := 0 ret, stop := testJob.deflake(func(_ *queue.Request, _ ProgTypes) *queue.Result { run++ switch run { case 1: - return fakeResult(0, []uint32{0, 2, 4, 6, 8}, []uint32{10, 20}) + return fakeResult(0, []uint64{0, 2, 4, 6, 8}, []uint64{10, 20}) case 2: // This one should be ignored -- it has a different errno. - return fakeResult(1, []uint32{0, 1, 2}, []uint32{100}) + return fakeResult(1, []uint64{0, 1, 2}, []uint64{100}) case 3: - return fakeResult(0, []uint32{0, 2, 4, 6, 8}, []uint32{20, 30}) + return fakeResult(0, []uint64{0, 2, 4, 6, 8}, []uint64{20, 30}) case 4: - return fakeResult(0, []uint32{0, 2, 6}, []uint32{30, 40}) + return fakeResult(0, []uint64{0, 2, 6}, []uint64{30, 40}) } // We expect it to have finished earlier. t.Fatal("only 4 runs were expected") @@ -73,14 +73,14 @@ func TestDeflakeSuccess(t *testing.T) { }, nil, false) assert.False(t, stop) // Cover is a union of all coverages. - assert.ElementsMatch(t, []uint32{10, 20, 30, 40}, ret.cover.Serialize()) + assert.ElementsMatch(t, []uint64{10, 20, 30, 40}, ret.cover.Serialize()) // 0, 2, 6 were in three resuls. - assert.ElementsMatch(t, []uint32{0, 2, 6}, ret.stableSignal.ToRaw()) + assert.ElementsMatch(t, []uint64{0, 2, 6}, ret.stableSignal.ToRaw()) // 0, 2 were also in newSignal. - assert.ElementsMatch(t, []uint32{0, 2}, ret.newStableSignal.ToRaw()) + assert.ElementsMatch(t, []uint64{0, 2}, ret.newStableSignal.ToRaw()) } -func fakeResult(errno int32, signal, cover []uint32) *queue.Result { +func fakeResult(errno int32, signal, cover []uint64) *queue.Result { return &queue.Result{ Info: &flatrpc.ProgInfo{ Calls: []*flatrpc.CallInfo{ diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go index 1b356c38c..84a7b9541 100644 --- a/pkg/ipc/ipc.go +++ b/pkg/ipc/ipc.go @@ -359,11 +359,11 @@ func (env *Env) parseOutput(opts *flatrpc.ExecOpts, ncalls int) (*flatrpc.ProgIn extraParts = append(extraParts, flatrpc.CallInfo{}) inf = &extraParts[len(extraParts)-1] } - if inf.Signal, ok = readUint32Array(&out, reply.signalSize); !ok { + if inf.Signal, ok = readUint64Array(&out, reply.signalSize); !ok { return nil, fmt.Errorf("call %v/%v/%v: signal overflow: %v/%v", i, reply.index, reply.num, reply.signalSize, len(out)) } - if inf.Cover, ok = readUint32Array(&out, reply.coverSize); !ok { + if inf.Cover, ok = readUint64Array(&out, reply.coverSize); !ok { return nil, fmt.Errorf("call %v/%v/%v: cover overflow: %v/%v", i, reply.index, reply.num, reply.coverSize, len(out)) } @@ -397,10 +397,10 @@ func convertExtra(extraParts []flatrpc.CallInfo, dedupCover bool) *flatrpc.CallI for _, part := range extraParts { extraSignal.Merge(signal.FromRaw(part.Signal, 0)) } - extra.Signal = make([]uint32, len(extraSignal)) + extra.Signal = make([]uint64, len(extraSignal)) i := 0 for s := range extraSignal { - extra.Signal[i] = uint32(s) + extra.Signal[i] = uint64(s) i++ } return &extra @@ -466,17 +466,16 @@ func readUint64(outp *[]byte) (uint64, bool) { return v, true } -func readUint32Array(outp *[]byte, size uint32) ([]uint32, bool) { +func readUint64Array(outp *[]byte, size uint32) ([]uint64, bool) { if size == 0 { return nil, true } out := *outp - dataSize := int(size * 4) + dataSize := int(size * 8) if dataSize > len(out) { return nil, false } - // "Convert" the data to uint32. - res := unsafe.Slice((*uint32)(unsafe.Pointer(&out[0])), size) + res := unsafe.Slice((*uint64)(unsafe.Pointer(&out[0])), size) *outp = out[dataSize:] // Detach the resulting array from the original data. return slices.Clone(res), true diff --git a/pkg/signal/signal.go b/pkg/signal/signal.go index 10a1ef0cb..5f6da48cb 100644 --- a/pkg/signal/signal.go +++ b/pkg/signal/signal.go @@ -7,7 +7,7 @@ package signal import "math/rand" type ( - elemType uint32 + elemType uint64 prioType int8 ) @@ -50,7 +50,7 @@ func (s *Signal) Split(n int) Signal { return c } -func FromRaw(raw []uint32, prio uint8) Signal { +func FromRaw(raw []uint64, prio uint8) Signal { if len(raw) == 0 { return nil } @@ -78,7 +78,7 @@ func (s Signal) Diff(s1 Signal) Signal { return res } -func (s Signal) DiffRaw(raw []uint32, prio uint8) Signal { +func (s Signal) DiffRaw(raw []uint64, prio uint8) Signal { var res Signal for _, e := range raw { if p, ok := s[elemType(e)]; ok && p >= prioType(prio) { @@ -161,8 +161,8 @@ func (s Signal) RandomSubset(r *rand.Rand, size int) Signal { // FilterRaw returns a subset of original raw elements that either are not present in ignore, // or coincides with the one in alwaysTake. -func FilterRaw(raw []uint32, ignore, alwaysTake Signal) []uint32 { - var ret []uint32 +func FilterRaw(raw []uint64, ignore, alwaysTake Signal) []uint64 { + var ret []uint64 for _, e := range raw { if _, ok := alwaysTake[elemType(e)]; ok { ret = append(ret, e) @@ -174,8 +174,8 @@ func FilterRaw(raw []uint32, ignore, alwaysTake Signal) []uint32 { } // DiffFromRaw returns a subset of the raw elements that is not present in Signal. -func (s Signal) DiffFromRaw(raw []uint32) []uint32 { - var ret []uint32 +func (s Signal) DiffFromRaw(raw []uint64) []uint64 { + var ret []uint64 for _, e := range raw { if _, ok := s[elemType(e)]; !ok { ret = append(ret, e) @@ -184,10 +184,10 @@ func (s Signal) DiffFromRaw(raw []uint32) []uint32 { return ret } -func (s Signal) ToRaw() []uint32 { - var raw []uint32 +func (s Signal) ToRaw() []uint64 { + var raw []uint64 for e := range s { - raw = append(raw, uint32(e)) + raw = append(raw, uint64(e)) } return raw } diff --git a/pkg/signal/signal_test.go b/pkg/signal/signal_test.go index efd53d2ea..52b91fc19 100644 --- a/pkg/signal/signal_test.go +++ b/pkg/signal/signal_test.go @@ -13,7 +13,7 @@ import ( func TestRandomSubset(t *testing.T) { r := rand.New(testutil.RandSource(t)) - base := FromRaw([]uint32{0, 1, 2, 3, 4}, 0) + base := FromRaw([]uint64{0, 1, 2, 3, 4}, 0) var s Signal for i := 0; i < 1000 && s.Len() < base.Len(); i++ { delta := base.RandomSubset(r, 1) @@ -24,18 +24,18 @@ func TestRandomSubset(t *testing.T) { } func TestSubtract(t *testing.T) { - base := FromRaw([]uint32{0, 1, 2, 3, 4}, 0) + base := FromRaw([]uint64{0, 1, 2, 3, 4}, 0) assert.Equal(t, 5, base.Len()) - base.Subtract(FromRaw([]uint32{0}, 0)) + base.Subtract(FromRaw([]uint64{0}, 0)) assert.Equal(t, 4, base.Len()) - base.Subtract(FromRaw([]uint32{1}, 0)) + base.Subtract(FromRaw([]uint64{1}, 0)) assert.Equal(t, 3, base.Len()) } func TestIntersectsWith(t *testing.T) { - base := FromRaw([]uint32{0, 1, 2, 3, 4}, 1) - assert.True(t, base.IntersectsWith(FromRaw([]uint32{0, 5, 10}, 1))) - assert.False(t, base.IntersectsWith(FromRaw([]uint32{5, 10, 15}, 1))) + base := FromRaw([]uint64{0, 1, 2, 3, 4}, 1) + assert.True(t, base.IntersectsWith(FromRaw([]uint64{0, 5, 10}, 1))) + assert.False(t, base.IntersectsWith(FromRaw([]uint64{5, 10, 15}, 1))) // The other signal has a lower priority. - assert.False(t, base.IntersectsWith(FromRaw([]uint32{0, 1, 2}, 0))) + assert.False(t, base.IntersectsWith(FromRaw([]uint64{0, 1, 2}, 0))) } diff --git a/pkg/vminfo/vminfo_test.go b/pkg/vminfo/vminfo_test.go index 0e5d17ef2..f58e3f7e5 100644 --- a/pkg/vminfo/vminfo_test.go +++ b/pkg/vminfo/vminfo_test.go @@ -106,8 +106,8 @@ func createSuccessfulResults(source queue.Source, stop chan struct{}) { info := &flatrpc.ProgInfo{} for range req.Prog.Calls { info.Calls = append(info.Calls, &flatrpc.CallInfo{ - Cover: []uint32{1}, - Signal: []uint32{1}, + Cover: []uint64{1}, + Signal: []uint64{1}, Comps: []*flatrpc.Comparison{{Op1: 1, Op2: 2}}, }) } diff --git a/prog/analysis.go b/prog/analysis.go index 7202a7d92..458b9455c 100644 --- a/prog/analysis.go +++ b/prog/analysis.go @@ -245,7 +245,7 @@ const ( type CallInfo struct { Flags CallFlags Errno int - Signal []uint32 + Signal []uint64 } const ( @@ -345,7 +345,7 @@ func extractArgSignal(arg Arg, callID, flags int, inf *CallInfo, resources map[* return flags } -func DecodeFallbackSignal(s uint32) (callID, errno int) { +func DecodeFallbackSignal(s uint64) (callID, errno int) { typ, id, aux := decodeFallbackSignal(s) switch typ { case fallbackSignalErrno, fallbackSignalErrnoBlocked: @@ -357,15 +357,15 @@ func DecodeFallbackSignal(s uint32) (callID, errno int) { } } -func encodeFallbackSignal(typ, id, aux int) uint32 { +func encodeFallbackSignal(typ, id, aux int) uint64 { checkMaxCallID(id) if typ & ^7 != 0 { panic(fmt.Sprintf("bad fallback signal type %v", typ)) } - return uint32(typ) | uint32(id&fallbackCallMask)<<3 | uint32(aux)<<24 + return uint64(typ) | uint64(id&fallbackCallMask)<<3 | uint64(aux)<<24 } -func decodeFallbackSignal(s uint32) (typ, id, aux int) { +func decodeFallbackSignal(s uint64) (typ, id, aux int) { return int(s & 7), int((s >> 3) & fallbackCallMask), int(s >> 24) } diff --git a/prog/prog_test.go b/prog/prog_test.go index d4301e1e7..1a9a2b6ba 100644 --- a/prog/prog_test.go +++ b/prog/prog_test.go @@ -294,12 +294,12 @@ fallback$0() { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 42, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, {}, }, @@ -318,32 +318,32 @@ fallback$1(0x0) { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 1, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 2), + Signal: make([]uint64, 2), }, { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 2), + Signal: make([]uint64, 2), }, { Flags: CallExecuted, Errno: 2, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, }, }, @@ -362,17 +362,17 @@ fallback$0() { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 1, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, @@ -402,12 +402,12 @@ fallback$0() { Flags: CallExecuted, Errno: 0, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, Errno: 1, - Signal: make([]uint32, 1), + Signal: make([]uint64, 1), }, { Flags: CallExecuted, diff --git a/syz-fuzzer/fuzzer.go b/syz-fuzzer/fuzzer.go index 8e6537616..78e918447 100644 --- a/syz-fuzzer/fuzzer.go +++ b/syz-fuzzer/fuzzer.go @@ -264,7 +264,7 @@ func diffMaxSignal(info *flatrpc.ProgInfo, max, mask signal.Signal, maskCall int } } -func diffCallSignal(raw []uint32, max, mask signal.Signal, call, maskCall int) []uint32 { +func diffCallSignal(raw []uint64, max, mask signal.Signal, call, maskCall int) []uint64 { if mask != nil && call == maskCall { return signal.FilterRaw(raw, max, mask) } diff --git a/syz-fuzzer/fuzzer_test.go b/syz-fuzzer/fuzzer_test.go index 2acc70ab9..5f453e31a 100644 --- a/syz-fuzzer/fuzzer_test.go +++ b/syz-fuzzer/fuzzer_test.go @@ -12,39 +12,39 @@ import ( ) func TestFilterProgInfo(t *testing.T) { - max := signal.FromRaw([]uint32{5, 6, 7}, 0) - mask := signal.FromRaw([]uint32{2, 4, 6, 8}, 0) + max := signal.FromRaw([]uint64{5, 6, 7}, 0) + mask := signal.FromRaw([]uint64{2, 4, 6, 8}, 0) info := flatrpc.ProgInfo{ Calls: []*flatrpc.CallInfo{ { - Signal: []uint32{1, 2, 3, 5, 6}, - Cover: []uint32{1, 2, 3}, + Signal: []uint64{1, 2, 3, 5, 6}, + Cover: []uint64{1, 2, 3}, }, { - Signal: []uint32{2, 3, 4, 6, 7}, - Cover: []uint32{2, 3, 4}, + Signal: []uint64{2, 3, 4, 6, 7}, + Cover: []uint64{2, 3, 4}, }, }, Extra: &flatrpc.CallInfo{ - Signal: []uint32{3, 4, 5}, - Cover: []uint32{3, 4, 5}, + Signal: []uint64{3, 4, 5}, + Cover: []uint64{3, 4, 5}, }, } diffMaxSignal(&info, max, mask, 1) assert.Equal(t, flatrpc.ProgInfo{ Calls: []*flatrpc.CallInfo{ { - Signal: []uint32{1, 2, 3}, - Cover: []uint32{1, 2, 3}, + Signal: []uint64{1, 2, 3}, + Cover: []uint64{1, 2, 3}, }, { - Signal: []uint32{2, 3, 4, 6}, - Cover: []uint32{2, 3, 4}, + Signal: []uint64{2, 3, 4, 6}, + Cover: []uint64{2, 3, 4}, }, }, Extra: &flatrpc.CallInfo{ - Signal: []uint32{3, 4}, - Cover: []uint32{3, 4, 5}, + Signal: []uint64{3, 4}, + Cover: []uint64{3, 4, 5}, }, }, info) } diff --git a/syz-manager/cover.go b/syz-manager/cover.go index d97f01358..0009ea1c8 100644 --- a/syz-manager/cover.go +++ b/syz-manager/cover.go @@ -36,7 +36,7 @@ func resetReportGenerator() { cachedRepGen = nil } -func coverToPCs(rg *cover.ReportGenerator, cov []uint32) []uint64 { +func coverToPCs(rg *cover.ReportGenerator, cov []uint64) []uint64 { pcs := make([]uint64, 0, len(cov)) for _, pc := range cov { pcs = append(pcs, rg.RestorePC(pc)) diff --git a/syz-manager/covfilter.go b/syz-manager/covfilter.go index 2acb06a5b..53fc03070 100644 --- a/syz-manager/covfilter.go +++ b/syz-manager/covfilter.go @@ -20,7 +20,7 @@ import ( ) func createCoverageFilter(cfg *mgrconfig.Config, modules []cover.KernelModule) ( - map[uint32]uint32, map[uint32]uint32, error) { + map[uint64]uint32, map[uint64]uint32, error) { if !cfg.HasCovFilter() { return nil, nil, nil } @@ -29,7 +29,7 @@ func createCoverageFilter(cfg *mgrconfig.Config, modules []cover.KernelModule) ( if err != nil { return nil, nil, err } - pcs := make(map[uint32]uint32) + pcs := make(map[uint64]uint32) foreachSymbol := func(apply func(*backend.ObjectUnit)) { for _, sym := range rg.Symbols { apply(&sym.ObjectUnit) @@ -56,7 +56,7 @@ func createCoverageFilter(cfg *mgrconfig.Config, modules []cover.KernelModule) ( return nil, nil, fmt.Errorf("coverage filter is only supported for targets that use shmem") } // Copy pcs into execPCs. This is used to filter coverage in the executor. - execPCs := make(map[uint32]uint32) + execPCs := make(map[uint64]uint32) for pc, val := range pcs { execPCs[pc] = val } @@ -64,13 +64,13 @@ func createCoverageFilter(cfg *mgrconfig.Config, modules []cover.KernelModule) ( // in syz-manager. for _, sym := range rg.Symbols { for _, pc := range sym.CMPs { - delete(pcs, uint32(pc)) + delete(pcs, pc) } } return execPCs, pcs, nil } -func covFilterAddFilter(pcs map[uint32]uint32, filters []string, foreach func(func(*backend.ObjectUnit))) error { +func covFilterAddFilter(pcs map[uint64]uint32, filters []string, foreach func(func(*backend.ObjectUnit))) error { res, err := compileRegexps(filters) if err != nil { return err @@ -82,10 +82,10 @@ func covFilterAddFilter(pcs map[uint32]uint32, filters []string, foreach func(fu // We add both coverage points and comparison interception points // because executor filters comparisons as well. for _, pc := range unit.PCs { - pcs[uint32(pc)] = 1 + pcs[pc] = 1 } for _, pc := range unit.CMPs { - pcs[uint32(pc)] = 1 + pcs[pc] = 1 } used[re] = append(used[re], unit.Name) break @@ -102,7 +102,7 @@ func covFilterAddFilter(pcs map[uint32]uint32, filters []string, foreach func(fu return nil } -func covFilterAddRawPCs(pcs map[uint32]uint32, rawPCsFiles []string) error { +func covFilterAddRawPCs(pcs map[uint64]uint32, rawPCsFiles []string) error { re := regexp.MustCompile(`(0x[0-9a-f]+)(?:: (0x[0-9a-f]+))?`) for _, f := range rawPCsFiles { rawFile, err := os.Open(f) @@ -128,7 +128,7 @@ func covFilterAddRawPCs(pcs map[uint32]uint32, rawPCsFiles []string) error { if match[2] == "" || weight < 1 { weight = 1 } - pcs[uint32(pc)] = uint32(weight) + pcs[pc] = uint32(weight) } if err := s.Err(); err != nil { return err @@ -137,36 +137,36 @@ func covFilterAddRawPCs(pcs map[uint32]uint32, rawPCsFiles []string) error { return nil } -func createCoverageBitmap(target *targets.Target, pcs map[uint32]uint32) []byte { +func createCoverageBitmap(target *targets.Target, pcs map[uint64]uint32) []byte { // Return nil if filtering is not used. if len(pcs) == 0 { return nil } start, size := coverageFilterRegion(pcs) - log.Logf(0, "coverage filter from 0x%x to 0x%x, size 0x%x, pcs %v", start, start+size, size, len(pcs)) + log.Logf(0, "coverage filter from 0x%x to 0x%x, size 0x%x, pcs %v", start, start+uint64(size), size, len(pcs)) // The file starts with two uint32: covFilterStart and covFilterSize, // and a bitmap with size ((covFilterSize>>4)/8+2 bytes follow them. // 8-bit = 1-byte - data := make([]byte, 8+((size>>4)/8+2)) + data := make([]byte, 12+((size>>4)/8+2)) order := binary.ByteOrder(binary.BigEndian) if target.LittleEndian { order = binary.LittleEndian } - order.PutUint32(data, start) - order.PutUint32(data[4:], size) + order.PutUint64(data, start) + order.PutUint32(data[8:], size) - bitmap := data[8:] + bitmap := data[12:] for pc := range pcs { // The lowest 4-bit is dropped. - pc = uint32(backend.NextInstructionPC(target, uint64(pc))) + pc = backend.NextInstructionPC(target, pc) pc = (pc - start) >> 4 bitmap[pc/8] |= (1 << (pc % 8)) } return data } -func coverageFilterRegion(pcs map[uint32]uint32) (uint32, uint32) { - start, end := ^uint32(0), uint32(0) +func coverageFilterRegion(pcs map[uint64]uint32) (uint64, uint32) { + start, end := ^uint64(0), uint64(0) for pc := range pcs { if start > pc { start = pc @@ -175,7 +175,7 @@ func coverageFilterRegion(pcs map[uint32]uint32) (uint32, uint32) { end = pc } } - return start, end - start + return start, uint32(end - start) } func compileRegexps(regexpStrings []string) ([]*regexp.Regexp, error) { diff --git a/syz-manager/covfilter_test.go b/syz-manager/covfilter_test.go index 8f9b808fa..d6165c19b 100644 --- a/syz-manager/covfilter_test.go +++ b/syz-manager/covfilter_test.go @@ -10,19 +10,19 @@ import ( ) func TestCreateBitmap(t *testing.T) { - pcs := map[uint32]uint32{ + pcs := map[uint64]uint32{ 0x81000002: 1, 0x8120001d: 1, } target := targets.Get("test", "64") order := target.HostEndian bitmap := createCoverageBitmap(target, pcs) - start := order.Uint32(bitmap[0:]) - size := order.Uint32(bitmap[4:]) + start := order.Uint64(bitmap[0:]) + size := order.Uint32(bitmap[8:]) if start != 0x81000002 || size != 0x20001b { t.Fatalf("bad region 0x%x/0x%x", start, size) } - for i, byte := range bitmap[8:] { + for i, byte := range bitmap[12:] { var expect uint8 switch i { case 0: @@ -34,17 +34,17 @@ func TestCreateBitmap(t *testing.T) { t.Errorf("bad bitmap byte 0x%x: 0x%x, expect 0x%x", i, byte, expect) } } - pcs = map[uint32]uint32{ + pcs = map[uint64]uint32{ 0: 1, 0xffffffff: 1, } createCoverageBitmap(target, pcs) - pcs = map[uint32]uint32{ + pcs = map[uint64]uint32{ 0x81000000: 1, 0x81000100: 1, } createCoverageBitmap(target, pcs) - pcs = map[uint32]uint32{ + pcs = map[uint64]uint32{ 0x81000002: 1, 0x81000010: 1, 0x81000102: 1, @@ -53,7 +53,7 @@ func TestCreateBitmap(t *testing.T) { } func TestNilCoverageBitmap(t *testing.T) { - pcs := map[uint32]uint32(nil) + pcs := map[uint64]uint32(nil) target := targets.Get("test", "64") bitmap := createCoverageBitmap(target, pcs) if bitmap != nil { diff --git a/syz-manager/http.go b/syz-manager/http.go index c2628dc5d..67fed3fdb 100644 --- a/syz-manager/http.go +++ b/syz-manager/http.go @@ -312,7 +312,7 @@ func (mgr *Manager) httpCoverCover(w http.ResponseWriter, r *http.Request, funcF } mgr.mu.Unlock() - var coverFilter map[uint32]uint32 + var coverFilter map[uint64]uint32 if r.FormValue("filter") != "" || funcFlag == DoFilterPCs { if mgr.serv.coverFilter == nil { http.Error(w, "cover is not filtered in config", http.StatusInternalServerError) @@ -359,7 +359,7 @@ func (mgr *Manager) httpCoverFallback(w http.ResponseWriter, r *http.Request) { defer mgr.mu.Unlock() calls := make(map[int][]int) for s := range mgr.corpus.Signal() { - id, errno := prog.DecodeFallbackSignal(uint32(s)) + id, errno := prog.DecodeFallbackSignal(uint64(s)) calls[id] = append(calls[id], errno) } data := &UIFallbackCoverData{} diff --git a/syz-manager/rpc.go b/syz-manager/rpc.go index af208b47e..fdbdc7bb4 100644 --- a/syz-manager/rpc.go +++ b/syz-manager/rpc.go @@ -42,8 +42,8 @@ type RPCServer struct { setupFeatures flatrpc.Feature modules []cover.KernelModule canonicalModules *cover.Canonicalizer - execCoverFilter map[uint32]uint32 - coverFilter map[uint32]uint32 + execCoverFilter map[uint64]uint32 + coverFilter map[uint64]uint32 mu sync.Mutex runners map[string]*Runner @@ -554,7 +554,7 @@ func (serv *RPCServer) distributeSignalDelta(plus, minus signal.Signal) { } } -func (runner *Runner) sendSignalUpdate(plus, minus []uint32) error { +func (runner *Runner) sendSignalUpdate(plus, minus []uint64) error { msg := &flatrpc.HostMessage{ Msg: &flatrpc.HostMessages{ Type: flatrpc.HostMessagesRawSignalUpdate, @@ -567,7 +567,7 @@ func (runner *Runner) sendSignalUpdate(plus, minus []uint32) error { return flatrpc.Send(runner.conn, msg) } -func (serv *RPCServer) updateCoverFilter(newCover []uint32) { +func (serv *RPCServer) updateCoverFilter(newCover []uint64) { if len(newCover) == 0 || serv.coverFilter == nil { return } @@ -577,7 +577,7 @@ func (serv *RPCServer) updateCoverFilter(newCover []uint32) { } filtered := 0 for _, pc := range newCover { - if serv.coverFilter[uint32(rg.RestorePC(pc))] != 0 { + if serv.coverFilter[rg.RestorePC(pc)] != 0 { filtered++ } } diff --git a/tools/syz-execprog/execprog.go b/tools/syz-execprog/execprog.go index cb51244b3..43146a170 100644 --- a/tools/syz-execprog/execprog.go +++ b/tools/syz-execprog/execprog.go @@ -13,12 +13,10 @@ import ( "math/rand" "os" "runtime" - "strconv" "strings" "sync" "time" - "github.com/google/syzkaller/pkg/cover" "github.com/google/syzkaller/pkg/cover/backend" "github.com/google/syzkaller/pkg/csource" "github.com/google/syzkaller/pkg/db" @@ -125,7 +123,6 @@ func main() { choiceTable = target.BuildChoiceTable(progs, syscalls) } sysTarget := targets.Get(*flagOS, *flagArch) - upperBase := getKernelUpperBase(sysTarget) ctx := &Context{ target: target, progs: progs, @@ -137,7 +134,6 @@ func main() { stress: *flagStress, repeat: *flagRepeat, sysTarget: sysTarget, - upperBase: upperBase, } var wg sync.WaitGroup wg.Add(*flagProcs) @@ -167,7 +163,6 @@ type Context struct { pos int lastPrint time.Time sysTarget *targets.Target - upperBase uint32 } func (ctx *Context) run(pid int) { @@ -296,39 +291,13 @@ func (ctx *Context) printHints(p *prog.Prog, info *flatrpc.ProgInfo) { log.Logf(0, "ncomps=%v ncandidates=%v", ncomps, ncandidates) } -func getKernelUpperBase(target *targets.Target) uint32 { - defaultRet := uint32(0xffffffff) - if target.OS == targets.Linux { - // Read the first 8 bytes from /proc/kallsyms. - f, err := os.Open("/proc/kallsyms") - if err != nil { - log.Logf(1, "could not get kernel fixup address: %v", err) - return defaultRet - } - defer f.Close() - data := make([]byte, 8) - _, err = f.ReadAt(data, 0) - if err != nil { - log.Logf(1, "could not get kernel fixup address: %v", err) - return defaultRet - } - value, err := strconv.ParseUint(string(data), 16, 32) - if err != nil { - log.Logf(1, "could not get kernel fixup address: %v", err) - return defaultRet - } - return uint32(value) - } - return defaultRet -} - func (ctx *Context) dumpCallCoverage(coverFile string, info *flatrpc.CallInfo) { if info == nil || len(info.Cover) == 0 { return } buf := new(bytes.Buffer) for _, pc := range info.Cover { - prev := backend.PreviousInstructionPC(ctx.sysTarget, cover.RestorePC(pc, ctx.upperBase)) + prev := backend.PreviousInstructionPC(ctx.sysTarget, pc) fmt.Fprintf(buf, "0x%x\n", prev) } err := osutil.WriteFile(coverFile, buf.Bytes()) |