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
|
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "test/util/signal_util.h"
#include <signal.h>
#include <ostream>
#include "gtest/gtest.h"
#include "test/util/cleanup.h"
#include "test/util/posix_error.h"
#include "test/util/test_util.h"
namespace {
struct Range {
int start;
int end;
};
// Format a Range as "start-end" or "start" for single value Ranges.
static ::std::ostream& operator<<(::std::ostream& os, const Range& range) {
if (range.end > range.start) {
return os << range.start << '-' << range.end;
}
return os << range.start;
}
} // namespace
// Format a sigset_t as a comma separated list of numeric ranges.
// Empty sigset: []
// Full sigset: [1-31,34-64]
::std::ostream& operator<<(::std::ostream& os, const sigset_t& sigset) {
const char* delim = "";
Range range = {0, 0};
os << '[';
for (int sig = 1; sig <= gvisor::testing::kMaxSignal; ++sig) {
if (sigismember(&sigset, sig)) {
if (range.start) {
range.end = sig;
} else {
range.start = sig;
range.end = sig;
}
} else if (range.start) {
os << delim << range;
delim = ",";
range.start = 0;
range.end = 0;
}
}
if (range.start) {
os << delim << range;
}
return os << ']';
}
namespace gvisor {
namespace testing {
PosixErrorOr<Cleanup> ScopedSigaction(int sig, struct sigaction const& sa) {
struct sigaction old_sa;
int rc = sigaction(sig, &sa, &old_sa);
MaybeSave();
if (rc < 0) {
return PosixError(errno, "sigaction failed");
}
return Cleanup([sig, old_sa] {
EXPECT_THAT(sigaction(sig, &old_sa, nullptr), SyscallSucceeds());
});
}
PosixErrorOr<Cleanup> ScopedSignalMask(int how, sigset_t const& set) {
sigset_t old;
int rc = sigprocmask(how, &set, &old);
MaybeSave();
if (rc < 0) {
return PosixError(errno, "sigprocmask failed");
}
return Cleanup([old] {
EXPECT_THAT(sigprocmask(SIG_SETMASK, &old, nullptr), SyscallSucceeds());
});
}
} // namespace testing
} // namespace gvisor
|
