Reduce the FileRef type to Arc<dyn File>

The FileRef type was defined as Arc<Box<dyn File>>, where the use of Box is
unnecessary. This commit reduces the type to Arc<dyn File>.

src/libos/src/fs/file.rs

@@ -106,7 +106,7 @@ pub trait File: Debug + Sync + Send + Any {
     fn as_any(&self) -> &dyn Any;
 }
 
-pub type FileRef = Arc<Box<dyn File>>;
+pub type FileRef = Arc<dyn File>;
 
 #[derive(Copy, Clone, Debug)]
 struct FileOpNotSupportedError {

src/libos/src/fs/file_ops/open.rs

@@ -10,8 +10,7 @@ pub fn do_openat(fs_path: &FsPath, flags: u32, mode: u32) -> Result<FileDesc> {
     let current = current!();
     let fs = current.fs().lock().unwrap();
 
-    let file = fs.open_file(&path, flags, mode)?;
+    let file_ref: Arc<dyn File> = fs.open_file(&path, flags, mode)?;
-    let file_ref: Arc<Box<dyn File>> = Arc::new(file);
 
     let fd = {
         let creation_flags = CreationFlags::from_bits_truncate(flags);

src/libos/src/fs/fs_view.rs

@@ -39,18 +39,18 @@ impl FsView {
     }
 
     /// Open a file on the process. But DO NOT add it to file table.
-    pub fn open_file(&self, path: &str, flags: u32, mode: u32) -> Result<Box<dyn File>> {
+    pub fn open_file(&self, path: &str, flags: u32, mode: u32) -> Result<Arc<dyn File>> {
         if path == "/dev/null" {
-            return Ok(Box::new(DevNull));
+            return Ok(Arc::new(DevNull));
         }
         if path == "/dev/zero" {
-            return Ok(Box::new(DevZero));
+            return Ok(Arc::new(DevZero));
         }
         if path == "/dev/random" || path == "/dev/urandom" || path == "/dev/arandom" {
-            return Ok(Box::new(DevRandom));
+            return Ok(Arc::new(DevRandom));
         }
         if path == "/dev/sgx" {
-            return Ok(Box::new(DevSgx));
+            return Ok(Arc::new(DevSgx));
         }
         let creation_flags = CreationFlags::from_bits_truncate(flags);
         let inode = if creation_flags.no_follow_symlink() {
@@ -113,7 +113,7 @@ impl FsView {
             }
         };
         let abs_path = self.convert_to_abs_path(&path);
-        Ok(Box::new(INodeFile::open(inode, &abs_path, flags)?))
+        Ok(Arc::new(INodeFile::open(inode, &abs_path, flags)?))
     }
 
     /// Recursively lookup the real path of giving path, dereference symlinks

src/libos/src/fs/pipe.rs

@@ -204,8 +204,8 @@ pub fn do_pipe2(flags: u32) -> Result<[FileDesc; 2]> {
     let close_on_spawn = creation_flags.must_close_on_spawn();
 
     let current = current!();
-    let reader_fd = current.add_file(Arc::new(Box::new(pipe_reader)), close_on_spawn);
+    let reader_fd = current.add_file(Arc::new(pipe_reader), close_on_spawn);
-    let writer_fd = current.add_file(Arc::new(Box::new(pipe_writer)), close_on_spawn);
+    let writer_fd = current.add_file(Arc::new(pipe_writer), close_on_spawn);
     trace!("pipe2: reader_fd: {}, writer_fd: {}", reader_fd, writer_fd);
     Ok([reader_fd, writer_fd])
 }

src/libos/src/fs/syscalls.rs

@@ -23,9 +23,9 @@ pub fn do_eventfd2(init_val: u32, flags: i32) -> Result<isize> {
 
     let inner_flags =
         EventCreationFlags::from_bits(flags).ok_or_else(|| errno!(EINVAL, "invalid flags"))?;
-    let file_ref: Arc<Box<dyn File>> = {
+    let file_ref: Arc<dyn File> = {
         let event = EventFile::new(init_val, inner_flags)?;
-        Arc::new(Box::new(event))
+        Arc::new(event)
     };
 
     let fd = current!().add_file(

src/libos/src/net/syscalls.rs

@@ -13,14 +13,14 @@ pub fn do_socket(domain: c_int, socket_type: c_int, protocol: c_int) -> Result<i
     let file_flags = FileFlags::from_bits_truncate(socket_type);
     let sock_type = SocketType::try_from(socket_type & (!file_flags.bits()))?;
 
-    let file_ref: Arc<Box<dyn File>> = match sock_domain {
+    let file_ref: Arc<dyn File> = match sock_domain {
         AddressFamily::LOCAL => {
             let unix_socket = UnixSocketFile::new(socket_type, protocol)?;
-            Arc::new(Box::new(unix_socket))
+            Arc::new(unix_socket)
         }
         _ => {
             let socket = HostSocket::new(sock_domain, sock_type, file_flags, protocol)?;
-            Arc::new(Box::new(socket))
+            Arc::new(socket)
         }
     };
 
@@ -130,7 +130,7 @@ pub fn do_accept4(
     let file_ref = current!().file(fd as FileDesc)?;
     let new_fd = if let Ok(socket) = file_ref.as_host_socket() {
         let (new_socket_file, sock_addr_option) = socket.accept(file_flags)?;
-        let new_file_ref: Arc<Box<dyn File>> = Arc::new(Box::new(new_socket_file));
+        let new_file_ref: Arc<dyn File> = Arc::new(new_socket_file);
         let new_fd = current!().add_file(new_file_ref, close_on_spawn);
 
         if addr_set && sock_addr_option.is_some() {
@@ -150,7 +150,7 @@ pub fn do_accept4(
         }
         // TODO: handle addr
         let new_socket = unix_socket.accept()?;
-        let new_file_ref: Arc<Box<dyn File>> = Arc::new(Box::new(new_socket));
+        let new_file_ref: Arc<dyn File> = Arc::new(new_socket);
         current!().add_file(new_file_ref, false)
     } else {
         return_errno!(EBADF, "not a socket");
@@ -385,8 +385,8 @@ pub fn do_socketpair(
 
         let current = current!();
         let mut files = current.files().lock().unwrap();
-        sock_pair[0] = files.put(Arc::new(Box::new(client_socket)), close_on_spawn);
+        sock_pair[0] = files.put(Arc::new(client_socket), close_on_spawn);
-        sock_pair[1] = files.put(Arc::new(Box::new(server_socket)), close_on_spawn);
+        sock_pair[1] = files.put(Arc::new(server_socket), close_on_spawn);
 
         debug!("socketpair: ({}, {})", sock_pair[0], sock_pair[1]);
         Ok(0)
@@ -616,7 +616,7 @@ pub fn do_epoll_create1(raw_flags: c_int) -> Result<isize> {
         .ok_or_else(|| errno!(EINVAL, "invalid flags"))?
         & CreationFlags::O_CLOEXEC;
     let epoll_file = io_multiplexing::EpollFile::new(flags)?;
-    let file_ref: Arc<Box<dyn File>> = Arc::new(Box::new(epoll_file));
+    let file_ref: Arc<dyn File> = Arc::new(epoll_file);
     let close_on_spawn = flags.contains(CreationFlags::O_CLOEXEC);
     let fd = current!().add_file(file_ref, close_on_spawn);
 

src/libos/src/process/do_spawn/mod.rs

@@ -244,13 +244,12 @@ fn init_files(
                     oflag,
                     fd,
                 } => {
-                    let file =
+                    let file_ref =
                         current_ref
                             .fs()
                             .lock()
                             .unwrap()
                             .open_file(path.as_str(), oflag, mode)?;
-                    let file_ref: Arc<Box<dyn File>> = Arc::new(file);
                     let creation_flags = CreationFlags::from_bits_truncate(oflag);
                     cloned_file_table.put_at(fd, file_ref, creation_flags.must_close_on_spawn());
                 }
@@ -273,15 +272,14 @@ fn init_files(
 
     // But, for init process, we initialize file table for it
     let mut file_table = FileTable::new();
-    let stdin: Arc<Box<dyn File>> = Arc::new(Box::new(StdinFile::new(
+    let stdin: Arc<dyn File> =
-        host_stdio_fds.unwrap().stdin_fd as FileDesc,
+        Arc::new(StdinFile::new(host_stdio_fds.unwrap().stdin_fd as FileDesc));
-    )));
+    let stdout: Arc<dyn File> = Arc::new(StdoutFile::new(
-    let stdout: Arc<Box<dyn File>> = Arc::new(Box::new(StdoutFile::new(
         host_stdio_fds.unwrap().stdout_fd as FileDesc,
-    )));
+    ));
-    let stderr: Arc<Box<dyn File>> = Arc::new(Box::new(StdoutFile::new(
+    let stderr: Arc<dyn File> = Arc::new(StdoutFile::new(
         host_stdio_fds.unwrap().stderr_fd as FileDesc,
-    )));
+    ));
 
     file_table.put(stdin, false);
     file_table.put(stdout, false);