Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(76)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: components/nacl/loader/nonsfi/nonsfi_sandbox_unittest.cc

Issue 196793023: Add seccomp sandbox for non-SFI NaCl (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« components/nacl/loader/nonsfi/nonsfi_sandbox.h ('K') | « components/nacl/loader/nonsfi/nonsfi_sandbox.cc ('k') | sandbox/linux/sandbox_linux.gypi » ('j') | sandbox/linux/seccomp-bpf/bpf_tests.h » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "components/nacl/loader/nonsfi/nonsfi_sandbox.h"
6
7 #include <errno.h>
8 #include <fcntl.h>
9 #include <pthread.h>
10 #include <sched.h>
11 #include <signal.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <sys/mman.h>
15 #include <sys/prctl.h>
16 #include <sys/ptrace.h>
17 #include <sys/socket.h>
18 #include <sys/syscall.h>
19 #include <sys/types.h>
20 #include <sys/wait.h>
21 #include <unistd.h>
22
23 #include "base/bind.h"
24 #include "base/callback.h"
25 #include "base/compiler_specific.h"
26 #include "base/logging.h"
27 #include "sandbox/linux/seccomp-bpf/bpf_tests.h"
28 #include "testing/gtest/include/gtest/gtest.h"
29
30 static const char kSeccompFailureMsg[] = "seccomp-bpf failure";
jln (very slow on Chromium) 2014/04/11 19:29:54 This is a hidden dependency on the messages in sig
hamaji 2014/04/15 15:09:25 Done.
31
32 static int GetPageSize() {
33 return sysconf(_SC_PAGESIZE);
34 }
35
36 BPF_DEATH_TEST(NaClNonSfiSandboxTest, invalid_sysno,
37 DEATH_MESSAGE(kSeccompFailureMsg),
38 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
39 syscall(999);
40 }
41
42 static void* SetZeroInThread(void* test_val_ptr) {
43 *reinterpret_cast<int*>(test_val_ptr) = 0;
44 return NULL;
45 }
46
47 static int DoClone() {
48 int pid = syscall(__NR_clone,
49 CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, NULL);
50 if (pid == 0)
51 _Exit(0);
jln (very slow on Chromium) 2014/04/11 19:29:54 Nit: _exit() is more common.
hamaji 2014/04/15 15:09:25 Done.
52 return pid;
53 }
54
55 BPF_TEST(NaClNonSfiSandboxTest, clone_by_pthread_create,
56 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
57 pthread_t th;
58 int test_val = 42;
59 BPF_ASSERT_EQ(0, pthread_create(&th, NULL, &SetZeroInThread, &test_val));
60 BPF_ASSERT_EQ(0, pthread_join(th, NULL));
61 BPF_ASSERT_EQ(0, test_val);
62 }
63
64 BPF_DEATH_TEST(NaClNonSfiSandboxTest, clone,
65 DEATH_MESSAGE("clone() failure"),
66 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
67 // The sanity check for DoClone without the sandbox.
jln (very slow on Chromium) 2014/04/11 19:29:54 Why do you say this is not running in the sandbox?
hamaji 2014/04/15 15:09:25 Sorry, this was not wrong when I didn't use BPF_DE
68 int pid = DoClone();
69 BPF_ASSERT_LT(0, pid);
70 int status;
71 BPF_ASSERT_EQ(pid, waitpid(pid, &status, 0));
jln (very slow on Chromium) 2014/04/11 19:29:54 HANDLE_EINTR()
hamaji 2014/04/15 15:09:25 Done.
72 BPF_ASSERT_EQ(1, WIFEXITED(status));
jln (very slow on Chromium) 2014/04/11 19:29:54 I don't think you have a guarantee that this will
hamaji 2014/04/15 15:09:25 Done.
73 BPF_ASSERT_EQ(0, WEXITSTATUS(status));
74 // Then, try this in the sandbox.
75 DoClone();
jln (very slow on Chromium) 2014/04/11 19:29:54 I don't understand what you're doing here. But the
hamaji 2014/04/15 15:09:25 Now I splitted this BPF_DEATH_TEST into two tests.
76 }
77
78 BPF_DEATH_TEST(NaClNonSfiSandboxTest, prctl,
79 DEATH_MESSAGE("prctl() failure"),
80 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
81 errno = 0;
82 BPF_ASSERT_EQ(-1, syscall(__NR_prctl, PR_SET_NAME, "foo"));
83 BPF_ASSERT_EQ(EPERM, errno);
84 syscall(__NR_prctl, PR_SET_DUMPABLE, 1UL);
85 }
86
87 BPF_TEST(NaClNonSfiSandboxTest, socketcall_allowed,
88 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
89 int fds[2];
90 struct msghdr msg = {};
91 struct iovec iov;
92 std::string payload("foo");
93 iov.iov_base = &payload[0];
94 iov.iov_len = payload.size();
95 msg.msg_iov = &iov;
96 msg.msg_iovlen = 1;
97 BPF_ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
98 BPF_ASSERT_EQ(static_cast<int>(payload.size()), sendmsg(fds[1], &msg, 0));
hamaji 2014/04/11 01:25:58 I found this assertion was wrong but this test did
jln (very slow on Chromium) 2014/04/11 19:29:54 Yeah, GTEST blows up silently when one uses fork()
99 BPF_ASSERT_EQ(static_cast<int>(payload.size()), recvmsg(fds[0], &msg, 0));
100 BPF_ASSERT_EQ(0, close(fds[0]));
101 BPF_ASSERT_EQ(0, close(fds[1]));
102 }
103
104 BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept,
105 DEATH_MESSAGE(kSeccompFailureMsg),
106 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
107 accept(0, NULL, NULL);
108 }
109
110 BPF_DEATH_TEST(NaClNonSfiSandboxTest, bind,
111 DEATH_MESSAGE(kSeccompFailureMsg),
112 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
113 bind(0, NULL, 0);
114 }
115
116 BPF_DEATH_TEST(NaClNonSfiSandboxTest, connect,
117 DEATH_MESSAGE(kSeccompFailureMsg),
118 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
119 connect(0, NULL, 0);
120 }
121
122 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpeername,
123 DEATH_MESSAGE(kSeccompFailureMsg),
124 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
125 getpeername(0, NULL, NULL);
126 }
127
128 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockname,
129 DEATH_MESSAGE(kSeccompFailureMsg),
130 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
131 getsockname(0, NULL, NULL);
132 }
133
134 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockopt,
135 DEATH_MESSAGE(kSeccompFailureMsg),
136 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
137 getsockopt(0, 0, 0, NULL, NULL);
138 }
139
140 BPF_DEATH_TEST(NaClNonSfiSandboxTest, listen,
141 DEATH_MESSAGE(kSeccompFailureMsg),
142 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
143 listen(0, 0);
144 }
145
146 BPF_DEATH_TEST(NaClNonSfiSandboxTest, recv,
147 DEATH_MESSAGE(kSeccompFailureMsg),
148 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
149 recv(0, NULL, 0, 0);
150 }
151
152 BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvfrom,
153 DEATH_MESSAGE(kSeccompFailureMsg),
154 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
155 recvfrom(0, NULL, 0, 0, NULL, NULL);
156 }
157
158 BPF_DEATH_TEST(NaClNonSfiSandboxTest, send,
159 DEATH_MESSAGE(kSeccompFailureMsg),
160 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
161 send(0, NULL, 0, 0);
162 }
163
164 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendto,
165 DEATH_MESSAGE(kSeccompFailureMsg),
166 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
167 sendto(0, NULL, 0, 0, NULL, 0);
168 }
169
170 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsockopt,
171 DEATH_MESSAGE(kSeccompFailureMsg),
172 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
173 setsockopt(0, 0, 0, NULL, 0);
174 }
175
176 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shutdown,
177 DEATH_MESSAGE(kSeccompFailureMsg),
178 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
179 shutdown(0, 0);
180 }
181
182 BPF_DEATH_TEST(NaClNonSfiSandboxTest, socket,
183 DEATH_MESSAGE(kSeccompFailureMsg),
184 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
185 socket(0, 0, 0);
186 }
187
188 #if defined(__x86_64__) || defined(__arm__)
189 BPF_DEATH_TEST(NaClNonSfiSandboxTest, socketpair,
190 DEATH_MESSAGE(kSeccompFailureMsg),
191 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
192 int fds[2];
193 socketpair(AF_INET, SOCK_STREAM, 0, fds);
194 }
195 #endif
196
197 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_SETFD,
198 DEATH_MESSAGE(kSeccompFailureMsg),
jln (very slow on Chromium) 2014/04/11 20:19:47 Same remark as above: you need to split this into
hamaji 2014/04/15 15:09:25 Done.
199 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
200 int fds[2];
201 BPF_ASSERT_EQ(0, pipe(fds));
202 int fd = fds[0];
203 BPF_ASSERT_EQ(0, fcntl(fd, F_SETFD, FD_CLOEXEC));
204 fcntl(fd, F_SETFD, 99);
205 }
206
207 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_GETFL_SETFL,
208 DEATH_MESSAGE(kSeccompFailureMsg),
jln (very slow on Chromium) 2014/04/11 20:19:47 Same remark: split
hamaji 2014/04/15 15:09:25 Done.
209 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
210 int fds[2];
211 BPF_ASSERT_EQ(0, pipe(fds));
212 int fd = fds[0];
213 BPF_ASSERT_EQ(0, fcntl(fd, F_GETFL));
214 BPF_ASSERT_EQ(0, fcntl(fd, F_SETFL, O_RDWR | O_NONBLOCK));
215 BPF_ASSERT_EQ(O_NONBLOCK, fcntl(fd, F_GETFL));
216 fcntl(fd, F_SETFL, O_APPEND);
217 }
218
219 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD,
220 DEATH_MESSAGE(kSeccompFailureMsg),
221 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
222 fcntl(0, F_DUPFD);
223 }
224
225 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_DUPFD_CLOEXEC,
226 DEATH_MESSAGE(kSeccompFailureMsg),
227 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
228 fcntl(0, F_DUPFD_CLOEXEC);
229 }
230
231 BPF_TEST(NaClNonSfiSandboxTest, mmap_allowed,
232 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
233 void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
234 MAP_ANONYMOUS | MAP_SHARED, -1, 0);
235 BPF_ASSERT_NE(MAP_FAILED, ptr);
236 BPF_ASSERT_EQ(0, munmap(ptr, GetPageSize()));
237 }
238
239 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_unallowed_flag,
240 DEATH_MESSAGE(kSeccompFailureMsg),
241 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
242 mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
243 MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
244 }
245
246 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_unallowed_prot,
247 DEATH_MESSAGE(kSeccompFailureMsg),
248 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
249 mmap(NULL, GetPageSize(), PROT_READ | PROT_GROWSDOWN,
250 MAP_ANONYMOUS, -1, 0);
251 }
252
253 // TODO(hamaji): Disallow RWX mmap.
254 #if 0
255 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_rwx,
256 DEATH_MESSAGE(kSeccompFailureMsg),
257 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
258 mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE | PROT_EXEC,
259 MAP_ANONYMOUS, -1, 0);
260 }
261 #endif
262
263 BPF_TEST(NaClNonSfiSandboxTest, mprotect,
264 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
265 void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
266 MAP_ANONYMOUS | MAP_SHARED, -1, 0);
267 BPF_ASSERT_NE(MAP_FAILED, ptr);
268 BPF_ASSERT_EQ(0, mprotect(ptr, GetPageSize(), PROT_READ));
269 BPF_ASSERT_EQ(0, munmap(ptr, GetPageSize()));
270 }
271
272 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mprotect_unallowed_prot,
273 DEATH_MESSAGE(kSeccompFailureMsg),
274 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
275 void* ptr = mmap(NULL, GetPageSize(), PROT_READ | PROT_WRITE,
276 MAP_ANONYMOUS | MAP_SHARED, -1, 0);
277 BPF_ASSERT_NE(MAP_FAILED, ptr);
278 mprotect(ptr, GetPageSize(), PROT_READ | PROT_GROWSDOWN);
279 }
280
281 BPF_TEST(NaClNonSfiSandboxTest, brk,
282 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
283 char* next_brk = static_cast<char*>(sbrk(0)) + GetPageSize();
284 // The kernel interface must return zero for brk.
285 BPF_ASSERT_EQ(0, syscall(__NR_brk, next_brk));
286 // The libc wrapper translates it to ENOMEM.
287 errno = 0;
288 BPF_ASSERT_EQ(-1, brk(next_brk));
289 BPF_ASSERT_EQ(ENOMEM, errno);
290 }
291
292 #if defined(__i386__) || defined(__arm__)
293 BPF_TEST(NaClNonSfiSandboxTest, getegid32_EPERM,
294 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
295 errno = 0;
296 BPF_ASSERT_EQ(-1, syscall(__NR_getegid32));
297 BPF_ASSERT_EQ(EPERM, errno);
298 }
299
300 BPF_TEST(NaClNonSfiSandboxTest, geteuid32_EPERM,
301 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
302 errno = 0;
303 BPF_ASSERT_EQ(-1, syscall(__NR_geteuid32));
304 BPF_ASSERT_EQ(EPERM, errno);
305 }
306
307 BPF_TEST(NaClNonSfiSandboxTest, getgid32_EPERM,
308 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
309 errno = 0;
310 BPF_ASSERT_EQ(-1, syscall(__NR_getgid32));
311 BPF_ASSERT_EQ(EPERM, errno);
312 }
313
314 BPF_TEST(NaClNonSfiSandboxTest, getuid32_EPERM,
315 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
316 errno = 0;
317 BPF_ASSERT_EQ(-1, syscall(__NR_getuid32));
318 BPF_ASSERT_EQ(EPERM, errno);
319 }
320
321 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getegid_SIGSYS,
322 DEATH_MESSAGE(kSeccompFailureMsg),
323 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
324 syscall(__NR_getegid);
325 }
326
327 BPF_DEATH_TEST(NaClNonSfiSandboxTest, geteuid_SIGSYS,
328 DEATH_MESSAGE(kSeccompFailureMsg),
329 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
330 syscall(__NR_geteuid);
331 }
332
333 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgid_SIGSYS,
334 DEATH_MESSAGE(kSeccompFailureMsg),
335 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
336 syscall(__NR_getgid);
337 }
338
339 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getuid_SIGSYS,
340 DEATH_MESSAGE(kSeccompFailureMsg),
341 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
342 syscall(__NR_getuid);
343 }
344 #endif
345
346 #if defined(__x86_64__)
347 BPF_TEST(NaClNonSfiSandboxTest, getegid_EPERM,
348 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
349 errno = 0;
350 BPF_ASSERT_EQ(-1, syscall(__NR_getegid));
351 BPF_ASSERT_EQ(EPERM, errno);
352 }
353
354 BPF_TEST(NaClNonSfiSandboxTest, geteuid_EPERM,
355 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
356 errno = 0;
357 BPF_ASSERT_EQ(-1, syscall(__NR_geteuid));
358 BPF_ASSERT_EQ(EPERM, errno);
359 }
360
361 BPF_TEST(NaClNonSfiSandboxTest, getgid_EPERM,
362 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
363 errno = 0;
364 BPF_ASSERT_EQ(-1, syscall(__NR_getgid));
365 BPF_ASSERT_EQ(EPERM, errno);
366 }
367
368 BPF_TEST(NaClNonSfiSandboxTest, getuid_EPERM,
369 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
370 errno = 0;
371 BPF_ASSERT_EQ(-1, syscall(__NR_getuid));
372 BPF_ASSERT_EQ(EPERM, errno);
373 }
374 #endif
375
376 BPF_TEST(NaClNonSfiSandboxTest, madvise_EPERM,
377 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
378 errno = 0;
379 BPF_ASSERT_EQ(-1, syscall(__NR_madvise));
380 BPF_ASSERT_EQ(EPERM, errno);
381 }
382
383 BPF_TEST(NaClNonSfiSandboxTest, open_EPERM,
384 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
385 errno = 0;
386 BPF_ASSERT_EQ(-1, syscall(__NR_open));
387 BPF_ASSERT_EQ(EPERM, errno);
388 }
389
390 BPF_TEST(NaClNonSfiSandboxTest, ptrace_EPERM,
391 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
392 errno = 0;
393 BPF_ASSERT_EQ(-1, syscall(__NR_ptrace));
394 BPF_ASSERT_EQ(EPERM, errno);
395 }
396
397 BPF_TEST(NaClNonSfiSandboxTest, set_robust_list_EPERM,
398 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
399 errno = 0;
400 BPF_ASSERT_EQ(-1, syscall(__NR_set_robust_list));
401 BPF_ASSERT_EQ(EPERM, errno);
402 }
403
404 #if defined(__i386__) || defined(__x86_64__)
405 BPF_TEST(NaClNonSfiSandboxTest, time_EPERM,
406 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
407 errno = 0;
408 BPF_ASSERT_EQ(-1, syscall(__NR_time));
409 BPF_ASSERT_EQ(EPERM, errno);
410 }
411 #endif
412
413 // The rest of syscalls should just raise SIGSYS regardless of arguments.
jln (very slow on Chromium) 2014/04/11 20:19:47 I wonder if we shouldn't fix 5 arguments (to 0) re
hamaji 2014/04/15 15:09:25 Done. Isn't there a syscall which takes 6 argument
414
415 #if defined(__i386__) || defined(__arm__)
416 BPF_DEATH_TEST(NaClNonSfiSandboxTest, _newselect_SIGSYS,
417 DEATH_MESSAGE(kSeccompFailureMsg),
418 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
419 syscall(__NR__newselect);
420 }
421 #endif
422
423 BPF_DEATH_TEST(NaClNonSfiSandboxTest, _sysctl_SIGSYS,
424 DEATH_MESSAGE(kSeccompFailureMsg),
425 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
426 syscall(__NR__sysctl);
427 }
428
429 #if defined(__x86_64__) || defined(__arm__)
430 BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept_SIGSYS,
431 DEATH_MESSAGE(kSeccompFailureMsg),
432 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
433 syscall(__NR_accept);
434 }
435 #endif
436
437 #if defined(__x86_64__) || defined(__arm__)
438 BPF_DEATH_TEST(NaClNonSfiSandboxTest, accept4_SIGSYS,
439 DEATH_MESSAGE(kSeccompFailureMsg),
440 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
441 syscall(__NR_accept4);
442 }
443 #endif
444
445 BPF_DEATH_TEST(NaClNonSfiSandboxTest, access_SIGSYS,
446 DEATH_MESSAGE(kSeccompFailureMsg),
447 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
448 syscall(__NR_access);
449 }
450
451 BPF_DEATH_TEST(NaClNonSfiSandboxTest, acct_SIGSYS,
452 DEATH_MESSAGE(kSeccompFailureMsg),
453 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
454 syscall(__NR_acct);
455 }
456
457 BPF_DEATH_TEST(NaClNonSfiSandboxTest, add_key_SIGSYS,
458 DEATH_MESSAGE(kSeccompFailureMsg),
459 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
460 syscall(__NR_add_key);
461 }
462
463 BPF_DEATH_TEST(NaClNonSfiSandboxTest, adjtimex_SIGSYS,
464 DEATH_MESSAGE(kSeccompFailureMsg),
465 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
466 syscall(__NR_adjtimex);
467 }
468
469 #if defined(__i386__) || defined(__x86_64__)
470 BPF_DEATH_TEST(NaClNonSfiSandboxTest, afs_syscall_SIGSYS,
471 DEATH_MESSAGE(kSeccompFailureMsg),
472 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
473 syscall(__NR_afs_syscall);
474 }
475 #endif
476
477 #if defined(__i386__) || defined(__x86_64__)
478 BPF_DEATH_TEST(NaClNonSfiSandboxTest, alarm_SIGSYS,
479 DEATH_MESSAGE(kSeccompFailureMsg),
480 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
481 syscall(__NR_alarm);
482 }
483 #endif
484
485 #if defined(__x86_64__)
486 BPF_DEATH_TEST(NaClNonSfiSandboxTest, arch_prctl_SIGSYS,
487 DEATH_MESSAGE(kSeccompFailureMsg),
488 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
489 syscall(__NR_arch_prctl);
490 }
491 #endif
492
493 #if defined(__arm__)
494 BPF_DEATH_TEST(NaClNonSfiSandboxTest, arm_fadvise64_64_SIGSYS,
495 DEATH_MESSAGE(kSeccompFailureMsg),
496 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
497 syscall(__NR_arm_fadvise64_64);
498 }
499 #endif
500
501 #if defined(__i386__) || defined(__arm__)
502 BPF_DEATH_TEST(NaClNonSfiSandboxTest, bdflush_SIGSYS,
503 DEATH_MESSAGE(kSeccompFailureMsg),
504 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
505 syscall(__NR_bdflush);
506 }
507 #endif
508
509 #if defined(__x86_64__) || defined(__arm__)
510 BPF_DEATH_TEST(NaClNonSfiSandboxTest, bind_SIGSYS,
511 DEATH_MESSAGE(kSeccompFailureMsg),
512 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
513 syscall(__NR_bind);
514 }
515 #endif
516
517 #if defined(__i386__)
518 BPF_DEATH_TEST(NaClNonSfiSandboxTest, break_SIGSYS,
519 DEATH_MESSAGE(kSeccompFailureMsg),
520 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
521 syscall(__NR_break);
522 }
523 #endif
524
525 BPF_DEATH_TEST(NaClNonSfiSandboxTest, capget_SIGSYS,
526 DEATH_MESSAGE(kSeccompFailureMsg),
527 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
528 syscall(__NR_capget);
529 }
530
531 BPF_DEATH_TEST(NaClNonSfiSandboxTest, capset_SIGSYS,
532 DEATH_MESSAGE(kSeccompFailureMsg),
533 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
534 syscall(__NR_capset);
535 }
536
537 BPF_DEATH_TEST(NaClNonSfiSandboxTest, chdir_SIGSYS,
538 DEATH_MESSAGE(kSeccompFailureMsg),
539 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
540 syscall(__NR_chdir);
541 }
542
543 BPF_DEATH_TEST(NaClNonSfiSandboxTest, chmod_SIGSYS,
544 DEATH_MESSAGE(kSeccompFailureMsg),
545 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
546 syscall(__NR_chmod);
547 }
548
549 BPF_DEATH_TEST(NaClNonSfiSandboxTest, chown_SIGSYS,
550 DEATH_MESSAGE(kSeccompFailureMsg),
551 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
552 syscall(__NR_chown);
553 }
554
555 #if defined(__i386__) || defined(__arm__)
556 BPF_DEATH_TEST(NaClNonSfiSandboxTest, chown32_SIGSYS,
557 DEATH_MESSAGE(kSeccompFailureMsg),
558 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
559 syscall(__NR_chown32);
560 }
561 #endif
562
563 BPF_DEATH_TEST(NaClNonSfiSandboxTest, chroot_SIGSYS,
564 DEATH_MESSAGE(kSeccompFailureMsg),
565 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
566 syscall(__NR_chroot);
567 }
568
569 BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_adjtime_SIGSYS,
570 DEATH_MESSAGE(kSeccompFailureMsg),
571 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
572 syscall(__NR_clock_adjtime);
573 }
574
575 BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_nanosleep_SIGSYS,
576 DEATH_MESSAGE(kSeccompFailureMsg),
577 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
578 syscall(__NR_clock_nanosleep);
579 }
580
581 BPF_DEATH_TEST(NaClNonSfiSandboxTest, clock_settime_SIGSYS,
582 DEATH_MESSAGE(kSeccompFailureMsg),
583 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
584 syscall(__NR_clock_settime);
585 }
586
587 #if defined(__x86_64__) || defined(__arm__)
588 BPF_DEATH_TEST(NaClNonSfiSandboxTest, connect_SIGSYS,
589 DEATH_MESSAGE(kSeccompFailureMsg),
590 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
591 syscall(__NR_connect);
592 }
593 #endif
594
595 BPF_DEATH_TEST(NaClNonSfiSandboxTest, creat_SIGSYS,
596 DEATH_MESSAGE(kSeccompFailureMsg),
597 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
598 syscall(__NR_creat);
599 }
600
601 #if defined(__i386__) || defined(__x86_64__)
602 BPF_DEATH_TEST(NaClNonSfiSandboxTest, create_module_SIGSYS,
603 DEATH_MESSAGE(kSeccompFailureMsg),
604 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
605 syscall(__NR_create_module);
606 }
607 #endif
608
609 BPF_DEATH_TEST(NaClNonSfiSandboxTest, delete_module_SIGSYS,
610 DEATH_MESSAGE(kSeccompFailureMsg),
611 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
612 syscall(__NR_delete_module);
613 }
614
615 BPF_DEATH_TEST(NaClNonSfiSandboxTest, dup3_SIGSYS,
616 DEATH_MESSAGE(kSeccompFailureMsg),
617 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
618 syscall(__NR_dup3);
619 }
620
621 BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_create1_SIGSYS,
622 DEATH_MESSAGE(kSeccompFailureMsg),
623 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
624 syscall(__NR_epoll_create1);
625 }
626
627 #if defined(__x86_64__)
628 BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_ctl_old_SIGSYS,
629 DEATH_MESSAGE(kSeccompFailureMsg),
630 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
631 syscall(__NR_epoll_ctl_old);
632 }
633 #endif
634
635 BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_pwait_SIGSYS,
636 DEATH_MESSAGE(kSeccompFailureMsg),
637 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
638 syscall(__NR_epoll_pwait);
639 }
640
641 #if defined(__x86_64__)
642 BPF_DEATH_TEST(NaClNonSfiSandboxTest, epoll_wait_old_SIGSYS,
643 DEATH_MESSAGE(kSeccompFailureMsg),
644 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
645 syscall(__NR_epoll_wait_old);
646 }
647 #endif
648
649 BPF_DEATH_TEST(NaClNonSfiSandboxTest, eventfd_SIGSYS,
650 DEATH_MESSAGE(kSeccompFailureMsg),
651 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
652 syscall(__NR_eventfd);
653 }
654
655 BPF_DEATH_TEST(NaClNonSfiSandboxTest, eventfd2_SIGSYS,
656 DEATH_MESSAGE(kSeccompFailureMsg),
657 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
658 syscall(__NR_eventfd2);
659 }
660
661 BPF_DEATH_TEST(NaClNonSfiSandboxTest, execve_SIGSYS,
662 DEATH_MESSAGE(kSeccompFailureMsg),
663 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
664 syscall(__NR_execve);
665 }
666
667 BPF_DEATH_TEST(NaClNonSfiSandboxTest, faccessat_SIGSYS,
668 DEATH_MESSAGE(kSeccompFailureMsg),
669 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
670 syscall(__NR_faccessat);
671 }
672
673 #if defined(__i386__) || defined(__x86_64__)
674 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fadvise64_SIGSYS,
675 DEATH_MESSAGE(kSeccompFailureMsg),
676 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
677 syscall(__NR_fadvise64);
678 }
679 #endif
680
681 #if defined(__i386__)
682 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fadvise64_64_SIGSYS,
683 DEATH_MESSAGE(kSeccompFailureMsg),
684 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
685 syscall(__NR_fadvise64_64);
686 }
687 #endif
688
689 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fallocate_SIGSYS,
690 DEATH_MESSAGE(kSeccompFailureMsg),
691 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
692 syscall(__NR_fallocate);
693 }
694
695 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fanotify_init_SIGSYS,
696 DEATH_MESSAGE(kSeccompFailureMsg),
697 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
698 syscall(__NR_fanotify_init);
699 }
700
701 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fanotify_mark_SIGSYS,
702 DEATH_MESSAGE(kSeccompFailureMsg),
703 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
704 syscall(__NR_fanotify_mark);
705 }
706
707 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchdir_SIGSYS,
708 DEATH_MESSAGE(kSeccompFailureMsg),
709 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
710 syscall(__NR_fchdir);
711 }
712
713 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchmod_SIGSYS,
714 DEATH_MESSAGE(kSeccompFailureMsg),
715 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
716 syscall(__NR_fchmod);
717 }
718
719 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchmodat_SIGSYS,
720 DEATH_MESSAGE(kSeccompFailureMsg),
721 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
722 syscall(__NR_fchmodat);
723 }
724
725 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchown_SIGSYS,
726 DEATH_MESSAGE(kSeccompFailureMsg),
727 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
728 syscall(__NR_fchown);
729 }
730
731 #if defined(__i386__) || defined(__arm__)
732 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchown32_SIGSYS,
733 DEATH_MESSAGE(kSeccompFailureMsg),
734 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
735 syscall(__NR_fchown32);
736 }
737 #endif
738
739 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fchownat_SIGSYS,
740 DEATH_MESSAGE(kSeccompFailureMsg),
741 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
742 syscall(__NR_fchownat);
743 }
744
745 #if defined(__i386__) || defined(__arm__)
746 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fcntl_SIGSYS,
747 DEATH_MESSAGE(kSeccompFailureMsg),
748 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
749 syscall(__NR_fcntl);
750 }
751 #endif
752
753 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fdatasync_SIGSYS,
754 DEATH_MESSAGE(kSeccompFailureMsg),
755 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
756 syscall(__NR_fdatasync);
757 }
758
759 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fgetxattr_SIGSYS,
760 DEATH_MESSAGE(kSeccompFailureMsg),
761 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
762 syscall(__NR_fgetxattr);
763 }
764
765 BPF_DEATH_TEST(NaClNonSfiSandboxTest, flistxattr_SIGSYS,
766 DEATH_MESSAGE(kSeccompFailureMsg),
767 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
768 syscall(__NR_flistxattr);
769 }
770
771 BPF_DEATH_TEST(NaClNonSfiSandboxTest, flock_SIGSYS,
772 DEATH_MESSAGE(kSeccompFailureMsg),
773 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
774 syscall(__NR_flock);
775 }
776
777 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fork_SIGSYS,
778 DEATH_MESSAGE(kSeccompFailureMsg),
779 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
780 syscall(__NR_fork);
781 }
782
783 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fremovexattr_SIGSYS,
784 DEATH_MESSAGE(kSeccompFailureMsg),
785 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
786 syscall(__NR_fremovexattr);
787 }
788
789 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fsetxattr_SIGSYS,
790 DEATH_MESSAGE(kSeccompFailureMsg),
791 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
792 syscall(__NR_fsetxattr);
793 }
794
795 #if defined(__i386__) || defined(__arm__)
796 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstat_SIGSYS,
797 DEATH_MESSAGE(kSeccompFailureMsg),
798 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
799 syscall(__NR_fstat);
800 }
801 #endif
802
803 #if defined(__i386__) || defined(__arm__)
804 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatat64_SIGSYS,
805 DEATH_MESSAGE(kSeccompFailureMsg),
806 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
807 syscall(__NR_fstatat64);
808 }
809 #endif
810
811 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatfs_SIGSYS,
812 DEATH_MESSAGE(kSeccompFailureMsg),
813 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
814 syscall(__NR_fstatfs);
815 }
816
817 #if defined(__i386__) || defined(__arm__)
818 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fstatfs64_SIGSYS,
819 DEATH_MESSAGE(kSeccompFailureMsg),
820 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
821 syscall(__NR_fstatfs64);
822 }
823 #endif
824
825 BPF_DEATH_TEST(NaClNonSfiSandboxTest, fsync_SIGSYS,
826 DEATH_MESSAGE(kSeccompFailureMsg),
827 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
828 syscall(__NR_fsync);
829 }
830
831 #if defined(__i386__)
832 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftime_SIGSYS,
833 DEATH_MESSAGE(kSeccompFailureMsg),
834 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
835 syscall(__NR_ftime);
836 }
837 #endif
838
839 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftruncate_SIGSYS,
840 DEATH_MESSAGE(kSeccompFailureMsg),
841 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
842 syscall(__NR_ftruncate);
843 }
844
845 #if defined(__i386__) || defined(__arm__)
846 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ftruncate64_SIGSYS,
847 DEATH_MESSAGE(kSeccompFailureMsg),
848 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
849 syscall(__NR_ftruncate64);
850 }
851 #endif
852
853 BPF_DEATH_TEST(NaClNonSfiSandboxTest, futimesat_SIGSYS,
854 DEATH_MESSAGE(kSeccompFailureMsg),
855 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
856 syscall(__NR_futimesat);
857 }
858
859 #if defined(__i386__) || defined(__x86_64__)
860 BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_kernel_syms_SIGSYS,
861 DEATH_MESSAGE(kSeccompFailureMsg),
862 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
863 syscall(__NR_get_kernel_syms);
864 }
865 #endif
866
867 BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_mempolicy_SIGSYS,
868 DEATH_MESSAGE(kSeccompFailureMsg),
869 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
870 syscall(__NR_get_mempolicy);
871 }
872
873 BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_robust_list_SIGSYS,
874 DEATH_MESSAGE(kSeccompFailureMsg),
875 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
876 syscall(__NR_get_robust_list);
877 }
878
879 #if defined(__i386__) || defined(__x86_64__)
880 BPF_DEATH_TEST(NaClNonSfiSandboxTest, get_thread_area_SIGSYS,
881 DEATH_MESSAGE(kSeccompFailureMsg),
882 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
883 syscall(__NR_get_thread_area);
884 }
885 #endif
886
887 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getcpu_SIGSYS,
888 DEATH_MESSAGE(kSeccompFailureMsg),
889 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
890 syscall(__NR_getcpu);
891 }
892
893 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getcwd_SIGSYS,
894 DEATH_MESSAGE(kSeccompFailureMsg),
895 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
896 syscall(__NR_getcwd);
897 }
898
899 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getdents_SIGSYS,
900 DEATH_MESSAGE(kSeccompFailureMsg),
901 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
902 syscall(__NR_getdents);
903 }
904
905 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getdents64_SIGSYS,
906 DEATH_MESSAGE(kSeccompFailureMsg),
907 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
908 syscall(__NR_getdents64);
909 }
910
911 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgroups_SIGSYS,
912 DEATH_MESSAGE(kSeccompFailureMsg),
913 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
914 syscall(__NR_getgroups);
915 }
916
917 #if defined(__i386__) || defined(__arm__)
918 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getgroups32_SIGSYS,
919 DEATH_MESSAGE(kSeccompFailureMsg),
920 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
921 syscall(__NR_getgroups32);
922 }
923 #endif
924
925 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getitimer_SIGSYS,
926 DEATH_MESSAGE(kSeccompFailureMsg),
927 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
928 syscall(__NR_getitimer);
929 }
930
931 #if defined(__x86_64__) || defined(__arm__)
932 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpeername_SIGSYS,
933 DEATH_MESSAGE(kSeccompFailureMsg),
934 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
935 syscall(__NR_getpeername);
936 }
937 #endif
938
939 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpgid_SIGSYS,
940 DEATH_MESSAGE(kSeccompFailureMsg),
941 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
942 syscall(__NR_getpgid);
943 }
944
945 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpgrp_SIGSYS,
946 DEATH_MESSAGE(kSeccompFailureMsg),
947 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
948 syscall(__NR_getpgrp);
949 }
950
951 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpid_SIGSYS,
952 DEATH_MESSAGE(kSeccompFailureMsg),
953 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
954 syscall(__NR_getpid);
955 }
956
957 #if defined(__i386__) || defined(__x86_64__)
958 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpmsg_SIGSYS,
959 DEATH_MESSAGE(kSeccompFailureMsg),
960 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
961 syscall(__NR_getpmsg);
962 }
963 #endif
964
965 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getppid_SIGSYS,
966 DEATH_MESSAGE(kSeccompFailureMsg),
967 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
968 syscall(__NR_getppid);
969 }
970
971 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getpriority_SIGSYS,
972 DEATH_MESSAGE(kSeccompFailureMsg),
973 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
974 syscall(__NR_getpriority);
975 }
976
977 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresgid_SIGSYS,
978 DEATH_MESSAGE(kSeccompFailureMsg),
979 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
980 syscall(__NR_getresgid);
981 }
982
983 #if defined(__i386__) || defined(__arm__)
984 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresgid32_SIGSYS,
985 DEATH_MESSAGE(kSeccompFailureMsg),
986 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
987 syscall(__NR_getresgid32);
988 }
989 #endif
990
991 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresuid_SIGSYS,
992 DEATH_MESSAGE(kSeccompFailureMsg),
993 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
994 syscall(__NR_getresuid);
995 }
996
997 #if defined(__i386__) || defined(__arm__)
998 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getresuid32_SIGSYS,
999 DEATH_MESSAGE(kSeccompFailureMsg),
1000 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1001 syscall(__NR_getresuid32);
1002 }
1003 #endif
1004
1005 #if defined(__i386__) || defined(__x86_64__)
1006 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getrlimit_SIGSYS,
1007 DEATH_MESSAGE(kSeccompFailureMsg),
1008 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1009 syscall(__NR_getrlimit);
1010 }
1011 #endif
1012
1013 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getrusage_SIGSYS,
1014 DEATH_MESSAGE(kSeccompFailureMsg),
1015 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1016 syscall(__NR_getrusage);
1017 }
1018
1019 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsid_SIGSYS,
1020 DEATH_MESSAGE(kSeccompFailureMsg),
1021 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1022 syscall(__NR_getsid);
1023 }
1024
1025 #if defined(__x86_64__) || defined(__arm__)
1026 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockname_SIGSYS,
1027 DEATH_MESSAGE(kSeccompFailureMsg),
1028 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1029 syscall(__NR_getsockname);
1030 }
1031 #endif
1032
1033 #if defined(__x86_64__) || defined(__arm__)
1034 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getsockopt_SIGSYS,
1035 DEATH_MESSAGE(kSeccompFailureMsg),
1036 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1037 syscall(__NR_getsockopt);
1038 }
1039 #endif
1040
1041 BPF_DEATH_TEST(NaClNonSfiSandboxTest, getxattr_SIGSYS,
1042 DEATH_MESSAGE(kSeccompFailureMsg),
1043 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1044 syscall(__NR_getxattr);
1045 }
1046
1047 #if defined(__i386__)
1048 BPF_DEATH_TEST(NaClNonSfiSandboxTest, gtty_SIGSYS,
1049 DEATH_MESSAGE(kSeccompFailureMsg),
1050 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1051 syscall(__NR_gtty);
1052 }
1053 #endif
1054
1055 #if defined(__i386__)
1056 BPF_DEATH_TEST(NaClNonSfiSandboxTest, idle_SIGSYS,
1057 DEATH_MESSAGE(kSeccompFailureMsg),
1058 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1059 syscall(__NR_idle);
1060 }
1061 #endif
1062
1063 BPF_DEATH_TEST(NaClNonSfiSandboxTest, init_module_SIGSYS,
1064 DEATH_MESSAGE(kSeccompFailureMsg),
1065 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1066 syscall(__NR_init_module);
1067 }
1068
1069 BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_add_watch_SIGSYS,
1070 DEATH_MESSAGE(kSeccompFailureMsg),
1071 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1072 syscall(__NR_inotify_add_watch);
1073 }
1074
1075 BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_init_SIGSYS,
1076 DEATH_MESSAGE(kSeccompFailureMsg),
1077 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1078 syscall(__NR_inotify_init);
1079 }
1080
1081 BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_init1_SIGSYS,
1082 DEATH_MESSAGE(kSeccompFailureMsg),
1083 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1084 syscall(__NR_inotify_init1);
1085 }
1086
1087 BPF_DEATH_TEST(NaClNonSfiSandboxTest, inotify_rm_watch_SIGSYS,
1088 DEATH_MESSAGE(kSeccompFailureMsg),
1089 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1090 syscall(__NR_inotify_rm_watch);
1091 }
1092
1093 BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_cancel_SIGSYS,
1094 DEATH_MESSAGE(kSeccompFailureMsg),
1095 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1096 syscall(__NR_io_cancel);
1097 }
1098
1099 BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_destroy_SIGSYS,
1100 DEATH_MESSAGE(kSeccompFailureMsg),
1101 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1102 syscall(__NR_io_destroy);
1103 }
1104
1105 BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_getevents_SIGSYS,
1106 DEATH_MESSAGE(kSeccompFailureMsg),
1107 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1108 syscall(__NR_io_getevents);
1109 }
1110
1111 BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_setup_SIGSYS,
1112 DEATH_MESSAGE(kSeccompFailureMsg),
1113 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1114 syscall(__NR_io_setup);
1115 }
1116
1117 BPF_DEATH_TEST(NaClNonSfiSandboxTest, io_submit_SIGSYS,
1118 DEATH_MESSAGE(kSeccompFailureMsg),
1119 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1120 syscall(__NR_io_submit);
1121 }
1122
1123 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioctl_SIGSYS,
1124 DEATH_MESSAGE(kSeccompFailureMsg),
1125 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1126 syscall(__NR_ioctl);
1127 }
1128
1129 #if defined(__i386__) || defined(__x86_64__)
1130 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioperm_SIGSYS,
1131 DEATH_MESSAGE(kSeccompFailureMsg),
1132 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1133 syscall(__NR_ioperm);
1134 }
1135 #endif
1136
1137 #if defined(__i386__) || defined(__x86_64__)
1138 BPF_DEATH_TEST(NaClNonSfiSandboxTest, iopl_SIGSYS,
1139 DEATH_MESSAGE(kSeccompFailureMsg),
1140 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1141 syscall(__NR_iopl);
1142 }
1143 #endif
1144
1145 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioprio_get_SIGSYS,
1146 DEATH_MESSAGE(kSeccompFailureMsg),
1147 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1148 syscall(__NR_ioprio_get);
1149 }
1150
1151 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ioprio_set_SIGSYS,
1152 DEATH_MESSAGE(kSeccompFailureMsg),
1153 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1154 syscall(__NR_ioprio_set);
1155 }
1156
1157 #if defined(__i386__)
1158 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ipc_SIGSYS,
1159 DEATH_MESSAGE(kSeccompFailureMsg),
1160 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1161 syscall(__NR_ipc);
1162 }
1163 #endif
1164
1165 BPF_DEATH_TEST(NaClNonSfiSandboxTest, kexec_load_SIGSYS,
1166 DEATH_MESSAGE(kSeccompFailureMsg),
1167 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1168 syscall(__NR_kexec_load);
1169 }
1170
1171 BPF_DEATH_TEST(NaClNonSfiSandboxTest, keyctl_SIGSYS,
1172 DEATH_MESSAGE(kSeccompFailureMsg),
1173 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1174 syscall(__NR_keyctl);
1175 }
1176
1177 BPF_DEATH_TEST(NaClNonSfiSandboxTest, kill_SIGSYS,
1178 DEATH_MESSAGE(kSeccompFailureMsg),
1179 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1180 syscall(__NR_kill);
1181 }
1182
1183 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lchown_SIGSYS,
1184 DEATH_MESSAGE(kSeccompFailureMsg),
1185 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1186 syscall(__NR_lchown);
1187 }
1188
1189 #if defined(__i386__) || defined(__arm__)
1190 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lchown32_SIGSYS,
1191 DEATH_MESSAGE(kSeccompFailureMsg),
1192 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1193 syscall(__NR_lchown32);
1194 }
1195 #endif
1196
1197 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lgetxattr_SIGSYS,
1198 DEATH_MESSAGE(kSeccompFailureMsg),
1199 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1200 syscall(__NR_lgetxattr);
1201 }
1202
1203 BPF_DEATH_TEST(NaClNonSfiSandboxTest, link_SIGSYS,
1204 DEATH_MESSAGE(kSeccompFailureMsg),
1205 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1206 syscall(__NR_link);
1207 }
1208
1209 BPF_DEATH_TEST(NaClNonSfiSandboxTest, linkat_SIGSYS,
1210 DEATH_MESSAGE(kSeccompFailureMsg),
1211 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1212 syscall(__NR_linkat);
1213 }
1214
1215 #if defined(__x86_64__) || defined(__arm__)
1216 BPF_DEATH_TEST(NaClNonSfiSandboxTest, listen_SIGSYS,
1217 DEATH_MESSAGE(kSeccompFailureMsg),
1218 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1219 syscall(__NR_listen);
1220 }
1221 #endif
1222
1223 BPF_DEATH_TEST(NaClNonSfiSandboxTest, listxattr_SIGSYS,
1224 DEATH_MESSAGE(kSeccompFailureMsg),
1225 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1226 syscall(__NR_listxattr);
1227 }
1228
1229 BPF_DEATH_TEST(NaClNonSfiSandboxTest, llistxattr_SIGSYS,
1230 DEATH_MESSAGE(kSeccompFailureMsg),
1231 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1232 syscall(__NR_llistxattr);
1233 }
1234
1235 #if defined(__i386__)
1236 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lock_SIGSYS,
1237 DEATH_MESSAGE(kSeccompFailureMsg),
1238 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1239 syscall(__NR_lock);
1240 }
1241 #endif
1242
1243 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lookup_dcookie_SIGSYS,
1244 DEATH_MESSAGE(kSeccompFailureMsg),
1245 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1246 syscall(__NR_lookup_dcookie);
1247 }
1248
1249 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lremovexattr_SIGSYS,
1250 DEATH_MESSAGE(kSeccompFailureMsg),
1251 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1252 syscall(__NR_lremovexattr);
1253 }
1254
1255 #if defined(__i386__) || defined(__arm__)
1256 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lseek_SIGSYS,
1257 DEATH_MESSAGE(kSeccompFailureMsg),
1258 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1259 syscall(__NR_lseek);
1260 }
1261 #endif
1262
1263 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lsetxattr_SIGSYS,
1264 DEATH_MESSAGE(kSeccompFailureMsg),
1265 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1266 syscall(__NR_lsetxattr);
1267 }
1268
1269 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lstat_SIGSYS,
1270 DEATH_MESSAGE(kSeccompFailureMsg),
1271 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1272 syscall(__NR_lstat);
1273 }
1274
1275 #if defined(__i386__) || defined(__arm__)
1276 BPF_DEATH_TEST(NaClNonSfiSandboxTest, lstat64_SIGSYS,
1277 DEATH_MESSAGE(kSeccompFailureMsg),
1278 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1279 syscall(__NR_lstat64);
1280 }
1281 #endif
1282
1283 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mbind_SIGSYS,
1284 DEATH_MESSAGE(kSeccompFailureMsg),
1285 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1286 syscall(__NR_mbind);
1287 }
1288
1289 #if defined(__i386__) || defined(__x86_64__)
1290 BPF_DEATH_TEST(NaClNonSfiSandboxTest, migrate_pages_SIGSYS,
1291 DEATH_MESSAGE(kSeccompFailureMsg),
1292 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1293 syscall(__NR_migrate_pages);
1294 }
1295 #endif
1296
1297 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mincore_SIGSYS,
1298 DEATH_MESSAGE(kSeccompFailureMsg),
1299 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1300 syscall(__NR_mincore);
1301 }
1302
1303 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mkdir_SIGSYS,
1304 DEATH_MESSAGE(kSeccompFailureMsg),
1305 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1306 syscall(__NR_mkdir);
1307 }
1308
1309 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mkdirat_SIGSYS,
1310 DEATH_MESSAGE(kSeccompFailureMsg),
1311 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1312 syscall(__NR_mkdirat);
1313 }
1314
1315 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mknod_SIGSYS,
1316 DEATH_MESSAGE(kSeccompFailureMsg),
1317 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1318 syscall(__NR_mknod);
1319 }
1320
1321 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mknodat_SIGSYS,
1322 DEATH_MESSAGE(kSeccompFailureMsg),
1323 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1324 syscall(__NR_mknodat);
1325 }
1326
1327 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mlock_SIGSYS,
1328 DEATH_MESSAGE(kSeccompFailureMsg),
1329 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1330 syscall(__NR_mlock);
1331 }
1332
1333 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mlockall_SIGSYS,
1334 DEATH_MESSAGE(kSeccompFailureMsg),
1335 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1336 syscall(__NR_mlockall);
1337 }
1338
1339 #if defined(__i386__)
1340 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mmap_SIGSYS,
1341 DEATH_MESSAGE(kSeccompFailureMsg),
1342 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1343 syscall(__NR_mmap);
1344 }
1345 #endif
1346
1347 #if defined(__i386__) || defined(__x86_64__)
1348 BPF_DEATH_TEST(NaClNonSfiSandboxTest, modify_ldt_SIGSYS,
1349 DEATH_MESSAGE(kSeccompFailureMsg),
1350 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1351 syscall(__NR_modify_ldt);
1352 }
1353 #endif
1354
1355 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mount_SIGSYS,
1356 DEATH_MESSAGE(kSeccompFailureMsg),
1357 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1358 syscall(__NR_mount);
1359 }
1360
1361 BPF_DEATH_TEST(NaClNonSfiSandboxTest, move_pages_SIGSYS,
1362 DEATH_MESSAGE(kSeccompFailureMsg),
1363 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1364 syscall(__NR_move_pages);
1365 }
1366
1367 #if defined(__i386__)
1368 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mpx_SIGSYS,
1369 DEATH_MESSAGE(kSeccompFailureMsg),
1370 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1371 syscall(__NR_mpx);
1372 }
1373 #endif
1374
1375 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_getsetattr_SIGSYS,
1376 DEATH_MESSAGE(kSeccompFailureMsg),
1377 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1378 syscall(__NR_mq_getsetattr);
1379 }
1380
1381 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_notify_SIGSYS,
1382 DEATH_MESSAGE(kSeccompFailureMsg),
1383 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1384 syscall(__NR_mq_notify);
1385 }
1386
1387 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_open_SIGSYS,
1388 DEATH_MESSAGE(kSeccompFailureMsg),
1389 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1390 syscall(__NR_mq_open);
1391 }
1392
1393 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_timedreceive_SIGSYS,
1394 DEATH_MESSAGE(kSeccompFailureMsg),
1395 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1396 syscall(__NR_mq_timedreceive);
1397 }
1398
1399 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_timedsend_SIGSYS,
1400 DEATH_MESSAGE(kSeccompFailureMsg),
1401 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1402 syscall(__NR_mq_timedsend);
1403 }
1404
1405 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mq_unlink_SIGSYS,
1406 DEATH_MESSAGE(kSeccompFailureMsg),
1407 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1408 syscall(__NR_mq_unlink);
1409 }
1410
1411 BPF_DEATH_TEST(NaClNonSfiSandboxTest, mremap_SIGSYS,
1412 DEATH_MESSAGE(kSeccompFailureMsg),
1413 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1414 syscall(__NR_mremap);
1415 }
1416
1417 #if defined(__x86_64__) || defined(__arm__)
1418 BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgctl_SIGSYS,
1419 DEATH_MESSAGE(kSeccompFailureMsg),
1420 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1421 syscall(__NR_msgctl);
1422 }
1423 #endif
1424
1425 #if defined(__x86_64__) || defined(__arm__)
1426 BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgget_SIGSYS,
1427 DEATH_MESSAGE(kSeccompFailureMsg),
1428 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1429 syscall(__NR_msgget);
1430 }
1431 #endif
1432
1433 #if defined(__x86_64__) || defined(__arm__)
1434 BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgrcv_SIGSYS,
1435 DEATH_MESSAGE(kSeccompFailureMsg),
1436 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1437 syscall(__NR_msgrcv);
1438 }
1439 #endif
1440
1441 #if defined(__x86_64__) || defined(__arm__)
1442 BPF_DEATH_TEST(NaClNonSfiSandboxTest, msgsnd_SIGSYS,
1443 DEATH_MESSAGE(kSeccompFailureMsg),
1444 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1445 syscall(__NR_msgsnd);
1446 }
1447 #endif
1448
1449 BPF_DEATH_TEST(NaClNonSfiSandboxTest, msync_SIGSYS,
1450 DEATH_MESSAGE(kSeccompFailureMsg),
1451 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1452 syscall(__NR_msync);
1453 }
1454
1455 BPF_DEATH_TEST(NaClNonSfiSandboxTest, munlock_SIGSYS,
1456 DEATH_MESSAGE(kSeccompFailureMsg),
1457 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1458 syscall(__NR_munlock);
1459 }
1460
1461 BPF_DEATH_TEST(NaClNonSfiSandboxTest, munlockall_SIGSYS,
1462 DEATH_MESSAGE(kSeccompFailureMsg),
1463 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1464 syscall(__NR_munlockall);
1465 }
1466
1467 BPF_DEATH_TEST(NaClNonSfiSandboxTest, name_to_handle_at_SIGSYS,
1468 DEATH_MESSAGE(kSeccompFailureMsg),
1469 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1470 syscall(__NR_name_to_handle_at);
1471 }
1472
1473 #if defined(__x86_64__)
1474 BPF_DEATH_TEST(NaClNonSfiSandboxTest, newfstatat_SIGSYS,
1475 DEATH_MESSAGE(kSeccompFailureMsg),
1476 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1477 syscall(__NR_newfstatat);
1478 }
1479 #endif
1480
1481 BPF_DEATH_TEST(NaClNonSfiSandboxTest, nfsservctl_SIGSYS,
1482 DEATH_MESSAGE(kSeccompFailureMsg),
1483 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1484 syscall(__NR_nfsservctl);
1485 }
1486
1487 #if defined(__i386__) || defined(__arm__)
1488 BPF_DEATH_TEST(NaClNonSfiSandboxTest, nice_SIGSYS,
1489 DEATH_MESSAGE(kSeccompFailureMsg),
1490 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1491 syscall(__NR_nice);
1492 }
1493 #endif
1494
1495 #if defined(__i386__)
1496 BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldfstat_SIGSYS,
1497 DEATH_MESSAGE(kSeccompFailureMsg),
1498 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1499 syscall(__NR_oldfstat);
1500 }
1501 #endif
1502
1503 #if defined(__i386__)
1504 BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldlstat_SIGSYS,
1505 DEATH_MESSAGE(kSeccompFailureMsg),
1506 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1507 syscall(__NR_oldlstat);
1508 }
1509 #endif
1510
1511 #if defined(__i386__)
1512 BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldolduname_SIGSYS,
1513 DEATH_MESSAGE(kSeccompFailureMsg),
1514 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1515 syscall(__NR_oldolduname);
1516 }
1517 #endif
1518
1519 #if defined(__i386__)
1520 BPF_DEATH_TEST(NaClNonSfiSandboxTest, oldstat_SIGSYS,
1521 DEATH_MESSAGE(kSeccompFailureMsg),
1522 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1523 syscall(__NR_oldstat);
1524 }
1525 #endif
1526
1527 #if defined(__i386__)
1528 BPF_DEATH_TEST(NaClNonSfiSandboxTest, olduname_SIGSYS,
1529 DEATH_MESSAGE(kSeccompFailureMsg),
1530 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1531 syscall(__NR_olduname);
1532 }
1533 #endif
1534
1535 BPF_DEATH_TEST(NaClNonSfiSandboxTest, open_by_handle_at_SIGSYS,
1536 DEATH_MESSAGE(kSeccompFailureMsg),
1537 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1538 syscall(__NR_open_by_handle_at);
1539 }
1540
1541 BPF_DEATH_TEST(NaClNonSfiSandboxTest, openat_SIGSYS,
1542 DEATH_MESSAGE(kSeccompFailureMsg),
1543 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1544 syscall(__NR_openat);
1545 }
1546
1547 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pause_SIGSYS,
1548 DEATH_MESSAGE(kSeccompFailureMsg),
1549 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1550 syscall(__NR_pause);
1551 }
1552
1553 #if defined(__arm__)
1554 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_iobase_SIGSYS,
1555 DEATH_MESSAGE(kSeccompFailureMsg),
1556 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1557 syscall(__NR_pciconfig_iobase);
1558 }
1559 #endif
1560
1561 #if defined(__arm__)
1562 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_read_SIGSYS,
1563 DEATH_MESSAGE(kSeccompFailureMsg),
1564 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1565 syscall(__NR_pciconfig_read);
1566 }
1567 #endif
1568
1569 #if defined(__arm__)
1570 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pciconfig_write_SIGSYS,
1571 DEATH_MESSAGE(kSeccompFailureMsg),
1572 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1573 syscall(__NR_pciconfig_write);
1574 }
1575 #endif
1576
1577 BPF_DEATH_TEST(NaClNonSfiSandboxTest, perf_event_open_SIGSYS,
1578 DEATH_MESSAGE(kSeccompFailureMsg),
1579 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1580 syscall(__NR_perf_event_open);
1581 }
1582
1583 BPF_DEATH_TEST(NaClNonSfiSandboxTest, personality_SIGSYS,
1584 DEATH_MESSAGE(kSeccompFailureMsg),
1585 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1586 syscall(__NR_personality);
1587 }
1588
1589 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pipe2_SIGSYS,
1590 DEATH_MESSAGE(kSeccompFailureMsg),
1591 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1592 syscall(__NR_pipe2);
1593 }
1594
1595 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pivot_root_SIGSYS,
1596 DEATH_MESSAGE(kSeccompFailureMsg),
1597 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1598 syscall(__NR_pivot_root);
1599 }
1600
1601 BPF_DEATH_TEST(NaClNonSfiSandboxTest, poll_SIGSYS,
1602 DEATH_MESSAGE(kSeccompFailureMsg),
1603 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1604 syscall(__NR_poll);
1605 }
1606
1607 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ppoll_SIGSYS,
1608 DEATH_MESSAGE(kSeccompFailureMsg),
1609 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1610 syscall(__NR_ppoll);
1611 }
1612
1613 BPF_DEATH_TEST(NaClNonSfiSandboxTest, preadv_SIGSYS,
1614 DEATH_MESSAGE(kSeccompFailureMsg),
1615 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1616 syscall(__NR_preadv);
1617 }
1618
1619 BPF_DEATH_TEST(NaClNonSfiSandboxTest, prlimit64_SIGSYS,
1620 DEATH_MESSAGE(kSeccompFailureMsg),
1621 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1622 syscall(__NR_prlimit64);
1623 }
1624
1625 BPF_DEATH_TEST(NaClNonSfiSandboxTest, process_vm_readv_SIGSYS,
1626 DEATH_MESSAGE(kSeccompFailureMsg),
1627 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1628 syscall(__NR_process_vm_readv);
1629 }
1630
1631 BPF_DEATH_TEST(NaClNonSfiSandboxTest, process_vm_writev_SIGSYS,
1632 DEATH_MESSAGE(kSeccompFailureMsg),
1633 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1634 syscall(__NR_process_vm_writev);
1635 }
1636
1637 #if defined(__i386__)
1638 BPF_DEATH_TEST(NaClNonSfiSandboxTest, prof_SIGSYS,
1639 DEATH_MESSAGE(kSeccompFailureMsg),
1640 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1641 syscall(__NR_prof);
1642 }
1643 #endif
1644
1645 #if defined(__i386__)
1646 BPF_DEATH_TEST(NaClNonSfiSandboxTest, profil_SIGSYS,
1647 DEATH_MESSAGE(kSeccompFailureMsg),
1648 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1649 syscall(__NR_profil);
1650 }
1651 #endif
1652
1653 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pselect6_SIGSYS,
1654 DEATH_MESSAGE(kSeccompFailureMsg),
1655 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1656 syscall(__NR_pselect6);
1657 }
1658
1659 #if defined(__i386__) || defined(__x86_64__)
1660 BPF_DEATH_TEST(NaClNonSfiSandboxTest, putpmsg_SIGSYS,
1661 DEATH_MESSAGE(kSeccompFailureMsg),
1662 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1663 syscall(__NR_putpmsg);
1664 }
1665 #endif
1666
1667 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pwrite64_SIGSYS,
1668 DEATH_MESSAGE(kSeccompFailureMsg),
1669 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1670 syscall(__NR_pwrite64);
1671 }
1672
1673 BPF_DEATH_TEST(NaClNonSfiSandboxTest, pwritev_SIGSYS,
1674 DEATH_MESSAGE(kSeccompFailureMsg),
1675 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1676 syscall(__NR_pwritev);
1677 }
1678
1679 #if defined(__i386__) || defined(__x86_64__)
1680 BPF_DEATH_TEST(NaClNonSfiSandboxTest, query_module_SIGSYS,
1681 DEATH_MESSAGE(kSeccompFailureMsg),
1682 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1683 syscall(__NR_query_module);
1684 }
1685 #endif
1686
1687 BPF_DEATH_TEST(NaClNonSfiSandboxTest, quotactl_SIGSYS,
1688 DEATH_MESSAGE(kSeccompFailureMsg),
1689 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1690 syscall(__NR_quotactl);
1691 }
1692
1693 BPF_DEATH_TEST(NaClNonSfiSandboxTest, readahead_SIGSYS,
1694 DEATH_MESSAGE(kSeccompFailureMsg),
1695 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1696 syscall(__NR_readahead);
1697 }
1698
1699 #if defined(__i386__)
1700 BPF_DEATH_TEST(NaClNonSfiSandboxTest, readdir_SIGSYS,
1701 DEATH_MESSAGE(kSeccompFailureMsg),
1702 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1703 syscall(__NR_readdir);
1704 }
1705 #endif
1706
1707 BPF_DEATH_TEST(NaClNonSfiSandboxTest, readlink_SIGSYS,
1708 DEATH_MESSAGE(kSeccompFailureMsg),
1709 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1710 syscall(__NR_readlink);
1711 }
1712
1713 BPF_DEATH_TEST(NaClNonSfiSandboxTest, readlinkat_SIGSYS,
1714 DEATH_MESSAGE(kSeccompFailureMsg),
1715 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1716 syscall(__NR_readlinkat);
1717 }
1718
1719 BPF_DEATH_TEST(NaClNonSfiSandboxTest, readv_SIGSYS,
1720 DEATH_MESSAGE(kSeccompFailureMsg),
1721 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1722 syscall(__NR_readv);
1723 }
1724
1725 BPF_DEATH_TEST(NaClNonSfiSandboxTest, reboot_SIGSYS,
1726 DEATH_MESSAGE(kSeccompFailureMsg),
1727 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1728 syscall(__NR_reboot);
1729 }
1730
1731 #if defined(__arm__)
1732 BPF_DEATH_TEST(NaClNonSfiSandboxTest, recv_SIGSYS,
1733 DEATH_MESSAGE(kSeccompFailureMsg),
1734 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1735 syscall(__NR_recv);
1736 }
1737 #endif
1738
1739 #if defined(__x86_64__) || defined(__arm__)
1740 BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvfrom_SIGSYS,
1741 DEATH_MESSAGE(kSeccompFailureMsg),
1742 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1743 syscall(__NR_recvfrom);
1744 }
1745 #endif
1746
1747 BPF_DEATH_TEST(NaClNonSfiSandboxTest, recvmmsg_SIGSYS,
1748 DEATH_MESSAGE(kSeccompFailureMsg),
1749 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1750 syscall(__NR_recvmmsg);
1751 }
1752
1753 BPF_DEATH_TEST(NaClNonSfiSandboxTest, remap_file_pages_SIGSYS,
1754 DEATH_MESSAGE(kSeccompFailureMsg),
1755 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1756 syscall(__NR_remap_file_pages);
1757 }
1758
1759 BPF_DEATH_TEST(NaClNonSfiSandboxTest, removexattr_SIGSYS,
1760 DEATH_MESSAGE(kSeccompFailureMsg),
1761 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1762 syscall(__NR_removexattr);
1763 }
1764
1765 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rename_SIGSYS,
1766 DEATH_MESSAGE(kSeccompFailureMsg),
1767 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1768 syscall(__NR_rename);
1769 }
1770
1771 BPF_DEATH_TEST(NaClNonSfiSandboxTest, renameat_SIGSYS,
1772 DEATH_MESSAGE(kSeccompFailureMsg),
1773 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1774 syscall(__NR_renameat);
1775 }
1776
1777 BPF_DEATH_TEST(NaClNonSfiSandboxTest, request_key_SIGSYS,
1778 DEATH_MESSAGE(kSeccompFailureMsg),
1779 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1780 syscall(__NR_request_key);
1781 }
1782
1783 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rmdir_SIGSYS,
1784 DEATH_MESSAGE(kSeccompFailureMsg),
1785 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1786 syscall(__NR_rmdir);
1787 }
1788
1789 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigaction_SIGSYS,
1790 DEATH_MESSAGE(kSeccompFailureMsg),
1791 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1792 syscall(__NR_rt_sigaction);
1793 }
1794
1795 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigpending_SIGSYS,
1796 DEATH_MESSAGE(kSeccompFailureMsg),
1797 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1798 syscall(__NR_rt_sigpending);
1799 }
1800
1801 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigprocmask_SIGSYS,
1802 DEATH_MESSAGE(kSeccompFailureMsg),
1803 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1804 syscall(__NR_rt_sigprocmask);
1805 }
1806
1807 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigqueueinfo_SIGSYS,
1808 DEATH_MESSAGE(kSeccompFailureMsg),
1809 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1810 syscall(__NR_rt_sigqueueinfo);
1811 }
1812
1813 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigreturn_SIGSYS,
1814 DEATH_MESSAGE(kSeccompFailureMsg),
1815 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1816 syscall(__NR_rt_sigreturn);
1817 }
1818
1819 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigsuspend_SIGSYS,
1820 DEATH_MESSAGE(kSeccompFailureMsg),
1821 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1822 syscall(__NR_rt_sigsuspend);
1823 }
1824
1825 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_sigtimedwait_SIGSYS,
1826 DEATH_MESSAGE(kSeccompFailureMsg),
1827 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1828 syscall(__NR_rt_sigtimedwait);
1829 }
1830
1831 BPF_DEATH_TEST(NaClNonSfiSandboxTest, rt_tgsigqueueinfo_SIGSYS,
1832 DEATH_MESSAGE(kSeccompFailureMsg),
1833 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1834 syscall(__NR_rt_tgsigqueueinfo);
1835 }
1836
1837 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_get_priority_max_SIGSYS,
1838 DEATH_MESSAGE(kSeccompFailureMsg),
1839 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1840 syscall(__NR_sched_get_priority_max);
1841 }
1842
1843 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_get_priority_min_SIGSYS,
1844 DEATH_MESSAGE(kSeccompFailureMsg),
1845 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1846 syscall(__NR_sched_get_priority_min);
1847 }
1848
1849 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getaffinity_SIGSYS,
1850 DEATH_MESSAGE(kSeccompFailureMsg),
1851 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1852 syscall(__NR_sched_getaffinity);
1853 }
1854
1855 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getparam_SIGSYS,
1856 DEATH_MESSAGE(kSeccompFailureMsg),
1857 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1858 syscall(__NR_sched_getparam);
1859 }
1860
1861 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_getscheduler_SIGSYS,
1862 DEATH_MESSAGE(kSeccompFailureMsg),
1863 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1864 syscall(__NR_sched_getscheduler);
1865 }
1866
1867 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_rr_get_interval_SIGSYS,
1868 DEATH_MESSAGE(kSeccompFailureMsg),
1869 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1870 syscall(__NR_sched_rr_get_interval);
1871 }
1872
1873 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setaffinity_SIGSYS,
1874 DEATH_MESSAGE(kSeccompFailureMsg),
1875 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1876 syscall(__NR_sched_setaffinity);
1877 }
1878
1879 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setparam_SIGSYS,
1880 DEATH_MESSAGE(kSeccompFailureMsg),
1881 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1882 syscall(__NR_sched_setparam);
1883 }
1884
1885 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sched_setscheduler_SIGSYS,
1886 DEATH_MESSAGE(kSeccompFailureMsg),
1887 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1888 syscall(__NR_sched_setscheduler);
1889 }
1890
1891 #if defined(__x86_64__)
1892 BPF_DEATH_TEST(NaClNonSfiSandboxTest, security_SIGSYS,
1893 DEATH_MESSAGE(kSeccompFailureMsg),
1894 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1895 syscall(__NR_security);
1896 }
1897 #endif
1898
1899 #if defined(__i386__) || defined(__x86_64__)
1900 BPF_DEATH_TEST(NaClNonSfiSandboxTest, select_SIGSYS,
1901 DEATH_MESSAGE(kSeccompFailureMsg),
1902 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1903 syscall(__NR_select);
1904 }
1905 #endif
1906
1907 #if defined(__x86_64__) || defined(__arm__)
1908 BPF_DEATH_TEST(NaClNonSfiSandboxTest, semctl_SIGSYS,
1909 DEATH_MESSAGE(kSeccompFailureMsg),
1910 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1911 syscall(__NR_semctl);
1912 }
1913 #endif
1914
1915 #if defined(__x86_64__) || defined(__arm__)
1916 BPF_DEATH_TEST(NaClNonSfiSandboxTest, semget_SIGSYS,
1917 DEATH_MESSAGE(kSeccompFailureMsg),
1918 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1919 syscall(__NR_semget);
1920 }
1921 #endif
1922
1923 #if defined(__x86_64__) || defined(__arm__)
1924 BPF_DEATH_TEST(NaClNonSfiSandboxTest, semop_SIGSYS,
1925 DEATH_MESSAGE(kSeccompFailureMsg),
1926 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1927 syscall(__NR_semop);
1928 }
1929 #endif
1930
1931 #if defined(__x86_64__) || defined(__arm__)
1932 BPF_DEATH_TEST(NaClNonSfiSandboxTest, semtimedop_SIGSYS,
1933 DEATH_MESSAGE(kSeccompFailureMsg),
1934 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1935 syscall(__NR_semtimedop);
1936 }
1937 #endif
1938
1939 #if defined(__arm__)
1940 BPF_DEATH_TEST(NaClNonSfiSandboxTest, send_SIGSYS,
1941 DEATH_MESSAGE(kSeccompFailureMsg),
1942 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1943 syscall(__NR_send);
1944 }
1945 #endif
1946
1947 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendfile_SIGSYS,
1948 DEATH_MESSAGE(kSeccompFailureMsg),
1949 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1950 syscall(__NR_sendfile);
1951 }
1952
1953 #if defined(__i386__) || defined(__arm__)
1954 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendfile64_SIGSYS,
1955 DEATH_MESSAGE(kSeccompFailureMsg),
1956 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1957 syscall(__NR_sendfile64);
1958 }
1959 #endif
1960
1961 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendmmsg_SIGSYS,
1962 DEATH_MESSAGE(kSeccompFailureMsg),
1963 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1964 syscall(__NR_sendmmsg);
1965 }
1966
1967 #if defined(__x86_64__) || defined(__arm__)
1968 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sendto_SIGSYS,
1969 DEATH_MESSAGE(kSeccompFailureMsg),
1970 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1971 syscall(__NR_sendto);
1972 }
1973 #endif
1974
1975 BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_mempolicy_SIGSYS,
1976 DEATH_MESSAGE(kSeccompFailureMsg),
1977 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1978 syscall(__NR_set_mempolicy);
1979 }
1980
1981 #if defined(__i386__) || defined(__x86_64__)
1982 BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_thread_area_SIGSYS,
1983 DEATH_MESSAGE(kSeccompFailureMsg),
1984 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1985 syscall(__NR_set_thread_area);
1986 }
1987 #endif
1988
1989 BPF_DEATH_TEST(NaClNonSfiSandboxTest, set_tid_address_SIGSYS,
1990 DEATH_MESSAGE(kSeccompFailureMsg),
1991 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1992 syscall(__NR_set_tid_address);
1993 }
1994
1995 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setdomainname_SIGSYS,
1996 DEATH_MESSAGE(kSeccompFailureMsg),
1997 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
1998 syscall(__NR_setdomainname);
1999 }
2000
2001 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsgid_SIGSYS,
2002 DEATH_MESSAGE(kSeccompFailureMsg),
2003 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2004 syscall(__NR_setfsgid);
2005 }
2006
2007 #if defined(__i386__) || defined(__arm__)
2008 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsgid32_SIGSYS,
2009 DEATH_MESSAGE(kSeccompFailureMsg),
2010 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2011 syscall(__NR_setfsgid32);
2012 }
2013 #endif
2014
2015 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsuid_SIGSYS,
2016 DEATH_MESSAGE(kSeccompFailureMsg),
2017 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2018 syscall(__NR_setfsuid);
2019 }
2020
2021 #if defined(__i386__) || defined(__arm__)
2022 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setfsuid32_SIGSYS,
2023 DEATH_MESSAGE(kSeccompFailureMsg),
2024 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2025 syscall(__NR_setfsuid32);
2026 }
2027 #endif
2028
2029 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgid_SIGSYS,
2030 DEATH_MESSAGE(kSeccompFailureMsg),
2031 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2032 syscall(__NR_setgid);
2033 }
2034
2035 #if defined(__i386__) || defined(__arm__)
2036 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgid32_SIGSYS,
2037 DEATH_MESSAGE(kSeccompFailureMsg),
2038 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2039 syscall(__NR_setgid32);
2040 }
2041 #endif
2042
2043 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgroups_SIGSYS,
2044 DEATH_MESSAGE(kSeccompFailureMsg),
2045 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2046 syscall(__NR_setgroups);
2047 }
2048
2049 #if defined(__i386__) || defined(__arm__)
2050 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setgroups32_SIGSYS,
2051 DEATH_MESSAGE(kSeccompFailureMsg),
2052 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2053 syscall(__NR_setgroups32);
2054 }
2055 #endif
2056
2057 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sethostname_SIGSYS,
2058 DEATH_MESSAGE(kSeccompFailureMsg),
2059 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2060 syscall(__NR_sethostname);
2061 }
2062
2063 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setitimer_SIGSYS,
2064 DEATH_MESSAGE(kSeccompFailureMsg),
2065 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2066 syscall(__NR_setitimer);
2067 }
2068
2069 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setns_SIGSYS,
2070 DEATH_MESSAGE(kSeccompFailureMsg),
2071 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2072 syscall(__NR_setns);
2073 }
2074
2075 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setpgid_SIGSYS,
2076 DEATH_MESSAGE(kSeccompFailureMsg),
2077 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2078 syscall(__NR_setpgid);
2079 }
2080
2081 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setpriority_SIGSYS,
2082 DEATH_MESSAGE(kSeccompFailureMsg),
2083 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2084 syscall(__NR_setpriority);
2085 }
2086
2087 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setregid_SIGSYS,
2088 DEATH_MESSAGE(kSeccompFailureMsg),
2089 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2090 syscall(__NR_setregid);
2091 }
2092
2093 #if defined(__i386__) || defined(__arm__)
2094 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setregid32_SIGSYS,
2095 DEATH_MESSAGE(kSeccompFailureMsg),
2096 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2097 syscall(__NR_setregid32);
2098 }
2099 #endif
2100
2101 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresgid_SIGSYS,
2102 DEATH_MESSAGE(kSeccompFailureMsg),
2103 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2104 syscall(__NR_setresgid);
2105 }
2106
2107 #if defined(__i386__) || defined(__arm__)
2108 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresgid32_SIGSYS,
2109 DEATH_MESSAGE(kSeccompFailureMsg),
2110 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2111 syscall(__NR_setresgid32);
2112 }
2113 #endif
2114
2115 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresuid_SIGSYS,
2116 DEATH_MESSAGE(kSeccompFailureMsg),
2117 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2118 syscall(__NR_setresuid);
2119 }
2120
2121 #if defined(__i386__) || defined(__arm__)
2122 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setresuid32_SIGSYS,
2123 DEATH_MESSAGE(kSeccompFailureMsg),
2124 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2125 syscall(__NR_setresuid32);
2126 }
2127 #endif
2128
2129 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setreuid_SIGSYS,
2130 DEATH_MESSAGE(kSeccompFailureMsg),
2131 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2132 syscall(__NR_setreuid);
2133 }
2134
2135 #if defined(__i386__) || defined(__arm__)
2136 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setreuid32_SIGSYS,
2137 DEATH_MESSAGE(kSeccompFailureMsg),
2138 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2139 syscall(__NR_setreuid32);
2140 }
2141 #endif
2142
2143 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setrlimit_SIGSYS,
2144 DEATH_MESSAGE(kSeccompFailureMsg),
2145 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2146 syscall(__NR_setrlimit);
2147 }
2148
2149 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsid_SIGSYS,
2150 DEATH_MESSAGE(kSeccompFailureMsg),
2151 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2152 syscall(__NR_setsid);
2153 }
2154
2155 #if defined(__x86_64__) || defined(__arm__)
2156 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setsockopt_SIGSYS,
2157 DEATH_MESSAGE(kSeccompFailureMsg),
2158 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2159 syscall(__NR_setsockopt);
2160 }
2161 #endif
2162
2163 BPF_DEATH_TEST(NaClNonSfiSandboxTest, settimeofday_SIGSYS,
2164 DEATH_MESSAGE(kSeccompFailureMsg),
2165 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2166 syscall(__NR_settimeofday);
2167 }
2168
2169 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setuid_SIGSYS,
2170 DEATH_MESSAGE(kSeccompFailureMsg),
2171 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2172 syscall(__NR_setuid);
2173 }
2174
2175 #if defined(__i386__) || defined(__arm__)
2176 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setuid32_SIGSYS,
2177 DEATH_MESSAGE(kSeccompFailureMsg),
2178 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2179 syscall(__NR_setuid32);
2180 }
2181 #endif
2182
2183 BPF_DEATH_TEST(NaClNonSfiSandboxTest, setxattr_SIGSYS,
2184 DEATH_MESSAGE(kSeccompFailureMsg),
2185 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2186 syscall(__NR_setxattr);
2187 }
2188
2189 #if defined(__i386__)
2190 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sgetmask_SIGSYS,
2191 DEATH_MESSAGE(kSeccompFailureMsg),
2192 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2193 syscall(__NR_sgetmask);
2194 }
2195 #endif
2196
2197 #if defined(__x86_64__) || defined(__arm__)
2198 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmat_SIGSYS,
2199 DEATH_MESSAGE(kSeccompFailureMsg),
2200 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2201 syscall(__NR_shmat);
2202 }
2203 #endif
2204
2205 #if defined(__x86_64__) || defined(__arm__)
2206 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmctl_SIGSYS,
2207 DEATH_MESSAGE(kSeccompFailureMsg),
2208 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2209 syscall(__NR_shmctl);
2210 }
2211 #endif
2212
2213 #if defined(__x86_64__) || defined(__arm__)
2214 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmdt_SIGSYS,
2215 DEATH_MESSAGE(kSeccompFailureMsg),
2216 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2217 syscall(__NR_shmdt);
2218 }
2219 #endif
2220
2221 #if defined(__x86_64__) || defined(__arm__)
2222 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shmget_SIGSYS,
2223 DEATH_MESSAGE(kSeccompFailureMsg),
2224 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2225 syscall(__NR_shmget);
2226 }
2227 #endif
2228
2229 #if defined(__x86_64__) || defined(__arm__)
2230 BPF_DEATH_TEST(NaClNonSfiSandboxTest, shutdown_SIGSYS,
2231 DEATH_MESSAGE(kSeccompFailureMsg),
2232 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2233 syscall(__NR_shutdown);
2234 }
2235 #endif
2236
2237 #if defined(__i386__) || defined(__arm__)
2238 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigaction_SIGSYS,
2239 DEATH_MESSAGE(kSeccompFailureMsg),
2240 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2241 syscall(__NR_sigaction);
2242 }
2243 #endif
2244
2245 #if defined(__i386__)
2246 BPF_DEATH_TEST(NaClNonSfiSandboxTest, signal_SIGSYS,
2247 DEATH_MESSAGE(kSeccompFailureMsg),
2248 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2249 syscall(__NR_signal);
2250 }
2251 #endif
2252
2253 BPF_DEATH_TEST(NaClNonSfiSandboxTest, signalfd_SIGSYS,
2254 DEATH_MESSAGE(kSeccompFailureMsg),
2255 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2256 syscall(__NR_signalfd);
2257 }
2258
2259 BPF_DEATH_TEST(NaClNonSfiSandboxTest, signalfd4_SIGSYS,
2260 DEATH_MESSAGE(kSeccompFailureMsg),
2261 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2262 syscall(__NR_signalfd4);
2263 }
2264
2265 #if defined(__i386__) || defined(__arm__)
2266 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigpending_SIGSYS,
2267 DEATH_MESSAGE(kSeccompFailureMsg),
2268 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2269 syscall(__NR_sigpending);
2270 }
2271 #endif
2272
2273 #if defined(__i386__) || defined(__arm__)
2274 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigprocmask_SIGSYS,
2275 DEATH_MESSAGE(kSeccompFailureMsg),
2276 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2277 syscall(__NR_sigprocmask);
2278 }
2279 #endif
2280
2281 #if defined(__i386__) || defined(__arm__)
2282 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigreturn_SIGSYS,
2283 DEATH_MESSAGE(kSeccompFailureMsg),
2284 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2285 syscall(__NR_sigreturn);
2286 }
2287 #endif
2288
2289 #if defined(__i386__) || defined(__arm__)
2290 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sigsuspend_SIGSYS,
2291 DEATH_MESSAGE(kSeccompFailureMsg),
2292 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2293 syscall(__NR_sigsuspend);
2294 }
2295 #endif
2296
2297 #if defined(__x86_64__) || defined(__arm__)
2298 BPF_DEATH_TEST(NaClNonSfiSandboxTest, socket_SIGSYS,
2299 DEATH_MESSAGE(kSeccompFailureMsg),
2300 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2301 syscall(__NR_socket);
2302 }
2303 #endif
2304
2305 BPF_DEATH_TEST(NaClNonSfiSandboxTest, splice_SIGSYS,
2306 DEATH_MESSAGE(kSeccompFailureMsg),
2307 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2308 syscall(__NR_splice);
2309 }
2310
2311 #if defined(__i386__)
2312 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ssetmask_SIGSYS,
2313 DEATH_MESSAGE(kSeccompFailureMsg),
2314 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2315 syscall(__NR_ssetmask);
2316 }
2317 #endif
2318
2319 BPF_DEATH_TEST(NaClNonSfiSandboxTest, stat_SIGSYS,
2320 DEATH_MESSAGE(kSeccompFailureMsg),
2321 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2322 syscall(__NR_stat);
2323 }
2324
2325 #if defined(__i386__) || defined(__arm__)
2326 BPF_DEATH_TEST(NaClNonSfiSandboxTest, stat64_SIGSYS,
2327 DEATH_MESSAGE(kSeccompFailureMsg),
2328 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2329 syscall(__NR_stat64);
2330 }
2331 #endif
2332
2333 BPF_DEATH_TEST(NaClNonSfiSandboxTest, statfs_SIGSYS,
2334 DEATH_MESSAGE(kSeccompFailureMsg),
2335 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2336 syscall(__NR_statfs);
2337 }
2338
2339 #if defined(__i386__) || defined(__arm__)
2340 BPF_DEATH_TEST(NaClNonSfiSandboxTest, statfs64_SIGSYS,
2341 DEATH_MESSAGE(kSeccompFailureMsg),
2342 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2343 syscall(__NR_statfs64);
2344 }
2345 #endif
2346
2347 #if defined(__i386__)
2348 BPF_DEATH_TEST(NaClNonSfiSandboxTest, stime_SIGSYS,
2349 DEATH_MESSAGE(kSeccompFailureMsg),
2350 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2351 syscall(__NR_stime);
2352 }
2353 #endif
2354
2355 #if defined(__i386__)
2356 BPF_DEATH_TEST(NaClNonSfiSandboxTest, stty_SIGSYS,
2357 DEATH_MESSAGE(kSeccompFailureMsg),
2358 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2359 syscall(__NR_stty);
2360 }
2361 #endif
2362
2363 BPF_DEATH_TEST(NaClNonSfiSandboxTest, swapoff_SIGSYS,
2364 DEATH_MESSAGE(kSeccompFailureMsg),
2365 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2366 syscall(__NR_swapoff);
2367 }
2368
2369 BPF_DEATH_TEST(NaClNonSfiSandboxTest, swapon_SIGSYS,
2370 DEATH_MESSAGE(kSeccompFailureMsg),
2371 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2372 syscall(__NR_swapon);
2373 }
2374
2375 BPF_DEATH_TEST(NaClNonSfiSandboxTest, symlink_SIGSYS,
2376 DEATH_MESSAGE(kSeccompFailureMsg),
2377 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2378 syscall(__NR_symlink);
2379 }
2380
2381 BPF_DEATH_TEST(NaClNonSfiSandboxTest, symlinkat_SIGSYS,
2382 DEATH_MESSAGE(kSeccompFailureMsg),
2383 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2384 syscall(__NR_symlinkat);
2385 }
2386
2387 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_SIGSYS,
2388 DEATH_MESSAGE(kSeccompFailureMsg),
2389 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2390 syscall(__NR_sync);
2391 }
2392
2393 #if defined(__i386__) || defined(__x86_64__)
2394 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_file_range_SIGSYS,
2395 DEATH_MESSAGE(kSeccompFailureMsg),
2396 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2397 syscall(__NR_sync_file_range);
2398 }
2399 #endif
2400
2401 #if defined(__arm__)
2402 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sync_file_range2_SIGSYS,
2403 DEATH_MESSAGE(kSeccompFailureMsg),
2404 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2405 syscall(__NR_sync_file_range2);
2406 }
2407 #endif
2408
2409 BPF_DEATH_TEST(NaClNonSfiSandboxTest, syncfs_SIGSYS,
2410 DEATH_MESSAGE(kSeccompFailureMsg),
2411 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2412 syscall(__NR_syncfs);
2413 }
2414
2415 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sysfs_SIGSYS,
2416 DEATH_MESSAGE(kSeccompFailureMsg),
2417 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2418 syscall(__NR_sysfs);
2419 }
2420
2421 BPF_DEATH_TEST(NaClNonSfiSandboxTest, sysinfo_SIGSYS,
2422 DEATH_MESSAGE(kSeccompFailureMsg),
2423 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2424 syscall(__NR_sysinfo);
2425 }
2426
2427 BPF_DEATH_TEST(NaClNonSfiSandboxTest, syslog_SIGSYS,
2428 DEATH_MESSAGE(kSeccompFailureMsg),
2429 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2430 syscall(__NR_syslog);
2431 }
2432
2433 BPF_DEATH_TEST(NaClNonSfiSandboxTest, tee_SIGSYS,
2434 DEATH_MESSAGE(kSeccompFailureMsg),
2435 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2436 syscall(__NR_tee);
2437 }
2438
2439 BPF_DEATH_TEST(NaClNonSfiSandboxTest, tgkill_SIGSYS,
2440 DEATH_MESSAGE(kSeccompFailureMsg),
2441 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2442 syscall(__NR_tgkill);
2443 }
2444
2445 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_create_SIGSYS,
2446 DEATH_MESSAGE(kSeccompFailureMsg),
2447 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2448 syscall(__NR_timer_create);
2449 }
2450
2451 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_delete_SIGSYS,
2452 DEATH_MESSAGE(kSeccompFailureMsg),
2453 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2454 syscall(__NR_timer_delete);
2455 }
2456
2457 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_getoverrun_SIGSYS,
2458 DEATH_MESSAGE(kSeccompFailureMsg),
2459 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2460 syscall(__NR_timer_getoverrun);
2461 }
2462
2463 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_gettime_SIGSYS,
2464 DEATH_MESSAGE(kSeccompFailureMsg),
2465 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2466 syscall(__NR_timer_gettime);
2467 }
2468
2469 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timer_settime_SIGSYS,
2470 DEATH_MESSAGE(kSeccompFailureMsg),
2471 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2472 syscall(__NR_timer_settime);
2473 }
2474
2475 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_create_SIGSYS,
2476 DEATH_MESSAGE(kSeccompFailureMsg),
2477 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2478 syscall(__NR_timerfd_create);
2479 }
2480
2481 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_gettime_SIGSYS,
2482 DEATH_MESSAGE(kSeccompFailureMsg),
2483 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2484 syscall(__NR_timerfd_gettime);
2485 }
2486
2487 BPF_DEATH_TEST(NaClNonSfiSandboxTest, timerfd_settime_SIGSYS,
2488 DEATH_MESSAGE(kSeccompFailureMsg),
2489 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2490 syscall(__NR_timerfd_settime);
2491 }
2492
2493 BPF_DEATH_TEST(NaClNonSfiSandboxTest, tkill_SIGSYS,
2494 DEATH_MESSAGE(kSeccompFailureMsg),
2495 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2496 syscall(__NR_tkill);
2497 }
2498
2499 BPF_DEATH_TEST(NaClNonSfiSandboxTest, truncate_SIGSYS,
2500 DEATH_MESSAGE(kSeccompFailureMsg),
2501 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2502 syscall(__NR_truncate);
2503 }
2504
2505 #if defined(__i386__) || defined(__arm__)
2506 BPF_DEATH_TEST(NaClNonSfiSandboxTest, truncate64_SIGSYS,
2507 DEATH_MESSAGE(kSeccompFailureMsg),
2508 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2509 syscall(__NR_truncate64);
2510 }
2511 #endif
2512
2513 #if defined(__x86_64__)
2514 BPF_DEATH_TEST(NaClNonSfiSandboxTest, tuxcall_SIGSYS,
2515 DEATH_MESSAGE(kSeccompFailureMsg),
2516 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2517 syscall(__NR_tuxcall);
2518 }
2519 #endif
2520
2521 #if defined(__i386__) || defined(__arm__)
2522 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ugetrlimit_SIGSYS,
2523 DEATH_MESSAGE(kSeccompFailureMsg),
2524 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2525 syscall(__NR_ugetrlimit);
2526 }
2527 #endif
2528
2529 #if defined(__i386__)
2530 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ulimit_SIGSYS,
2531 DEATH_MESSAGE(kSeccompFailureMsg),
2532 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2533 syscall(__NR_ulimit);
2534 }
2535 #endif
2536
2537 BPF_DEATH_TEST(NaClNonSfiSandboxTest, umask_SIGSYS,
2538 DEATH_MESSAGE(kSeccompFailureMsg),
2539 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2540 syscall(__NR_umask);
2541 }
2542
2543 #if defined(__i386__)
2544 BPF_DEATH_TEST(NaClNonSfiSandboxTest, umount_SIGSYS,
2545 DEATH_MESSAGE(kSeccompFailureMsg),
2546 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2547 syscall(__NR_umount);
2548 }
2549 #endif
2550
2551 BPF_DEATH_TEST(NaClNonSfiSandboxTest, umount2_SIGSYS,
2552 DEATH_MESSAGE(kSeccompFailureMsg),
2553 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2554 syscall(__NR_umount2);
2555 }
2556
2557 BPF_DEATH_TEST(NaClNonSfiSandboxTest, uname_SIGSYS,
2558 DEATH_MESSAGE(kSeccompFailureMsg),
2559 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2560 syscall(__NR_uname);
2561 }
2562
2563 BPF_DEATH_TEST(NaClNonSfiSandboxTest, unlink_SIGSYS,
2564 DEATH_MESSAGE(kSeccompFailureMsg),
2565 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2566 syscall(__NR_unlink);
2567 }
2568
2569 BPF_DEATH_TEST(NaClNonSfiSandboxTest, unlinkat_SIGSYS,
2570 DEATH_MESSAGE(kSeccompFailureMsg),
2571 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2572 syscall(__NR_unlinkat);
2573 }
2574
2575 BPF_DEATH_TEST(NaClNonSfiSandboxTest, unshare_SIGSYS,
2576 DEATH_MESSAGE(kSeccompFailureMsg),
2577 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2578 syscall(__NR_unshare);
2579 }
2580
2581 BPF_DEATH_TEST(NaClNonSfiSandboxTest, uselib_SIGSYS,
2582 DEATH_MESSAGE(kSeccompFailureMsg),
2583 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2584 syscall(__NR_uselib);
2585 }
2586
2587 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ustat_SIGSYS,
2588 DEATH_MESSAGE(kSeccompFailureMsg),
2589 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2590 syscall(__NR_ustat);
2591 }
2592
2593 #if defined(__i386__) || defined(__x86_64__)
2594 BPF_DEATH_TEST(NaClNonSfiSandboxTest, utime_SIGSYS,
2595 DEATH_MESSAGE(kSeccompFailureMsg),
2596 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2597 syscall(__NR_utime);
2598 }
2599 #endif
2600
2601 BPF_DEATH_TEST(NaClNonSfiSandboxTest, utimensat_SIGSYS,
2602 DEATH_MESSAGE(kSeccompFailureMsg),
2603 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2604 syscall(__NR_utimensat);
2605 }
2606
2607 BPF_DEATH_TEST(NaClNonSfiSandboxTest, utimes_SIGSYS,
2608 DEATH_MESSAGE(kSeccompFailureMsg),
2609 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2610 syscall(__NR_utimes);
2611 }
2612
2613 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vfork_SIGSYS,
2614 DEATH_MESSAGE(kSeccompFailureMsg),
2615 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2616 syscall(__NR_vfork);
2617 }
2618
2619 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vhangup_SIGSYS,
2620 DEATH_MESSAGE(kSeccompFailureMsg),
2621 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2622 syscall(__NR_vhangup);
2623 }
2624
2625 #if defined(__i386__)
2626 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vm86_SIGSYS,
2627 DEATH_MESSAGE(kSeccompFailureMsg),
2628 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2629 syscall(__NR_vm86);
2630 }
2631 #endif
2632
2633 #if defined(__i386__)
2634 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vm86old_SIGSYS,
2635 DEATH_MESSAGE(kSeccompFailureMsg),
2636 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2637 syscall(__NR_vm86old);
2638 }
2639 #endif
2640
2641 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vmsplice_SIGSYS,
2642 DEATH_MESSAGE(kSeccompFailureMsg),
2643 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2644 syscall(__NR_vmsplice);
2645 }
2646
2647 BPF_DEATH_TEST(NaClNonSfiSandboxTest, vserver_SIGSYS,
2648 DEATH_MESSAGE(kSeccompFailureMsg),
2649 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2650 syscall(__NR_vserver);
2651 }
2652
2653 BPF_DEATH_TEST(NaClNonSfiSandboxTest, wait4_SIGSYS,
2654 DEATH_MESSAGE(kSeccompFailureMsg),
2655 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2656 syscall(__NR_wait4);
2657 }
2658
2659 BPF_DEATH_TEST(NaClNonSfiSandboxTest, waitid_SIGSYS,
2660 DEATH_MESSAGE(kSeccompFailureMsg),
2661 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2662 syscall(__NR_waitid);
2663 }
2664
2665 #if defined(__i386__)
2666 BPF_DEATH_TEST(NaClNonSfiSandboxTest, waitpid_SIGSYS,
2667 DEATH_MESSAGE(kSeccompFailureMsg),
2668 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2669 syscall(__NR_waitpid);
2670 }
2671 #endif
2672
2673 BPF_DEATH_TEST(NaClNonSfiSandboxTest, writev_SIGSYS,
2674 DEATH_MESSAGE(kSeccompFailureMsg),
2675 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2676 syscall(__NR_writev);
2677 }
2678
2679 // ARM specific syscalls.
2680 #if defined(__arm__)
2681 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_breakpoint_SIGSYS,
2682 DEATH_MESSAGE(kSeccompFailureMsg),
2683 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2684 syscall(__ARM_NR_breakpoint);
2685 }
2686
2687 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_usr26_SIGSYS,
2688 DEATH_MESSAGE(kSeccompFailureMsg),
2689 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2690 syscall(__ARM_NR_usr26);
2691 }
2692
2693 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_usr32_SIGSYS,
2694 DEATH_MESSAGE(kSeccompFailureMsg),
2695 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2696 syscall(__ARM_NR_usr32);
2697 }
2698
2699 BPF_DEATH_TEST(NaClNonSfiSandboxTest, ARM_set_tls_SIGSYS,
2700 DEATH_MESSAGE(kSeccompFailureMsg),
2701 nacl::nonsfi::NaClNonSfiBPFSandboxPolicy::EvaluateSyscallImpl) {
2702 syscall(__ARM_NR_set_tls);
2703 }
2704 #endif
OLDNEW
« components/nacl/loader/nonsfi/nonsfi_sandbox.h ('K') | « components/nacl/loader/nonsfi/nonsfi_sandbox.cc ('k') | sandbox/linux/sandbox_linux.gypi » ('j') | sandbox/linux/seccomp-bpf/bpf_tests.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698