1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
// Copyright 2021 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
package main
import (
"io/ioutil"
"math/rand"
"os"
"testing"
"time"
"github.com/google/syzkaller/pkg/ipc"
"github.com/google/syzkaller/pkg/osutil"
"github.com/google/syzkaller/prog"
)
func createTestServer(t *testing.T) *RPCServer {
target, err := prog.GetTarget("test", "64")
if err != nil {
t.Fatalf("failed to initialise test target: %v", err)
}
vrf := Verifier{
target: target,
choiceTable: target.DefaultChoiceTable(),
rnd: rand.New(rand.NewSource(time.Now().UnixNano())),
progIdx: 3,
reruns: 1,
}
vrf.resultsdir = makeTestResultDirectory(t)
vrf.stats = emptyTestStats()
srv, err := startRPCServer(&vrf)
if err != nil {
t.Fatalf("failed to initialise RPC server: %v", err)
}
return srv
}
func getTestProgram(t *testing.T) *prog.Prog {
p := "breaks_returns()\n" +
"minimize$0(0x1, 0x1)\n" +
"test$res0()\n"
target := prog.InitTargetTest(t, "test", "64")
prog, err := target.Deserialize([]byte(p), prog.Strict)
if err != nil {
t.Fatalf("failed to deserialise test program: %v", err)
}
return prog
}
func makeTestResultDirectory(t *testing.T) string {
dir, err := ioutil.TempDir("", "syz-verifier")
if err != nil {
t.Fatalf("failed to create results directory: %v", err)
}
t.Cleanup(func() {
os.RemoveAll(dir)
})
return osutil.Abs(dir)
}
func makeExecResult(pool int, errnos []int, flags ...int) *ExecResult {
r := &ExecResult{Pool: pool, Info: ipc.ProgInfo{Calls: []ipc.CallInfo{}}}
for _, e := range errnos {
r.Info.Calls = append(r.Info.Calls, ipc.CallInfo{Errno: e})
}
for idx, f := range flags {
r.Info.Calls[idx].Flags = ipc.CallFlags(f)
}
return r
}
func makeExecResultCrashed(pool int) *ExecResult {
return &ExecResult{Pool: pool, Crashed: true}
}
func emptyTestStats() *Stats {
return &Stats{
Calls: map[string]*CallStats{
"breaks_returns": {Name: "breaks_returns", States: map[ReturnState]bool{}},
"minimize$0": {Name: "minimize$0", States: map[ReturnState]bool{}},
"test$res0": {Name: "test$res0", States: map[ReturnState]bool{}},
},
}
}
func makeCallStats(name string, occurrences, mismatches int, states map[ReturnState]bool) *CallStats {
return &CallStats{Name: name,
Occurrences: occurrences,
Mismatches: mismatches,
States: states}
}
func returnState(errno int, flags ...int) ReturnState {
rs := ReturnState{Errno: errno}
if flags != nil {
rs.Flags = ipc.CallFlags(flags[0])
}
return rs
}
func crashedReturnState() ReturnState {
return ReturnState{Crashed: true}
}
|
