Merge 0975fe3 into 043a506

stevenengler · web-flow · commit 26fc4c45e380 · 2021-01-28T16:45:21.000Z
diff --git a/src/main/bindings/c/bindings.h b/src/main/bindings/c/bindings.h
@@ -135,6 +135,8 @@ SysCallReg memorymanager_handleMprotect(MemoryManager *memory_manager,
 
 SysCallReturn rustsyscallhandler_close(SysCallHandler *sys, const SysCallArgs *args);
 
+SysCallReturn rustsyscallhandler_dup(SysCallHandler *sys, const SysCallArgs *args);
+
 SysCallReturn rustsyscallhandler_read(SysCallHandler *sys, const SysCallArgs *args);
 
 SysCallReturn rustsyscallhandler_write(SysCallHandler *sys, const SysCallArgs *args);
diff --git a/src/main/bindings/rust/wrapper.rs b/src/main/bindings/rust/wrapper.rs
@@ -678,6 +678,9 @@ extern "C" {
         args: *const SysCallArgs,
     ) -> SysCallReturn;
 }
+extern "C" {
+    pub fn syscallhandler_dup(sys: *mut SysCallHandler, args: *const SysCallArgs) -> SysCallReturn;
+}
 extern "C" {
     pub fn syscallhandler_getpid(
         sys: *mut SysCallHandler,
diff --git a/src/main/host/syscall/unistd.c b/src/main/host/syscall/unistd.c
@@ -296,6 +296,12 @@ SysCallReturn syscallhandler_close(SysCallHandler* sys,
     return (SysCallReturn){.state = SYSCALL_DONE, .retval.as_i64 = errorCode};
 }
 
+SysCallReturn syscallhandler_dup(SysCallHandler* sys,
+                                   const SysCallArgs* args) {
+    warning("Cannot dup legacy descriptors");
+    return (SysCallReturn){.state = SYSCALL_DONE, .retval.as_i64 = -EOPNOTSUPP};
+}
+
 SysCallReturn syscallhandler_pipe2(SysCallHandler* sys,
                                    const SysCallArgs* args) {
     return _syscallhandler_pipeHelper(
diff --git a/src/main/host/syscall/unistd.h b/src/main/host/syscall/unistd.h
@@ -9,6 +9,7 @@
 #include "main/host/syscall/protected.h"
 
 SYSCALL_HANDLER(close);
+SYSCALL_HANDLER(dup);
 SYSCALL_HANDLER(getpid);
 SYSCALL_HANDLER(pipe);
 SYSCALL_HANDLER(pipe2);
diff --git a/src/main/host/syscall/unistd.rs b/src/main/host/syscall/unistd.rs
@@ -40,6 +40,44 @@ pub fn close(sys: &mut c::SysCallHandler, args: &c::SysCallArgs) -> c::SysCallRe
     c::SysCallReturn::from_int(0)
 }
 
+pub fn dup(sys: &mut c::SysCallHandler, args: &c::SysCallArgs) -> c::SysCallReturn {
+    let fd = unsafe { args.args[0].as_i64 } as libc::c_int;
+
+    dup_helper(sys, args, fd)
+}
+
+pub fn dup_helper(
+    sys: &mut c::SysCallHandler,
+    args: &c::SysCallArgs,
+    fd: libc::c_int,
+) -> c::SysCallReturn {
+    // get the descriptor, or return early if it doesn't exist
+    let desc = match syscall::get_descriptor(fd, sys.process) {
+        Ok(d) => unsafe { &mut *d },
+        Err(errno) => return c::SysCallReturn::from_errno(errno),
+    };
+
+    // if it's a legacy descriptor, use the C syscall handler instead
+    let desc = match desc {
+        CompatDescriptor::New(d) => d,
+        CompatDescriptor::Legacy(_) => unsafe {
+            return c::syscallhandler_dup(
+                sys as *mut c::SysCallHandler,
+                args as *const c::SysCallArgs,
+            );
+        },
+    };
+
+    // clone the descriptor and register it
+    let new_desc = CompatDescriptor::New(desc.clone());
+    let new_fd = unsafe {
+        c::process_registerCompatDescriptor(sys.process, Box::into_raw(Box::new(new_desc)))
+    };
+
+    // return the new fd
+    c::SysCallReturn::from_int(new_fd as i64)
+}
+
 pub fn read(sys: &mut c::SysCallHandler, args: &c::SysCallArgs) -> c::SysCallReturn {
     let fd = unsafe { args.args[0].as_i64 } as libc::c_int;
     let buf_ptr = unsafe { args.args[1].as_ptr };
@@ -299,6 +337,15 @@ mod export {
         close(unsafe { &mut *sys }, unsafe { &*args })
     }
 
+    #[no_mangle]
+    pub extern "C" fn rustsyscallhandler_dup(
+        sys: *mut c::SysCallHandler,
+        args: *const c::SysCallArgs,
+    ) -> c::SysCallReturn {
+        assert!(!sys.is_null() && !args.is_null());
+        dup(unsafe { &mut *sys }, unsafe { &*args })
+    }
+
     #[no_mangle]
     pub extern "C" fn rustsyscallhandler_read(
         sys: *mut c::SysCallHandler,
diff --git a/src/main/host/syscall_handler.c b/src/main/host/syscall_handler.c
@@ -215,6 +215,7 @@ SysCallReturn syscallhandler_make_syscall(SysCallHandler* sys,
         HANDLE_RUST(close);
         HANDLE(connect);
         HANDLE(creat);
+        HANDLE_RUST(dup);
         HANDLE(epoll_create);
         HANDLE(epoll_create1);
         HANDLE(epoll_ctl);
@@ -335,7 +336,6 @@ SysCallReturn syscallhandler_make_syscall(SysCallHandler* sys,
         NATIVE(sched_setaffinity);
 
         // operations on file descriptors
-        NATIVE(dup);
         NATIVE(dup2);
         NATIVE(dup3);
         NATIVE(poll);
diff --git a/src/shim/preload_syscalls.c b/src/shim/preload_syscalls.c
@@ -223,6 +223,7 @@ NOREMAP(int, close, (int a), a);
 NOREMAP(int, connect, (int a, const struct sockaddr* b, socklen_t c), a,b,c);
 NOREMAP(int, creat, (const char *a, mode_t b), a,b);
 REMAP(int, creat64, creat, (const char *a, mode_t b), a,b);
+NOREMAP(int, dup, (int a), a);
 NOREMAP(int, epoll_create, (int a), a);
 NOREMAP(int, epoll_create1, (int a), a);
 NOREMAP(int, epoll_ctl, (int a, int b, int c, struct epoll_event* d), a,b,c,d);
diff --git a/src/test/pipe/test_pipe.rs b/src/test/pipe/test_pipe.rs
@@ -41,8 +41,7 @@ fn get_tests() -> Vec<test_utils::ShadowTest<(), String>> {
             test_read_write,
             set![TestEnv::Libc, TestEnv::Shadow],
         ),
-        // TODO: support dup() in Shadow
-        test_utils::ShadowTest::new("test_dup", test_dup, set![TestEnv::Libc]),
+        test_utils::ShadowTest::new("test_dup", test_dup, set![TestEnv::Libc, TestEnv::Shadow]),
         test_utils::ShadowTest::new(
             "test_write_to_read_end",
             test_write_to_read_end,
