Without ice files

Author: davidge20

src/safeposix/syscalls/fs_calls.rs

@@ -1099,8 +1099,8 @@ impl Cage {
     /// O_WRONLY flags.
     /// There are generally two cases which occur when this syscall happens:
     /// Case 1: If the file to be opened doesn't exist, then due to O_CREAT flag,
-    /// a new file is created at the given location and a new file descriptor is 
-    /// created and returned. 
+    /// a new file is created at the given location and a new file descriptor is
+    /// created and returned.
     /// Case 2: If the file already exists, then due to O_TRUNC flag, the file
     /// size gets reduced to 0, and the existing file descriptor is returned.
     ///

src/safeposix/syscalls/net_calls.rs

@@ -1511,56 +1511,56 @@ impl Cage {
     }
 
     /// ### Description
-    /// 
+    ///
     /// `listen_syscall` listen for connections on a socket
-    /// 
+    ///
     /// ### Arguments
-    /// 
-    /// it accepts two parameters: 
+    ///
+    /// it accepts two parameters:
     /// * `sockfd` - a file descriptor that refers to a socket
-    ///    of type SOCK_STREAM 
+    ///    of type SOCK_STREAM
     ///    Note, we do not implement sockets of type SOCK_SEQPACKET
     /// * `backlog` - defines the maximum length to which the
     ///   queue of pending connections for sockfd may grow.  If a
     ///   connection request arrives when the queue is full, the client may
     ///   receive an error with an indication of ECONNREFUSED or, if the
     ///   underlying protocol supports retransmission, the request may be
     ///   ignored so that a later reattempt at connection succeeds.
-    /// 
+    ///
     /// ### Returns
-    /// 
+    ///
     /// for a successful call, zero is returned. On error, -errno is
     /// returned and errno is set to indicate the error
-    /// 
+    ///
     /// ### Errors
-    /// 
+    ///
     /// * EADDRINUSE - Another socket is already listening on the same port.
-    /// 
+    ///
     /// * EADDRINUSE - (Internet domain sockets) The socket referred to by sockfd
     ///      had not previously been bound to an address and, upon
     ///      attempting to bind it to an ephemeral port, it was
     ///      determined that all port numbers in the ephemeral port
     ///      range are currently in use.  See the discussion of
     ///      /proc/sys/net/ipv4/ip_local_port_range in ip(7).
-    /// 
+    ///
     /// * EBADF - The argument sockfd is not a valid file descriptor.
-    /// 
+    ///
     /// * ENOTSOCK - The file descriptor sockfd does not refer to a socket.
-    /// 
+    ///
     /// * EOPNOTSUPP - The socket is not of a type that supports the listen()
     ///     operation.
-    /// 
+    ///
     /// ### Panics
-    /// 
+    ///
     /// * invalid or out-of-bounds file descriptor), calling unwrap() on it will cause a panic.
-    /// * unknown errno value from socket bind sys call from libc in the case 
+    /// * unknown errno value from socket bind sys call from libc in the case
     ///   that the socket isn't assigned an address
     /// * unknown errno value from socket listen sys call from libc
-    /// 
-    /// for more detailed description of all the commands and return values, see 
+    ///
+    /// for more detailed description of all the commands and return values, see
     /// [listen(2)](https://linux.die.net/man/2/listen)
     //
-    // TODO: We are currently ignoring backlog 
+    // TODO: We are currently ignoring backlog
     pub fn listen_syscall(&self, fd: i32, _backlog: i32) -> i32 {
         //BUG:s
         //If fd is out of range of [0,MAXFD], process will panic
@@ -1607,7 +1607,7 @@ impl Cage {
                         //If the given socket is not connected, it is ready
                         //to begin listening
                         ConnState::NOTCONNECTED => {
-                            //If the given socket is not a TCP socket, then the 
+                            //If the given socket is not a TCP socket, then the
                             //socket can not listen for connections
                             if sockhandle.protocol != IPPROTO_TCP {
                                 return syscall_error(
@@ -1676,8 +1676,8 @@ impl Cage {
                                         panic!("Unknown errno value from socket listen returned!")
                                     }
                                 };
-                                //Remove the tuple of the address, port, and 
-                                //port type from the set of listening ports 
+                                //Remove the tuple of the address, port, and
+                                //port type from the set of listening ports
                                 //as we are returning from an error
                                 //** Why dont we use 'porttuple' as the argument for the key ?? */
                                 NET_METADATA.listening_port_set.remove(&mux_port(
@@ -1692,14 +1692,14 @@ impl Cage {
                                 return lr;
                             };
 
-                            // Set the rawfd for select_syscall as we cannot implement the select 
-                            // logics for AF_INET socket right now, so we have to call the select 
-                            // syscall from libc, which takes the rawfd as the argument instead of 
+                            // Set the rawfd for select_syscall as we cannot implement the select
+                            // logics for AF_INET socket right now, so we have to call the select
+                            // syscall from libc, which takes the rawfd as the argument instead of
                             // the fake fd used by lind.
                             // The raw fd of the socket is the set to be the same as the fd set by the kernal in the libc connect call
                             sockfdobj.rawfd = sockhandle.innersocket.as_ref().unwrap().raw_sys_fd;
 
-                            //If listening socket is not in the table of pending 
+                            //If listening socket is not in the table of pending
                             //connections, we must insert it as the key with
                             //an empty vector as the value
                             //We can now track incoming connections
@@ -1714,7 +1714,7 @@ impl Cage {
                     }
                 }
 
-                //Otherwise, the file descriptor refers to something other 
+                //Otherwise, the file descriptor refers to something other
                 //than a socket, return with error
                 _ => {
                     return syscall_error(

src/safeposix/syscalls/sys_calls.rs

@@ -43,8 +43,6 @@ use crate::safeposix::filesystem::{decref_dir, metawalk, Inode, FS_METADATA};
 use crate::safeposix::net::NET_METADATA;
 use crate::safeposix::shm::SHM_METADATA;
 
-
-
 impl Cage {
     fn unmap_shm_mappings(&self) {
         //unmap shm mappings on exit or exec
@@ -72,41 +70,41 @@ impl Cage {
     }
 
     /// ### Description
-    /// 
+    ///
     ///'fork_syscall` creates a new process (cage object)
-    /// The newly created child process is an exact copy of the 
-    /// parent process (the process that calls fork) 
+    /// The newly created child process is an exact copy of the
+    /// parent process (the process that calls fork)
     /// apart from it's cage_id and the parent_id
-    /// In this function we clone the mutex table, condition variables table, 
-    /// semaphore table and the file descriptors and create 
-    /// a new Cage object with these cloned tables. 
-    /// We also update the shared memory mappings - and create mappings 
-    /// from the new Cage object the the 
-    /// parent Cage object's memory mappings. 
-    /// 
+    /// In this function we clone the mutex table, condition variables table,
+    /// semaphore table and the file descriptors and create
+    /// a new Cage object with these cloned tables.
+    /// We also update the shared memory mappings - and create mappings
+    /// from the new Cage object the the
+    /// parent Cage object's memory mappings.
+    ///
     /// ### Arguments
-    /// 
+    ///
     /// It accepts one parameter:
-    /// 
+    ///
     /// * `child_cageid` : an integer representing the pid of the child process
-    /// 
+    ///
     /// ### Errors
     ///    
     /// There are 2 scenarios where the call to `fork_syscall` might return an error
-    /// 
+    ///
     /// * When the RawMutex::create() call fails to create a new Mutex object
     /// * When the RawCondvar::create() call fails to create a new Condition Variable object
-    /// 
+    ///
     /// ### Returns
-    /// 
+    ///
     /// On success it returns a value of 0, and the new child Cage object is added to Cagetable
-    /// 
-    /// ### Panics 
-    /// 
+    ///
+    /// ### Panics
+    ///
     /// This system call has no scenarios where it panics
-    /// 
+    ///
     /// To learn more about the syscall and possible error values, see
-    /// [fork(2)](https://man7.org/linux/man-pages/man2/fork.2.html) 
+    /// [fork(2)](https://man7.org/linux/man-pages/man2/fork.2.html)
 
     pub fn fork_syscall(&self, child_cageid: u64) -> i32 {
         //Create a new mutex table that replicates the mutex table of the parent (calling) Cage object
@@ -116,7 +114,7 @@ impl Cage {
         let mut new_mutex_table = vec![];
         //Loop through each element in the mutex table
         //Each entry in the mutex table represents a `lock` which the parent process holds
-        //Copying them into the child's Cage exhibits the inheritance of the lock 
+        //Copying them into the child's Cage exhibits the inheritance of the lock
         for elem in mutextable.iter() {
             if elem.is_some() {
                 //If the mutex is `Some` - we create a new mutex and store it in the child's mutex table
@@ -151,7 +149,7 @@ impl Cage {
         //Construct a replica of the condition variables table in the child cage object
         //This table stores condition variables - which are special variables that the process
         //uses to determine whether certain conditions have been met or not. Threads use condition variables
-        //to stop or resume their operation depending on the value of these variables.  
+        //to stop or resume their operation depending on the value of these variables.
         //Read the CondVar table of the calling process
         let cvtable = self.cv_table.read();
         // Initialize the table for the child process
@@ -239,11 +237,11 @@ impl Cage {
                         let sock_tmp = socket_filedesc_obj.handle.clone();
                         let mut sockhandle = sock_tmp.write();
                         let socket_type = sockhandle.domain;
-                        //Here we only increment the reference for AF_UNIX socket type 
+                        //Here we only increment the reference for AF_UNIX socket type
                         //Since these are the only sockets that have an inode associated with them
                         if socket_type == AF_UNIX {
                             //Increment the appropriate reference counter of the correct socket
-                            //Each socket has two pipes associated with them - a read and write pipe 
+                            //Each socket has two pipes associated with them - a read and write pipe
                             //Here we grab these two pipes and increment their references individually
                             //And also increment the reference count of the socket as a whole
                             if let Some(sockinfo) = &sockhandle.unix_info {
@@ -255,9 +253,9 @@ impl Cage {
                                 }
                                 if let Inode::Socket(ref mut sock) =
                                     *(FS_METADATA.inodetable.get_mut(&sockinfo.inode).unwrap())
-                                    {
-                                        sock.refcount += 1;
-                                    }
+                                {
+                                    sock.refcount += 1;
+                                }
                             }
                         }
                         drop(sockhandle);
@@ -268,13 +266,12 @@ impl Cage {
                 let newfdobj = filedesc_enum.clone();
                 // Insert the file descriptor object into the new file descriptor table
                 let _insertval = newfdtable[fd as usize].write().insert(newfdobj);
-                
             }
         }
 
         //We read the current working directory of the parent Cage object
         let cwd_container = self.cwd.read();
-        //We try to resolve the inode of the current working directory - if the 
+        //We try to resolve the inode of the current working directory - if the
         //resolution is successful we update the reference count of the current working directory
         //since the newly created Child cage object also references the same directory
         //If the resolution is not successful - the code panics since the cwd's inode cannot be resolved
@@ -291,10 +288,10 @@ impl Cage {
             panic!("We changed from a directory that was not a directory in chdir!");
         }
 
-        // We clone the parent cage's main threads and store them and index 0 
-        // This is done since there isn't a thread established for the child Cage object yet - 
-        // And there is no threadId to store it at. 
-        // The child Cage object can then initialize and store the sigset appropriately when it establishes its own 
+        // We clone the parent cage's main threads and store them and index 0
+        // This is done since there isn't a thread established for the child Cage object yet -
+        // And there is no threadId to store it at.
+        // The child Cage object can then initialize and store the sigset appropriately when it establishes its own
         // main thread id.
         let newsigset = interface::RustHashMap::new();
         // Here we check if Lind is being run under the test suite or not
@@ -316,7 +313,7 @@ impl Cage {
             newsigset.insert(0, mainsigset);
         }
 
-        // Construct a new semaphore table in child cage which equals to the one in the parent cage 
+        // Construct a new semaphore table in child cage which equals to the one in the parent cage
         let semtable = &self.sem_table;
         let new_semtable: interface::RustHashMap<
             u32,

src/tests/networking_tests.rs

@@ -670,7 +670,7 @@ pub mod net_tests {
         lindrustfinalize();
     }
 
-    //We try to queue more than 5 connections, as the 
+    //We try to queue more than 5 connections, as the
     //backlog is set to 5. We expect only the first 5 queues to return
     //with success.
     //Currently, the 6th connection returns with EINPROGRESS, while
@@ -719,7 +719,7 @@ pub mod net_tests {
         assert_eq!(cage.connect_syscall(clientsockfd3, &socket), -115);
         assert_eq!(cage.connect_syscall(clientsockfd4, &socket), -115);
         assert_eq!(cage.connect_syscall(clientsockfd5, &socket), -115);
-        assert_eq!(cage.connect_syscall(clientsockfd6, &socket), -111); 
+        assert_eq!(cage.connect_syscall(clientsockfd6, &socket), -111);
 
         assert_eq!(cage.close_syscall(serversockfd), 0);
         assert_eq!(cage.close_syscall(clientsockfd1), 0);