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
106
107
108
109
110
111
112
113
114
|
// Copyright 2015 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 prog
import (
"strings"
"testing"
)
func TestResourceCtors(t *testing.T) {
if testing.Short() && raceEnabled {
t.Skip("too slow")
}
testEachTarget(t, func(t *testing.T, target *Target) {
expectFail := false
for _, res := range target.Resources {
if len(target.calcResourceCtors(res.Kind, true)) == 0 != expectFail {
t.Errorf("resource %v can't be created", res.Name)
}
}
})
}
func TestTransitivelyEnabledCalls(t *testing.T) {
testEachTarget(t, func(t *testing.T, target *Target) {
calls := make(map[*Syscall]bool)
for _, c := range target.Syscalls {
calls[c] = true
}
enabled, disabled := target.TransitivelyEnabledCalls(calls)
for c, ok := range enabled {
if !ok {
t.Fatalf("syscalls %v is false in enabled map", c.Name)
}
}
if target.OS == "test" {
for c := range enabled {
if c.CallName == "unsupported" {
t.Errorf("call %v is not disabled", c.Name)
}
}
for c, reason := range disabled {
if c.CallName != "unsupported" {
t.Errorf("call %v is disabled: %v", c.Name, reason)
}
}
} else {
if len(enabled) != len(target.Syscalls) {
t.Errorf("some calls are disabled: %v/%v", len(enabled), len(target.Syscalls))
}
if len(disabled) != 0 {
for c, reason := range disabled {
t.Errorf("disabled %v: %v", c.Name, reason)
}
}
}
})
}
func TestTransitivelyEnabledCallsLinux(t *testing.T) {
t.Parallel()
target, err := GetTarget("linux", "amd64")
if err != nil {
t.Fatal(err)
}
calls := make(map[*Syscall]bool)
for _, c := range target.Syscalls {
calls[c] = true
}
delete(calls, target.SyscallMap["epoll_create"])
if trans, disabled := target.TransitivelyEnabledCalls(calls); len(disabled) != 0 || len(trans) != len(calls) {
t.Fatalf("still must be able to create epoll fd with epoll_create1")
}
delete(calls, target.SyscallMap["epoll_create1"])
trans, disabled := target.TransitivelyEnabledCalls(calls)
if len(calls)-6 != len(trans) ||
trans[target.SyscallMap["epoll_ctl$EPOLL_CTL_ADD"]] ||
trans[target.SyscallMap["epoll_ctl$EPOLL_CTL_MOD"]] ||
trans[target.SyscallMap["epoll_ctl$EPOLL_CTL_DEL"]] ||
trans[target.SyscallMap["epoll_wait"]] ||
trans[target.SyscallMap["epoll_pwait"]] ||
trans[target.SyscallMap["kcmp$KCMP_EPOLL_TFD"]] {
t.Fatalf("epoll fd is not disabled")
}
if len(disabled) != 6 {
t.Fatalf("disabled %v syscalls, want 6", len(disabled))
}
for c, reason := range disabled {
if !strings.Contains(reason, "no syscalls can create resource fd_epoll,"+
" enable some syscalls that can create it [epoll_create epoll_create1]") {
t.Fatalf("%v: wrong disable reason: %v", c.Name, reason)
}
}
}
func TestClockGettime(t *testing.T) {
t.Parallel()
target, err := GetTarget("linux", "amd64")
if err != nil {
t.Fatal(err)
}
calls := make(map[*Syscall]bool)
for _, c := range target.Syscalls {
calls[c] = true
}
// Removal of clock_gettime should disable all calls that accept timespec/timeval.
delete(calls, target.SyscallMap["clock_gettime"])
trans, disabled := target.TransitivelyEnabledCalls(calls)
if len(trans)+10 > len(calls) || len(trans)+len(disabled) != len(calls) || len(trans) == 0 {
t.Fatalf("clock_gettime did not disable enough calls: before %v, after %v, disabled %v",
len(calls), len(trans), len(disabled))
}
}
|
