sandbox: Add Arm64 support for seccomp-BPF

sandbox/linux/seccomp-bpf/syscall_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/linux/seccomp-bpf/syscall.h"
 
 #include <asm/unistd.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
@@ skipping 23 matching lines @@
 #endif
 
 TEST(Syscall, InvalidCallReturnsENOSYS) {
   EXPECT_EQ(-ENOSYS, Syscall::InvalidCall());
 }
 
 TEST(Syscall, WellKnownEntryPoint) {
 // Test that Syscall::Call(-1) is handled specially. Don't do this on ARM,
 // where syscall(-1) crashes with SIGILL. Not running the test is fine, as we
 // are still testing ARM code in the next set of tests.
-#if !defined(__arm__)
+#if !defined(__arm__) && !defined(__aarch64__)
   EXPECT_NE(Syscall::Call(-1), syscall(-1));
 #endif
 
 // If possible, test that Syscall::Call(-1) returns the address right
 // after
 // a kernel entry point.
 #if defined(__i386__)
   EXPECT_EQ(0x80CDu, ((uint16_t*)Syscall::Call(-1))[-1]);  // INT 0x80
 #elif defined(__x86_64__)
   EXPECT_EQ(0x050Fu, ((uint16_t*)Syscall::Call(-1))[-1]);  // SYSCALL
 #elif defined(__arm__)
 #if defined(__thumb__)
   EXPECT_EQ(0xDF00u, ((uint16_t*)Syscall::Call(-1))[-1]);  // SWI 0
 #else
   EXPECT_EQ(0xEF000000u, ((uint32_t*)Syscall::Call(-1))[-1]);  // SVC 0
 #endif
 #elif defined(__mips__)
   // Opcode for MIPS sycall is in the lower 16-bits
   EXPECT_EQ(0x0cu, (((uint32_t*)Syscall::Call(-1))[-1]) & 0x0000FFFF);
+#elif defined(__aarch64__)
+  EXPECT_EQ(0xD4000001u, ((uint32_t*)Syscall::Call(-1))[-1]);  // SVC 0
 #else
 #warning Incomplete test case; need port for target platform
 #endif
 }
 
 TEST(Syscall, TrivialSyscallNoArgs) {
   // Test that we can do basic system calls
   EXPECT_EQ(Syscall::Call(__NR_getpid), syscall(__NR_getpid));
 }
 
@@ skipping 72 matching lines @@
   BPF_ASSERT((*BPF_AUX)[0] == static_cast<uint64_t>(syscall_args[0]));
   BPF_ASSERT((*BPF_AUX)[1] == static_cast<uint64_t>(syscall_args[1]));
   BPF_ASSERT((*BPF_AUX)[2] == static_cast<uint64_t>(syscall_args[2]));
   BPF_ASSERT((*BPF_AUX)[3] == static_cast<uint64_t>(syscall_args[3]));
   BPF_ASSERT((*BPF_AUX)[4] == static_cast<uint64_t>(syscall_args[4]));
   BPF_ASSERT((*BPF_AUX)[5] == static_cast<uint64_t>(syscall_args[5]));
 }
 
 TEST(Syscall, ComplexSyscallSixArgs) {
   int fd;
-  ASSERT_LE(0, fd = Syscall::Call(__NR_open, "/dev/null", O_RDWR, 0L));
+  ASSERT_LE(0,
+            fd = Syscall::Call(__NR_openat, AT_FDCWD, "/dev/null", O_RDWR, 0L));
 
   // Use mmap() to allocate some read-only memory
   char* addr0;
   ASSERT_NE(
       (char*)NULL,
       addr0 = reinterpret_cast<char*>(Syscall::Call(kMMapNr,
                                                     (void*)NULL,
                                                     4096,
                                                     PROT_READ,
                                                     MAP_PRIVATE | MAP_ANONYMOUS,
@@ skipping 12 matching lines @@
                               fd,
                               0L)));
   ++*addr1;  // This should not seg fault
 
   // Clean up
   EXPECT_EQ(0, Syscall::Call(__NR_munmap, addr1, 4096L));
   EXPECT_EQ(0, IGNORE_EINTR(Syscall::Call(__NR_close, fd)));
 
   // Check that the offset argument (i.e. the sixth argument) is processed
   // correctly.
-  ASSERT_GE(fd = Syscall::Call(__NR_open, "/proc/self/exe", O_RDONLY, 0L), 0);
+  ASSERT_GE(
+      fd = Syscall::Call(__NR_openat, AT_FDCWD, "/proc/self/exe", O_RDONLY, 0L),
+      0);
   char* addr2, *addr3;
   ASSERT_NE((char*)NULL,
             addr2 = reinterpret_cast<char*>(Syscall::Call(
                 kMMapNr, (void*)NULL, 8192L, PROT_READ, MAP_PRIVATE, fd, 0L)));
   ASSERT_NE((char*)NULL,
             addr3 = reinterpret_cast<char*>(Syscall::Call(kMMapNr,
                                                           (void*)NULL,
                                                           4096L,
                                                           PROT_READ,
                                                           MAP_PRIVATE,
@@ skipping 14 matching lines @@
 
   // Clean up
   EXPECT_EQ(0, Syscall::Call(__NR_munmap, addr2, 8192L));
   EXPECT_EQ(0, Syscall::Call(__NR_munmap, addr3, 4096L));
   EXPECT_EQ(0, IGNORE_EINTR(Syscall::Call(__NR_close, fd)));
 }
 
 }  // namespace
 
 }  // namespace sandbox