fix armv7a and aarch64 build errors and warnings

BUG=None
TEST=cargo build --target=armv7a-cros-linux-gnueabi &&
     cargo build --target=aarch64-cros-linux-gnu

Change-Id: I954c152f3c8086e24c4809dd5aabb5043fdd63af
Reviewed-on: https://chromium-review.googlesource.com/644408
Commit-Ready: Zach Reizner <zachr@chromium.org>
Tested-by: Zach Reizner <zachr@chromium.org>
Reviewed-by: Jason Clinton <jclinton@chromium.org>
Reviewed-by: Stephen Barber <smbarber@chromium.org>
Reviewed-by: Dylan Reid <dgreid@chromium.org>

12 files changed, 424 insertions, 39 deletions

diff --git a/Cargo.toml b/Cargo.toml
index 9ee038f..c0b64ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,6 @@ panic = 'abort'
 io_jail = { path = "io_jail" }
 kvm = { path = "kvm" }
 sys_util = { path = "sys_util" }
-x86_64 = { path = "x86_64" }
 kernel_loader = { path = "kernel_loader" }
 libc = "0.2.21"
 byteorder = "1"
@@ -25,3 +24,6 @@ data_model = { path = "data_model" }
 [dependencies.clap]
 version = "*"
 default-features = false
+
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+x86_64 = { path = "x86_64" }
diff --git a/kvm/src/lib.rs b/kvm/src/lib.rs
index f2a45db..4681a7c 100644
--- a/kvm/src/lib.rs
+++ b/kvm/src/lib.rs
@@ -11,7 +11,6 @@ extern crate sys_util;
 mod cap;
 
 use std::fs::File;
-use std::mem;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use std::os::raw::*;
@@ -22,6 +21,7 @@ use libc::{open, O_RDWR, EINVAL, ENOSPC, ENOENT};
 use kvm_sys::*;
 
 use sys_util::{GuestAddress, GuestMemory, MemoryMapping, EventFd, Error, Result};
+#[allow(unused_imports)]
 use sys_util::{ioctl, ioctl_with_val, ioctl_with_ref, ioctl_with_mut_ref, ioctl_with_ptr,
                ioctl_with_mut_ptr};
 
@@ -659,15 +659,19 @@ impl AsRawFd for Vcpu {
 
 /// Wrapper for kvm_cpuid2 which has a zero length array at the end.
 /// Hides the zero length array behind a bounds check.
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 pub struct CpuId {
     bytes: Vec<u8>, // Actually accessed as a kvm_cpuid2 struct.
     allocated_len: usize, // Number of kvm_cpuid_entry2 structs at the end of kvm_cpuid2.
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 impl CpuId {
     pub fn new(array_len: usize) -> CpuId {
-        let vec_size_bytes = mem::size_of::<kvm_cpuid2>() +
-            (array_len * mem::size_of::<kvm_cpuid_entry2>());
+        use std::mem::size_of;
+
+        let vec_size_bytes = size_of::<kvm_cpuid2>() +
+            (array_len * size_of::<kvm_cpuid_entry2>());
         let bytes: Vec<u8> = vec![0; vec_size_bytes];
         let kvm_cpuid: &mut kvm_cpuid2 = unsafe {
             // We have ensured in new that there is enough space for the structure so this
diff --git a/net_util/src/lib.rs b/net_util/src/lib.rs
index 41ca236..5a8fda8 100644
--- a/net_util/src/lib.rs
+++ b/net_util/src/lib.rs
@@ -72,7 +72,7 @@ impl Tap {
         // Open calls are safe because we give a constant nul-terminated
         // string and verify the result.
         let fd = unsafe {
-            libc::open(b"/dev/net/tun\0".as_ptr() as *const i8,
+            libc::open(b"/dev/net/tun\0".as_ptr() as *const c_char,
                        libc::O_RDWR | libc::O_NONBLOCK | libc::O_CLOEXEC)
         };
         if fd < 0 {
@@ -93,9 +93,8 @@ impl Tap {
             let ifru_flags = ifreq.ifr_ifru.ifru_flags.as_mut();
             let mut name_slice = &mut ifrn_name[..TUNTAP_DEV_FORMAT.len()];
             name_slice.copy_from_slice(TUNTAP_DEV_FORMAT);
-            *ifru_flags = (net_sys::IFF_TAP |
-                           net_sys::IFF_NO_PI |
-                           net_sys::IFF_VNET_HDR) as c_short;
+            *ifru_flags = (net_sys::IFF_TAP | net_sys::IFF_NO_PI | net_sys::IFF_VNET_HDR) as
+                          c_short;
         }
 
         // ioctl is safe since we call it with a valid tap fd and check the return
@@ -107,9 +106,9 @@ impl Tap {
 
         // Safe since only the name is accessed, and it's cloned out.
         Ok(Tap {
-            tap_file: tuntap,
-            if_name: unsafe { ifreq.ifr_ifrn.ifrn_name.as_ref().clone() },
-        })
+               tap_file: tuntap,
+               if_name: unsafe { ifreq.ifr_ifrn.ifrn_name.as_ref().clone() },
+           })
     }
 
     /// Set the host-side IP address for the tap interface.
@@ -126,7 +125,8 @@ impl Tap {
         }
 
         // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFADDR as u64, &ifreq) };
+        let ret =
+            unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFADDR as c_ulong, &ifreq) };
         if ret < 0 {
             return Err(Error::IoctlError(sys_util::Error::last()));
         }
@@ -148,7 +148,8 @@ impl Tap {
         }
 
         // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFNETMASK as u64, &ifreq) };
+        let ret =
+            unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFNETMASK as c_ulong, &ifreq) };
         if ret < 0 {
             return Err(Error::IoctlError(sys_util::Error::last()));
         }
@@ -159,7 +160,8 @@ impl Tap {
     /// Set the offload flags for the tap interface.
     pub fn set_offload(&self, flags: c_uint) -> Result<()> {
         // ioctl is safe. Called with a valid tap fd, and we check the return.
-        let ret = unsafe { ioctl_with_val(&self.tap_file, net_sys::TUNSETOFFLOAD(), flags as u64) };
+        let ret =
+            unsafe { ioctl_with_val(&self.tap_file, net_sys::TUNSETOFFLOAD(), flags as c_ulong) };
         if ret < 0 {
             return Err(Error::IoctlError(sys_util::Error::last()));
         }
@@ -181,7 +183,8 @@ impl Tap {
         }
 
         // ioctl is safe. Called with a valid sock fd, and we check the return.
-        let ret = unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFFLAGS as u64, &ifreq) };
+        let ret =
+            unsafe { ioctl_with_ref(&sock, net_sys::sockios::SIOCSIFFLAGS as c_ulong, &ifreq) };
         if ret < 0 {
             return Err(Error::IoctlError(sys_util::Error::last()));
         }
diff --git a/src/main.rs b/src/main.rs
index c538c01..608bdda 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,6 +8,7 @@ extern crate clap;
 extern crate libc;
 extern crate io_jail;
 extern crate kvm;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 extern crate x86_64;
 extern crate kernel_loader;
 extern crate byteorder;
@@ -67,6 +68,7 @@ enum Error {
     RngDeviceNew(hw::virtio::RngError),
     RngDeviceRootSetup(sys_util::Error),
     KernelLoader(kernel_loader::Error),
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     ConfigureSystem(x86_64::Error),
     EventFd(sys_util::Error),
     SignalFd(sys_util::SignalFdError),
@@ -82,6 +84,7 @@ impl std::convert::From<kernel_loader::Error> for Error {
     }
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 impl std::convert::From<x86_64::Error> for Error {
     fn from(e: x86_64::Error) -> Error {
         Error::ConfigureSystem(e)
@@ -122,6 +125,7 @@ impl fmt::Display for Error {
             &Error::Cmdline(ref e) => write!(f, "the given kernel command line was invalid: {}", e),
             &Error::RegisterIrqfd(ref e) => write!(f, "error registering irqfd: {:?}", e),
             &Error::KernelLoader(ref e) => write!(f, "error loading kernel: {:?}", e),
+            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
             &Error::ConfigureSystem(ref e) => write!(f, "error configuring system: {:?}", e),
             &Error::EventFd(ref e) => write!(f, "error creating EventFd: {:?}", e),
             &Error::SignalFd(ref e) => write!(f, "error with SignalFd: {:?}", e),
@@ -249,8 +253,12 @@ fn run_config(cfg: Config) -> Result<()> {
     }
 
     let mem_size = cfg.memory.unwrap_or(256) << 20;
+    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+    let arch_mem_regions = vec![(GuestAddress(0), mem_size)];
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    let arch_mem_regions = x86_64::arch_memory_regions(mem_size);
     let guest_mem =
-        GuestMemory::new(&x86_64::arch_memory_regions(mem_size)).expect("new mmap failed");
+        GuestMemory::new(&arch_mem_regions).expect("new mmap failed");
 
     let mut cmdline = kernel_cmdline::Cmdline::new(CMDLINE_MAX_SIZE);
     cmdline
@@ -352,13 +360,16 @@ fn run_kvm(requests: Vec<VmRequest>,
            warn_unknown_ports: bool)
            -> Result<()> {
     let kvm = Kvm::new().map_err(Error::Kvm)?;
-    let tss_addr = GuestAddress(0xfffbd000);
     let kernel_start_addr = GuestAddress(KERNEL_START_OFFSET);
     let cmdline_addr = GuestAddress(CMDLINE_OFFSET);
 
     let mut vm = Vm::new(&kvm, guest_mem).map_err(Error::Vm)?;
-    vm.set_tss_addr(tss_addr).expect("set tss addr failed");
-    vm.create_pit().expect("create pit failed");
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    {
+        let tss_addr = GuestAddress(0xfffbd000);
+        vm.set_tss_addr(tss_addr).expect("set tss addr failed");
+        vm.create_pit().expect("create pit failed");
+    }
     vm.create_irq_chip().expect("create irq chip failed");
 
     let mut next_dev_pfn = BASE_DEV_MEMORY_PFN;
@@ -375,6 +386,7 @@ fn run_kvm(requests: Vec<VmRequest>,
 
     kernel_loader::load_kernel(vm.get_memory(), kernel_start_addr, &mut kernel_image)?;
     kernel_loader::load_cmdline(vm.get_memory(), cmdline_addr, cmdline)?;
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     x86_64::configure_system(vm.get_memory(),
                              kernel_start_addr,
                              cmdline_addr,
@@ -451,7 +463,8 @@ fn run_kvm(requests: Vec<VmRequest>,
         let kill_signaled = kill_signaled.clone();
         let vcpu_thread_barrier = vcpu_thread_barrier.clone();
         let vcpu_exit_evt = exit_evt.try_clone().map_err(Error::EventFd)?;
-        let vcpu = Vcpu::new(cpu_id as u64, &kvm, &vm).map_err(Error::Vcpu)?;
+        let vcpu = Vcpu::new(cpu_id as libc::c_ulong, &kvm, &vm).map_err(Error::Vcpu)?;
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
         x86_64::configure_vcpu(vm.get_memory(),
                                kernel_start_addr,
                                &kvm,
diff --git a/sys_util/sock_ctrl_msg.c b/sys_util/sock_ctrl_msg.c
index 85ef9f7..d569a47 100644
--- a/sys_util/sock_ctrl_msg.c
+++ b/sys_util/sock_ctrl_msg.c
@@ -39,7 +39,8 @@ ssize_t scm_sendmsg(int fd, const struct iovec *outv, size_t outv_count, uint8_t
     if (fd < 0 || ((!cmsg_buffer || !fds) && fd_count > 0))
         return -EINVAL;
 
-    struct msghdr msg = {0};
+    struct msghdr msg;
+    memset(&msg, 0, sizeof(msg));
     msg.msg_iov = (struct iovec *)outv; // discard const, sendmsg won't mutate it
     msg.msg_iovlen = outv_count;
 
@@ -83,7 +84,8 @@ ssize_t scm_recvmsg(int fd, struct iovec *outv, size_t outv_count, uint8_t *cmsg
     if (fd < 0 || !cmsg_buffer || !fds || !fd_count)
         return -EINVAL;
 
-    struct msghdr msg = {0};
+    struct msghdr msg;
+    memset(&msg, 0, sizeof(msg));
     msg.msg_iov = outv;
     msg.msg_iovlen = outv_count;
     msg.msg_control = cmsg_buffer;
diff --git a/sys_util/src/fork.rs b/sys_util/src/fork.rs
index 053152a..69a49c5 100644
--- a/sys_util/src/fork.rs
+++ b/sys_util/src/fork.rs
@@ -10,7 +10,7 @@ use std::result;
 
 use errno_result;
 
-use libc::{syscall, SIGCHLD, CLONE_NEWUSER, CLONE_NEWPID, pid_t};
+use libc::{syscall, SIGCHLD, CLONE_NEWUSER, CLONE_NEWPID, c_long, pid_t};
 
 use syscall_defines::linux::LinuxSyscall::SYS_clone;
 
@@ -36,7 +36,7 @@ pub enum CloneError {
 unsafe fn do_clone(flags: i32) -> ::Result<pid_t> {
     // Forking is unsafe, this function must be unsafe as there is no way to guarantee safety
     // without more context about the state of the program.
-    let pid = syscall(SYS_clone as i64, flags | SIGCHLD as i32, 0);
+    let pid = syscall(SYS_clone as c_long, flags | SIGCHLD as i32, 0);
     if pid < 0 {
         errno_result()
     } else {
diff --git a/sys_util/src/lib.rs b/sys_util/src/lib.rs
index 3574f98..7610d4e 100644
--- a/sys_util/src/lib.rs
+++ b/sys_util/src/lib.rs
@@ -52,7 +52,7 @@ pub use signalfd::Error as SignalFdError;
 
 use std::ptr;
 
-use libc::{kill, syscall, waitpid, pid_t, uid_t, gid_t, SIGKILL, WNOHANG};
+use libc::{kill, syscall, waitpid, c_long, pid_t, uid_t, gid_t, SIGKILL, WNOHANG};
 
 use syscall_defines::linux::LinuxSyscall::SYS_getpid;
 
@@ -61,7 +61,7 @@ use syscall_defines::linux::LinuxSyscall::SYS_getpid;
 #[inline(always)]
 pub fn getpid() -> pid_t {
     // Safe because this syscall can never fail and we give it a valid syscall number.
-    unsafe { syscall(SYS_getpid as i64) as pid_t }
+    unsafe { syscall(SYS_getpid as c_long) as pid_t }
 }
 
 /// Safe wrapper for `geteuid(2)`.
diff --git a/sys_util/src/shm.rs b/sys_util/src/shm.rs
index 5fee8df..4d2e41c 100644
--- a/sys_util/src/shm.rs
+++ b/sys_util/src/shm.rs
@@ -7,7 +7,7 @@ use std::fs::File;
 use std::io::{Seek, SeekFrom};
 use std::os::unix::io::{AsRawFd, IntoRawFd, FromRawFd, RawFd};
 
-use libc::{off64_t, c_int, c_uint, c_char, syscall, ftruncate64};
+use libc::{off64_t, c_long, c_int, c_uint, c_char, syscall, ftruncate64};
 
 use syscall_defines::linux::LinuxSyscall::SYS_memfd_create;
 
@@ -23,7 +23,7 @@ pub struct SharedMemory {
 const MFD_CLOEXEC: c_uint = 0x0001;
 
 unsafe fn memfd_create(name: *const c_char, flags: c_uint) -> c_int {
-    syscall(SYS_memfd_create as i64, name as i64, flags as i64) as c_int
+    syscall(SYS_memfd_create as c_long, name as i64, flags as i64) as c_int
 }
 
 impl SharedMemory {
@@ -35,7 +35,7 @@ impl SharedMemory {
     /// The file descriptor is opened with the close on exec flag.
     pub fn new(name: Option<&CStr>) -> Result<SharedMemory> {
         let shm_name = name.map(|n| n.as_ptr())
-            .unwrap_or(b"/crosvm_shm\0".as_ptr() as *const i8);
+            .unwrap_or(b"/crosvm_shm\0".as_ptr() as *const c_char);
         // The following are safe because we give a valid C string and check the
         // results of the memfd_create call.
         let fd = unsafe { memfd_create(shm_name, MFD_CLOEXEC) };
diff --git a/sys_util/src/syslog.rs b/sys_util/src/syslog.rs
index 1a3e6ee..12996f8 100644
--- a/sys_util/src/syslog.rs
+++ b/sys_util/src/syslog.rs
@@ -38,9 +38,9 @@ use std::result;
 use std::str::from_utf8;
 use std::sync::{Mutex, MutexGuard, Once, ONCE_INIT};
 
-use libc::{tm, time, time_t, localtime_r, gethostname, c_char, syscall};
+use libc::{tm, time, time_t, localtime_r, gethostname, c_char};
 
-use syscall_defines::linux::LinuxSyscall::SYS_getpid;
+use getpid;
 
 const SYSLOG_PATH: &'static str = "/dev/log";
 
@@ -293,13 +293,6 @@ fn send_buf(socket: &UnixDatagram, buf: &[u8]) {
     }
 }
 
-// This bypasses libc's caching getpid() wrapper which can be invalid if a raw clone was used
-// elsewhere.
-fn getpid() -> i32 {
-    // Safe because this syscall can never fail and we give it a valid syscall number.
-    unsafe { syscall(SYS_getpid as i64) as i32 }
-}
-
 fn get_localtime() -> tm {
     unsafe {
         // Safe because tm is just a struct of plain data.
diff --git a/sys_util/src/tempdir.rs b/sys_util/src/tempdir.rs
index 6a27652..de36c69 100644
--- a/sys_util/src/tempdir.rs
+++ b/sys_util/src/tempdir.rs
@@ -45,7 +45,7 @@ impl TempDir {
         let ret = unsafe {
             // Creating the directory isn't unsafe.  The fact that it modifies the guts of the path
             // is also OK because it only overwrites the last 6 Xs added above.
-            libc::mkdtemp(dir_bytes.as_mut_ptr() as *mut i8)
+            libc::mkdtemp(dir_bytes.as_mut_ptr() as *mut libc::c_char)
         };
         if ret.is_null() {
             return errno_result();
diff --git a/syscall_defines/src/lib.rs b/syscall_defines/src/lib.rs
index 469aa26..c1cbb51 100644
--- a/syscall_defines/src/lib.rs
+++ b/syscall_defines/src/lib.rs
@@ -13,3 +13,7 @@ pub mod linux;
 #[cfg(target_arch="aarch64")]
 #[path="linux-aarch64/mod.rs"]
 pub mod linux;
+
+#[cfg(target_arch="arm")]
+#[path="linux-arm/mod.rs"]
+pub mod linux;
\ No newline at end of file
diff --git a/syscall_defines/src/linux-arm/mod.rs b/syscall_defines/src/linux-arm/mod.rs
new file mode 100644
index 0000000..fbaf4a2
--- /dev/null
+++ b/syscall_defines/src/linux-arm/mod.rs
@@ -0,0 +1,364 @@
+// Copyright 2017 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Based on /usr/include/asm/unistd.h from the sysroot of an arm32 board.
+#[allow(dead_code)]
+#[allow(non_camel_case_types)]
+pub enum LinuxSyscall {
+    SYS_restart_syscall = 0,
+    SYS_exit = 1,
+    SYS_fork = 2,
+    SYS_read = 3,
+    SYS_write = 4,
+    SYS_open = 5,
+    SYS_close = 6,
+    SYS_creat = 8,
+    SYS_link = 9,
+    SYS_unlink = 10,
+    SYS_execve = 11,
+    SYS_chdir = 12,
+    SYS_time = 13,
+    SYS_mknod = 14,
+    SYS_chmod = 15,
+    SYS_lchown = 16,
+    SYS_lseek = 19,
+    SYS_getpid = 20,
+    SYS_mount = 21,
+    SYS_umount = 22,
+    SYS_setuid = 23,
+    SYS_getuid = 24,
+    SYS_stime = 25,
+    SYS_ptrace = 26,
+    SYS_alarm = 27,
+    SYS_pause = 29,
+    SYS_utime = 30,
+    SYS_access = 33,
+    SYS_nice = 34,
+    SYS_sync = 36,
+    SYS_kill = 37,
+    SYS_rename = 38,
+    SYS_mkdir = 39,
+    SYS_rmdir = 40,
+    SYS_dup = 41,
+    SYS_pipe = 42,
+    SYS_times = 43,
+    SYS_brk = 45,
+    SYS_setgid = 46,
+    SYS_getgid = 47,
+    SYS_geteuid = 49,
+    SYS_getegid = 50,
+    SYS_acct = 51,
+    SYS_umount2 = 52,
+    SYS_ioctl = 54,
+    SYS_fcntl = 55,
+    SYS_setpgid = 57,
+    SYS_umask = 60,
+    SYS_chroot = 61,
+    SYS_ustat = 62,
+    SYS_dup2 = 63,
+    SYS_getppid = 64,
+    SYS_getpgrp = 65,
+    SYS_setsid = 66,
+    SYS_sigaction = 67,
+    SYS_setreuid = 70,
+    SYS_setregid = 71,
+    SYS_sigsuspend = 72,
+    SYS_sigpending = 73,
+    SYS_sethostname = 74,
+    SYS_setrlimit = 75,
+    SYS_getrlimit = 76,
+    SYS_getrusage = 77,
+    SYS_gettimeofday = 78,
+    SYS_settimeofday = 79,
+    SYS_getgroups = 80,
+    SYS_setgroups = 81,
+    SYS_select = 82,
+    SYS_symlink = 83,
+    SYS_readlink = 85,
+    SYS_uselib = 86,
+    SYS_swapon = 87,
+    SYS_reboot = 88,
+    SYS_readdir = 89,
+    SYS_mmap = 90,
+    SYS_munmap = 91,
+    SYS_truncate = 92,
+    SYS_ftruncate = 93,
+    SYS_fchmod = 94,
+    SYS_fchown = 95,
+    SYS_getpriority = 96,
+    SYS_setpriority = 97,
+    SYS_statfs = 99,
+    SYS_fstatfs = 100,
+    SYS_socketcall = 102,
+    SYS_syslog = 103,
+    SYS_setitimer = 104,
+    SYS_getitimer = 105,
+    SYS_stat = 106,
+    SYS_lstat = 107,
+    SYS_fstat = 108,
+    SYS_vhangup = 111,
+    SYS_syscall = 113,
+    SYS_wait4 = 114,
+    SYS_swapoff = 115,
+    SYS_sysinfo = 116,
+    SYS_ipc = 117,
+    SYS_fsync = 118,
+    SYS_sigreturn = 119,
+    SYS_clone = 120,
+    SYS_setdomainname = 121,
+    SYS_uname = 122,
+    SYS_adjtimex = 124,
+    SYS_mprotect = 125,
+    SYS_sigprocmask = 126,
+    SYS_init_module = 128,
+    SYS_delete_module = 129,
+    SYS_quotactl = 131,
+    SYS_getpgid = 132,
+    SYS_fchdir = 133,
+    SYS_bdflush = 134,
+    SYS_sysfs = 135,
+    SYS_personality = 136,
+    SYS_setfsuid = 138,
+    SYS_setfsgid = 139,
+    SYS__llseek = 140,
+    SYS_getdents = 141,
+    SYS__newselect = 142,
+    SYS_flock = 143,
+    SYS_msync = 144,
+    SYS_readv = 145,
+    SYS_writev = 146,
+    SYS_getsid = 147,
+    SYS_fdatasync = 148,
+    SYS__sysctl = 149,
+    SYS_mlock = 150,
+    SYS_munlock = 151,
+    SYS_mlockall = 152,
+    SYS_munlockall = 153,
+    SYS_sched_setparam = 154,
+    SYS_sched_getparam = 155,
+    SYS_sched_setscheduler = 156,
+    SYS_sched_getscheduler = 157,
+    SYS_sched_yield = 158,
+    SYS_sched_get_priority_max = 159,
+    SYS_sched_get_priority_min = 160,
+    SYS_sched_rr_get_interval = 161,
+    SYS_nanosleep = 162,
+    SYS_mremap = 163,
+    SYS_setresuid = 164,
+    SYS_getresuid = 165,
+    SYS_poll = 168,
+    SYS_nfsservctl = 169,
+    SYS_setresgid = 170,
+    SYS_getresgid = 171,
+    SYS_prctl = 172,
+    SYS_rt_sigreturn = 173,
+    SYS_rt_sigaction = 174,
+    SYS_rt_sigprocmask = 175,
+    SYS_rt_sigpending = 176,
+    SYS_rt_sigtimedwait = 177,
+    SYS_rt_sigqueueinfo = 178,
+    SYS_rt_sigsuspend = 179,
+    SYS_pread64 = 180,
+    SYS_pwrite64 = 181,
+    SYS_chown = 182,
+    SYS_getcwd = 183,
+    SYS_capget = 184,
+    SYS_capset = 185,
+    SYS_sigaltstack = 186,
+    SYS_sendfile = 187,
+    SYS_vfork = 190,
+    SYS_ugetrlimit = 191,
+    SYS_mmap2 = 192,
+    SYS_truncate64 = 193,
+    SYS_ftruncate64 = 194,
+    SYS_stat64 = 195,
+    SYS_lstat64 = 196,
+    SYS_fstat64 = 197,
+    SYS_lchown32 = 198,
+    SYS_getuid32 = 199,
+    SYS_getgid32 = 200,
+    SYS_geteuid32 = 201,
+    SYS_getegid32 = 202,
+    SYS_setreuid32 = 203,
+    SYS_setregid32 = 204,
+    SYS_getgroups32 = 205,
+    SYS_setgroups32 = 206,
+    SYS_fchown32 = 207,
+    SYS_setresuid32 = 208,
+    SYS_getresuid32 = 209,
+    SYS_setresgid32 = 210,
+    SYS_getresgid32 = 211,
+    SYS_chown32 = 212,
+    SYS_setuid32 = 213,
+    SYS_setgid32 = 214,
+    SYS_setfsuid32 = 215,
+    SYS_setfsgid32 = 216,
+    SYS_getdents64 = 217,
+    SYS_pivot_root = 218,
+    SYS_mincore = 219,
+    SYS_madvise = 220,
+    SYS_fcntl64 = 221,
+    SYS_gettid = 224,
+    SYS_readahead = 225,
+    SYS_setxattr = 226,
+    SYS_lsetxattr = 227,
+    SYS_fsetxattr = 228,
+    SYS_getxattr = 229,
+    SYS_lgetxattr = 230,
+    SYS_fgetxattr = 231,
+    SYS_listxattr = 232,
+    SYS_llistxattr = 233,
+    SYS_flistxattr = 234,
+    SYS_removexattr = 235,
+    SYS_lremovexattr = 236,
+    SYS_fremovexattr = 237,
+    SYS_tkill = 238,
+    SYS_sendfile64 = 239,
+    SYS_futex = 240,
+    SYS_sched_setaffinity = 241,
+    SYS_sched_getaffinity = 242,
+    SYS_io_setup = 243,
+    SYS_io_destroy = 244,
+    SYS_io_getevents = 245,
+    SYS_io_submit = 246,
+    SYS_io_cancel = 247,
+    SYS_exit_group = 248,
+    SYS_lookup_dcookie = 249,
+    SYS_epoll_create = 250,
+    SYS_epoll_ctl = 251,
+    SYS_epoll_wait = 252,
+    SYS_remap_file_pages = 253,
+    SYS_set_tid_address = 256,
+    SYS_timer_create = 257,
+    SYS_timer_settime = 258,
+    SYS_timer_gettime = 259,
+    SYS_timer_getoverrun = 260,
+    SYS_timer_delete = 261,
+    SYS_clock_settime = 262,
+    SYS_clock_gettime = 263,
+    SYS_clock_getres = 264,
+    SYS_clock_nanosleep = 265,
+    SYS_statfs64 = 266,
+    SYS_fstatfs64 = 267,
+    SYS_tgkill = 268,
+    SYS_utimes = 269,
+    SYS_arm_fadvise64_64 = 270,
+    SYS_pciconfig_iobase = 271,
+    SYS_pciconfig_read = 272,
+    SYS_pciconfig_write = 273,
+    SYS_mq_open = 274,
+    SYS_mq_unlink = 275,
+    SYS_mq_timedsend = 276,
+    SYS_mq_timedreceive = 277,
+    SYS_mq_notify = 278,
+    SYS_mq_getsetattr = 279,
+    SYS_waitid = 280,
+    SYS_socket = 281,
+    SYS_bind = 282,
+    SYS_connect = 283,
+    SYS_listen = 284,
+    SYS_accept = 285,
+    SYS_getsockname = 286,
+    SYS_getpeername = 287,
+    SYS_socketpair = 288,
+    SYS_send = 289,
+    SYS_sendto = 290,
+    SYS_recv = 291,
+    SYS_recvfrom = 292,
+    SYS_shutdown = 293,
+    SYS_setsockopt = 294,
+    SYS_getsockopt = 295,
+    SYS_sendmsg = 296,
+    SYS_recvmsg = 297,
+    SYS_semop = 298,
+    SYS_semget = 299,
+    SYS_semctl = 300,
+    SYS_msgsnd = 301,
+    SYS_msgrcv = 302,
+    SYS_msgget = 303,
+    SYS_msgctl = 304,
+    SYS_shmat = 305,
+    SYS_shmdt = 306,
+    SYS_shmget = 307,
+    SYS_shmctl = 308,
+    SYS_add_key = 309,
+    SYS_request_key = 310,
+    SYS_keyctl = 311,
+    SYS_semtimedop = 312,
+    SYS_vserver = 313,
+    SYS_ioprio_set = 314,
+    SYS_ioprio_get = 315,
+    SYS_inotify_init = 316,
+    SYS_inotify_add_watch = 317,
+    SYS_inotify_rm_watch = 318,
+    SYS_mbind = 319,
+    SYS_get_mempolicy = 320,
+    SYS_set_mempolicy = 321,
+    SYS_openat = 322,
+    SYS_mkdirat = 323,
+    SYS_mknodat = 324,
+    SYS_fchownat = 325,
+    SYS_futimesat = 326,
+    SYS_fstatat64 = 327,
+    SYS_unlinkat = 328,
+    SYS_renameat = 329,
+    SYS_linkat = 330,
+    SYS_symlinkat = 331,
+    SYS_readlinkat = 332,
+    SYS_fchmodat = 333,
+    SYS_faccessat = 334,
+    SYS_pselect6 = 335,
+    SYS_ppoll = 336,
+    SYS_unshare = 337,
+    SYS_set_robust_list = 338,
+    SYS_get_robust_list = 339,
+    SYS_splice = 340,
+    SYS_arm_sync_file_range = 341,
+    SYS_tee = 342,
+    SYS_vmsplice = 343,
+    SYS_move_pages = 344,
+    SYS_getcpu = 345,
+    SYS_epoll_pwait = 346,
+    SYS_kexec_load = 347,
+    SYS_utimensat = 348,
+    SYS_signalfd = 349,
+    SYS_timerfd_create = 350,
+    SYS_eventfd = 351,
+    SYS_fallocate = 352,
+    SYS_timerfd_settime = 353,
+    SYS_timerfd_gettime = 354,
+    SYS_signalfd4 = 355,
+    SYS_eventfd2 = 356,
+    SYS_epoll_create1 = 357,
+    SYS_dup3 = 358,
+    SYS_pipe2 = 359,
+    SYS_inotify_init1 = 360,
+    SYS_preadv = 361,
+    SYS_pwritev = 362,
+    SYS_rt_tgsigqueueinfo = 363,
+    SYS_perf_event_open = 364,
+    SYS_recvmmsg = 365,
+    SYS_accept4 = 366,
+    SYS_fanotify_init = 367,
+    SYS_fanotify_mark = 368,
+    SYS_prlimit64 = 369,
+    SYS_name_to_handle_at = 370,
+    SYS_open_by_handle_at = 371,
+    SYS_clock_adjtime = 372,
+    SYS_syncfs = 373,
+    SYS_sendmmsg = 374,
+    SYS_setns = 375,
+    SYS_process_vm_readv = 376,
+    SYS_process_vm_writev = 377,
+    SYS_kcmp = 378,
+    SYS_finit_module = 379,
+    SYS_sched_setattr = 380,
+    SYS_sched_getattr = 381,
+    SYS_renameat2 = 382,
+    SYS_seccomp = 383,
+    SYS_getrandom = 384,
+    SYS_memfd_create = 385,
+    SYS_bpf = 386,
+    SYS_execveat = 387,
+}