use errno! macro for all error

src/libos/src/fs/file.rs

@@ -37,7 +37,7 @@ impl SgxFile {
         is_append: bool,
     ) -> Result<SgxFile, Error> {
         if !is_readable && !is_writable {
-            return Err(Error::new(Errno::EINVAL, "Invalid permissions"));
+            return errno!(EINVAL, "Invalid permissions");
         }
 
         Ok(SgxFile {
@@ -132,7 +132,7 @@ struct SgxFileInner {
 impl SgxFileInner {
     pub fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {
         if !self.is_writable {
-            return Err(Error::new(Errno::EINVAL, "File not writable"));
+            return errno!(EINVAL, "File not writable");
         }
 
         let mut file_guard = self.file.lock().unwrap();
@@ -160,7 +160,7 @@ impl SgxFileInner {
 
     pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
         if !self.is_readable {
-            return Err(Error::new(Errno::EINVAL, "File not readable"));
+            return errno!(EINVAL, "File not readable");
         }
 
         let mut file_guard = self.file.lock().unwrap();
@@ -193,7 +193,7 @@ impl SgxFileInner {
                     let backward_offset = (-relative_offset) as usize;
                     if self.pos < backward_offset {
                         // underflow
-                        return Err(Error::new(Errno::EINVAL, "Invalid seek position"));
+                        return errno!(EINVAL, "Invalid seek position");
                     }
                     SeekFrom::Start((self.pos - backward_offset) as u64)
                 }
@@ -209,7 +209,7 @@ impl SgxFileInner {
 
     pub fn writev(&mut self, bufs: &[&[u8]]) -> Result<usize, Error> {
         if !self.is_writable {
-            return Err(Error::new(Errno::EINVAL, "File not writable"));
+            return errno!(EINVAL, "File not writable");
         }
 
         let mut file_guard = self.file.lock().unwrap();
@@ -235,7 +235,7 @@ impl SgxFileInner {
                 Err(e) => {
                     match total_bytes {
                         // a complete failure
-                        0 => return Err(Error::new(Errno::EINVAL, "Failed to write")),
+                        0 => return errno!(EINVAL, "Failed to write"),
                         // a partially failure
                         _ => break,
                     }
@@ -249,7 +249,7 @@ impl SgxFileInner {
 
     fn readv(&mut self, bufs: &mut [&mut [u8]]) -> Result<usize, Error> {
         if !self.is_readable {
-            return Err(Error::new(Errno::EINVAL, "File not readable"));
+            return errno!(EINVAL, "File not readable");
         }
 
         let mut file_guard = self.file.lock().unwrap();
@@ -271,7 +271,7 @@ impl SgxFileInner {
                 Err(e) => {
                     match total_bytes {
                         // a complete failure
-                        0 => return Err(Error::new(Errno::EINVAL, "Failed to write")),
+                        0 => return errno!(EINVAL, "Failed to write"),
                         // a partially failure
                         _ => break,
                     }
@@ -307,7 +307,7 @@ impl StdoutFile {
 
 impl File for StdoutFile {
     fn read(&self, buf: &mut [u8]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "Stdout does not support read"))
+        errno!(EBADF, "Stdout does not support read")
     }
 
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
@@ -329,7 +329,7 @@ impl File for StdoutFile {
     }
 
     fn readv(&self, bufs: &mut [&mut [u8]]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "Stdout does not support read"))
+        errno!(EBADF, "Stdout does not support read")
     }
 
     fn writev(&self, bufs: &[&[u8]]) -> Result<usize, Error> {
@@ -346,7 +346,7 @@ impl File for StdoutFile {
                 Err(e) => {
                     match total_bytes {
                         // a complete failure
-                        0 => return Err(Error::new(Errno::EINVAL, "Failed to write")),
+                        0 => return errno!(EINVAL, "Failed to write"),
                         // a partially failure
                         _ => break,
                     }
@@ -357,7 +357,7 @@ impl File for StdoutFile {
     }
 
     fn seek(&self, seek_pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Stdout does not support seek"))
+        errno!(ESPIPE, "Stdout does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {
@@ -414,7 +414,7 @@ impl File for StdinFile {
     }
 
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "Stdin does not support write"))
+        errno!(EBADF, "Stdin does not support write")
     }
 
     fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize, Error> {
@@ -439,7 +439,7 @@ impl File for StdinFile {
                 Err(e) => {
                     match total_bytes {
                         // a complete failure
-                        0 => return Err(Error::new(Errno::EINVAL, "Failed to write")),
+                        0 => return errno!(EINVAL, "Failed to write"),
                         // a partially failure
                         _ => break,
                     }
@@ -450,11 +450,11 @@ impl File for StdinFile {
     }
 
     fn writev(&self, bufs: &[&[u8]]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "Stdin does not support write"))
+        errno!(EBADF, "Stdin does not support write")
     }
 
     fn seek(&self, pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Stdin does not support seek"))
+        errno!(ESPIPE, "Stdin does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {

src/libos/src/fs/inode_file.rs

@@ -32,7 +32,7 @@ pub struct OpenOptions {
 impl File for INodeFile {
     fn read(&self, buf: &mut [u8]) -> Result<usize, Error> {
         if !self.options.read {
-            return Err(Error::new(Errno::EBADF, "File not readable"));
+            return errno!(EBADF, "File not readable");
         }
         let mut offset = self.offset.lock().unwrap();
         let len = self.inode.read_at(*offset, buf)?;
@@ -42,7 +42,7 @@ impl File for INodeFile {
 
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
         if !self.options.write {
-            return Err(Error::new(Errno::EBADF, "File not writable"));
+            return errno!(EBADF, "File not writable");
         }
         let mut offset = self.offset.lock().unwrap();
         if self.options.append {
@@ -56,7 +56,7 @@ impl File for INodeFile {
 
     fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize, Error> {
         if !self.options.read {
-            return Err(Error::new(Errno::EBADF, "File not readable"));
+            return errno!(EBADF, "File not readable");
         }
         let len = self.inode.read_at(offset, buf)?;
         Ok(len)
@@ -64,7 +64,7 @@ impl File for INodeFile {
 
     fn write_at(&self, offset: usize, buf: &[u8]) -> Result<usize, Error> {
         if !self.options.write {
-            return Err(Error::new(Errno::EBADF, "File not writable"));
+            return errno!(EBADF, "File not writable");
         }
         let len = self.inode.write_at(offset, buf)?;
         Ok(len)
@@ -72,7 +72,7 @@ impl File for INodeFile {
 
     fn readv(&self, bufs: &mut [&mut [u8]]) -> Result<usize, Error> {
         if !self.options.read {
-            return Err(Error::new(Errno::EBADF, "File not readable"));
+            return errno!(EBADF, "File not readable");
         }
         let mut offset = self.offset.lock().unwrap();
         let mut total_len = 0;
@@ -91,7 +91,7 @@ impl File for INodeFile {
 
     fn writev(&self, bufs: &[&[u8]]) -> Result<usize, Error> {
         if !self.options.write {
-            return Err(Error::new(Errno::EBADF, "File not writable"));
+            return errno!(EBADF, "File not writable");
         }
         let mut offset = self.offset.lock().unwrap();
         if self.options.append {
@@ -129,7 +129,7 @@ impl File for INodeFile {
 
     fn set_len(&self, len: u64) -> Result<(), Error> {
         if !self.options.write {
-            return Err(Error::new(EBADF, "File not writable. Can't set len."));
+            return errno!(EBADF, "File not writable. Can't set len.");
         }
         self.inode.resize(len as usize)?;
         Ok(())
@@ -147,7 +147,7 @@ impl File for INodeFile {
 
     fn read_entry(&self) -> Result<String, Error> {
         if !self.options.read {
-            return Err(Error::new(EBADF, "File not readable. Can't read entry."));
+            return errno!(EBADF, "File not readable. Can't read entry.");
         }
         let mut offset = self.offset.lock().unwrap();
         let name = self.inode.get_entry(*offset)?;

src/libos/src/fs/io_multiplexing.rs

@@ -52,7 +52,7 @@ pub fn do_select(
     };
 
     if ret < 0 {
-        return Err(Error::new(Errno::from_retval(ret as i32), ""));
+        return errno!(Errno::from_retval(ret as i32), "");
     }
 
     // convert fd back and write fdset
@@ -97,7 +97,7 @@ pub fn do_poll(
     // recover fd ?
 
     if ret < 0 {
-        Err(Error::new(Errno::from_retval(ret as i32), ""))
+        errno!(Errno::from_retval(ret as i32), "")
     } else {
         Ok(ret as usize)
     }
@@ -202,7 +202,7 @@ impl EpollFileInner {
     pub fn new() -> Result<Self, Error> {
         let ret = unsafe { libc::ocall::epoll_create1(0) };
         if ret < 0 {
-            return Err(Error::new(Errno::from_retval(ret as i32), ""));
+            return errno!(Errno::from_retval(ret as i32), "");
         }
         Ok(EpollFileInner {
             epoll_fd: ret,
@@ -220,7 +220,7 @@ impl EpollFileInner {
             )
         };
         if ret < 0 {
-            return Err(Error::new(Errno::from_retval(ret as i32), ""));
+            return errno!(Errno::from_retval(ret as i32), "");
         }
         Ok(())
     }
@@ -241,7 +241,7 @@ impl EpollFileInner {
             )
         };
         if ret < 0 {
-            return Err(Error::new(Errno::from_retval(ret as i32), ""));
+            return errno!(Errno::from_retval(ret as i32), "");
         }
         Ok(ret as usize)
     }
@@ -281,7 +281,7 @@ impl File for EpollFile {
     }
 
     fn seek(&self, pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Epoll does not support seek"))
+        errno!(ESPIPE, "Epoll does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {

src/libos/src/fs/mod.rs

@@ -173,7 +173,7 @@ pub fn do_getdents64(fd: FileDesc, buf: &mut [u8]) -> Result<usize, Error> {
     let file_ref = current_process.get_files().lock().unwrap().get(fd)?;
     let info = file_ref.metadata()?;
     if info.type_ != FileType::Dir {
-        return Err(Error::new(ENOTDIR, ""));
+        return errno!(ENOTDIR, "");
     }
     let mut writer = unsafe { DirentBufWriter::new(buf) };
     loop {
@@ -267,7 +267,7 @@ pub fn do_chdir(path: &str) -> Result<(), Error> {
     let inode = current_process.lookup_inode(path)?;
     let info = inode.metadata()?;
     if info.type_ != FileType::Dir {
-        return Err(Error::new(ENOTDIR, ""));
+        return errno!(ENOTDIR, "");
     }
     current_process.change_cwd(path);
     Ok(())
@@ -295,7 +295,7 @@ pub fn do_mkdir(path: &str, mode: usize) -> Result<(), Error> {
     let (dir_path, file_name) = split_path(&path);
     let inode = current_process.lookup_inode(dir_path)?;
     if inode.find(file_name).is_ok() {
-        return Err(Error::new(EEXIST, ""));
+        return errno!(EEXIST, "");
     }
     inode.create(file_name, FileType::Dir, mode as u32)?;
     Ok(())
@@ -310,7 +310,7 @@ pub fn do_rmdir(path: &str) -> Result<(), Error> {
     let dir_inode = current_process.lookup_inode(dir_path)?;
     let file_inode = dir_inode.find(file_name)?;
     if file_inode.metadata()?.type_ != FileType::Dir {
-        return Err(Error::new(ENOTDIR, "rmdir on not directory"));
+        return errno!(ENOTDIR, "rmdir on not directory");
     }
     dir_inode.unlink(file_name)?;
     Ok(())
@@ -337,7 +337,7 @@ pub fn do_unlink(path: &str) -> Result<(), Error> {
     let dir_inode = current_process.lookup_inode(dir_path)?;
     let file_inode = dir_inode.find(file_name)?;
     if file_inode.metadata()?.type_ == FileType::Dir {
-        return Err(Error::new(EISDIR, "unlink on directory"));
+        return errno!(EISDIR, "unlink on directory");
     }
     dir_inode.unlink(file_name)?;
     Ok(())
@@ -381,7 +381,7 @@ pub fn do_sendfile(
         while bytes_written < read_len {
             let write_len = out_file.write(&buffer[bytes_written..])?;
             if write_len == 0 {
-                return Err(Error::new(EBADF, "sendfile write return 0"));
+                return errno!(EBADF, "sendfile write return 0");
             }
             bytes_written += write_len;
         }
@@ -406,7 +406,7 @@ impl Process {
             match dir_inode.find(file_name) {
                 Ok(file_inode) => {
                     if flags.contains(OpenFlags::EXCLUSIVE) {
-                        return Err(Error::new(EEXIST, "file exists"));
+                        return errno!(EEXIST, "file exists");
                     }
                     file_inode
                 }

src/libos/src/fs/pipe.rs

@@ -37,10 +37,7 @@ impl File for PipeReader {
     }
 
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
-        Err(Error::new(
+        errno!(EBADF, "PipeReader does not support write")
-            Errno::EBADF,
-            "PipeReader does not support write",
-        ))
     }
 
     fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize, Error> {
@@ -76,14 +73,11 @@ impl File for PipeReader {
     }
 
     fn writev(&self, bufs: &[&[u8]]) -> Result<usize, Error> {
-        Err(Error::new(
+        errno!(EBADF, "PipeReader does not support write")
-            Errno::EBADF,
-            "PipeReader does not support write",
-        ))
     }
 
     fn seek(&self, pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Pipe does not support seek"))
+        errno!(ESPIPE, "Pipe does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {
@@ -117,7 +111,7 @@ pub struct PipeWriter {
 
 impl File for PipeWriter {
     fn read(&self, buf: &mut [u8]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "PipeWriter does not support read"))
+        errno!(EBADF, "PipeWriter does not support read")
     }
 
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
@@ -133,7 +127,7 @@ impl File for PipeWriter {
     }
 
     fn readv(&self, bufs: &mut [&mut [u8]]) -> Result<usize, Error> {
-        Err(Error::new(Errno::EBADF, "PipeWriter does not support read"))
+        errno!(EBADF, "PipeWriter does not support read")
     }
 
     fn writev(&self, bufs: &[&[u8]]) -> Result<usize, Error> {
@@ -161,7 +155,7 @@ impl File for PipeWriter {
     }
 
     fn seek(&self, seek_pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Pipe does not support seek"))
+        errno!(ESPIPE, "Pipe does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {

src/libos/src/fs/socket_file.rs

@@ -11,7 +11,7 @@ impl SocketFile {
     pub fn new(domain: c_int, socket_type: c_int, protocol: c_int) -> Result<Self, Error> {
         let ret = unsafe { libc::ocall::socket(domain, socket_type, protocol) };
         if ret < 0 {
-            Err(Error::new(Errno::from_retval(ret as i32), ""))
+            errno!(Errno::from_retval(ret as i32), "")
         } else {
             Ok(SocketFile { fd: ret })
         }
@@ -25,7 +25,7 @@ impl SocketFile {
     ) -> Result<Self, Error> {
         let ret = unsafe { libc::ocall::accept4(self.fd, addr, addr_len, flags) };
         if ret < 0 {
-            Err(Error::new(Errno::from_retval(ret as i32), ""))
+            errno!(Errno::from_retval(ret as i32), "")
         } else {
             Ok(SocketFile { fd: ret })
         }
@@ -49,7 +49,7 @@ impl File for SocketFile {
     fn read(&self, buf: &mut [u8]) -> Result<usize, Error> {
         let ret = unsafe { libc::ocall::read(self.fd, buf.as_mut_ptr() as *mut c_void, buf.len()) };
         if ret < 0 {
-            Err(Error::new(Errno::from_retval(ret as i32), ""))
+            errno!(Errno::from_retval(ret as i32), "")
         } else {
             Ok(ret as usize)
         }
@@ -58,7 +58,7 @@ impl File for SocketFile {
     fn write(&self, buf: &[u8]) -> Result<usize, Error> {
         let ret = unsafe { libc::ocall::write(self.fd, buf.as_ptr() as *const c_void, buf.len()) };
         if ret < 0 {
-            Err(Error::new(Errno::from_retval(ret as i32), ""))
+            errno!(Errno::from_retval(ret as i32), "")
         } else {
             Ok(ret as usize)
         }
@@ -101,7 +101,7 @@ impl File for SocketFile {
     }
 
     fn seek(&self, pos: SeekFrom) -> Result<off_t, Error> {
-        Err(Error::new(Errno::ESPIPE, "Socket does not support seek"))
+        errno!(ESPIPE, "Socket does not support seek")
     }
 
     fn metadata(&self) -> Result<Metadata, Error> {

src/libos/src/prelude.rs

@@ -35,7 +35,7 @@ macro_rules! debug_trace {
 }
 
 macro_rules! errno {
-    ($errno: ident, $msg: expr) => {{
+    ($errno: expr, $msg: expr) => {{
         println!(
             "ERROR: {} ({}, line {} in file {})",
             $errno,

src/libos/src/process/spawn/init_stack.rs

@@ -139,7 +139,7 @@ impl StackBuf {
             let old_pos = self.stack_pos.get();
             let new_pos = align_down(old_pos - size, align);
             if new_pos < self.stack_bottom {
-                return Err(Error::new(Errno::ENOMEM, "No enough space in buffer"));
+                return errno!(ENOMEM, "No enough space in buffer");
             }
             new_pos
         };
@@ -274,7 +274,7 @@ impl AuxTable {
 
     pub fn set_val(&mut self, key: AuxKey, val: u64) -> Result<(), Error> {
         if key == AuxKey::AT_NULL || key == AuxKey::AT_IGNORE {
-            return Err(Error::new(Errno::EINVAL, "Illegal key"));
+            return errno!(EINVAL, "Illegal key");
         }
         self.values[key as usize] = Some(val);
         Ok(())

src/libos/src/process/spawn/mod.rs

@@ -65,7 +65,7 @@ pub fn do_spawn<P: AsRef<Path>>(
         let program_entry = {
             let program_entry = base_addr + elf_helper::get_start_address(&elf_file)?;
             if !vm.get_code_vma().contains_obj(program_entry, 16) {
-                return Err(Error::new(Errno::EINVAL, "Invalid program entry"));
+                return errno!(EINVAL, "Invalid program entry");
             }
             program_entry
         };

src/libos/src/syscall/mod.rs

@@ -436,7 +436,7 @@ fn do_write(fd: FileDesc, buf: *const u8, size: usize) -> Result<isize, Error> {
 fn do_writev(fd: FileDesc, iov: *const iovec_t, count: i32) -> Result<isize, Error> {
     let count = {
         if count < 0 {
-            return Err(Error::new(Errno::EINVAL, "Invalid count of iovec"));
+            return errno!(EINVAL, "Invalid count of iovec");
         }
         count as usize
     };
@@ -461,7 +461,7 @@ fn do_writev(fd: FileDesc, iov: *const iovec_t, count: i32) -> Result<isize, Err
 fn do_readv(fd: FileDesc, iov: *mut iovec_t, count: i32) -> Result<isize, Error> {
     let count = {
         if count < 0 {
-            return Err(Error::new(Errno::EINVAL, "Invalid count of iovec"));
+            return errno!(EINVAL, "Invalid count of iovec");
         }
         count as usize
     };
@@ -538,7 +538,7 @@ fn do_lseek(fd: FileDesc, offset: off_t, whence: i32) -> Result<isize, Error> {
         0 => {
             // SEEK_SET
             if offset < 0 {
-                return Err(Error::new(Errno::EINVAL, "Invalid offset"));
+                return errno!(EINVAL, "Invalid offset");
             }
             SeekFrom::Start(offset as u64)
         }
@@ -551,7 +551,7 @@ fn do_lseek(fd: FileDesc, offset: off_t, whence: i32) -> Result<isize, Error> {
             SeekFrom::End(offset)
         }
         _ => {
-            return Err(Error::new(Errno::EINVAL, "Invalid whence"));
+            return errno!(EINVAL, "Invalid whence");
         }
     };
 
@@ -767,7 +767,7 @@ fn do_unknown(
         "unknown or unsupported syscall (# = {}): {:#x}, {:#x}, {:#x}, {:#x}, {:#x}, {:#x}",
         num, arg0, arg1, arg2, arg3, arg4, arg5
     );
-    Err(Error::new(ENOSYS, "Unknown syscall"))
+    errno!(ENOSYS, "Unknown syscall")
 }
 
 fn do_getcwd(buf: *mut u8, size: usize) -> Result<isize, Error> {
@@ -779,7 +779,7 @@ fn do_getcwd(buf: *mut u8, size: usize) -> Result<isize, Error> {
     let mut proc = proc_ref.lock().unwrap();
     let cwd = proc.get_cwd();
     if cwd.len() + 1 > safe_buf.len() {
-        return Err(Error::new(ERANGE, "buf is not long enough"));
+        return errno!(ERANGE, "buf is not long enough");
     }
     safe_buf[..cwd.len()].copy_from_slice(cwd.as_bytes());
     safe_buf[cwd.len()] = 0;
@@ -1064,10 +1064,7 @@ fn do_select(
 ) -> Result<isize, Error> {
     // check arguments
     if nfds < 0 || nfds >= libc::FD_SETSIZE as c_int {
-        return Err(Error::new(
+        return errno!(EINVAL, "nfds is negative or exceeds the resource limit");
-            EINVAL,
-            "nfds is negative or exceeds the resource limit",
-        ));
     }
     let nfds = nfds as usize;
 
@@ -1114,7 +1111,7 @@ fn do_poll(fds: *mut libc::pollfd, nfds: libc::nfds_t, timeout: c_int) -> Result
 
 fn do_epoll_create(size: c_int) -> Result<isize, Error> {
     if size <= 0 {
-        return Err(Error::new(EINVAL, "size is not positive"));
+        return errno!(EINVAL, "size is not positive");
     }
     do_epoll_create1(0)
 }
@@ -1145,7 +1142,7 @@ fn do_epoll_wait(
 ) -> Result<isize, Error> {
     let maxevents = {
         if maxevents <= 0 {
-            return Err(Error::new(EINVAL, "maxevents <= 0"));
+            return errno!(EINVAL, "maxevents <= 0");
         }
         maxevents as usize
     };

src/libos/src/vm/mod.rs

@@ -74,7 +74,7 @@ pub struct VMAllocOptions {
 impl VMAllocOptions {
     pub fn new(size: usize) -> Result<VMAllocOptions, Error> {
         if size % PAGE_SIZE != 0 {
-            return Err(Error::new(Errno::EINVAL, "Size is not page-aligned"));
+            return errno!(EINVAL, "Size is not page-aligned");
         }
         Ok(VMAllocOptions {
             size,
@@ -84,7 +84,7 @@ impl VMAllocOptions {
 
     pub fn addr(&mut self, addr: VMAddrOption) -> Result<&mut Self, Error> {
         if addr.is_addr_given() && addr.get_addr() % PAGE_SIZE != 0 {
-            return Err(Error::new(Errno::EINVAL, "Invalid address"));
+            return errno!(EINVAL, "Invalid address");
         }
         self.addr = addr;
         Ok(self)
@@ -175,7 +175,7 @@ pub struct VMResizeOptions {
 impl VMResizeOptions {
     pub fn new(new_size: usize) -> Result<VMResizeOptions, Error> {
         if new_size % PAGE_SIZE != 0 {
-            return Err(Error::new(Errno::EINVAL, "Size is not page-aligned"));
+            return errno!(EINVAL, "Size is not page-aligned");
         }
         Ok(VMResizeOptions {
             new_size,

src/libos/src/vm/process_vm.rs

@@ -169,7 +169,7 @@ impl ProcessVM {
                     VMAddrOption::Beyond(mmap_start_addr)
                 } else {
                     if addr < mmap_start_addr {
-                        return Err(Error::new(Errno::EINVAL, "Beyond valid memory range"));
+                        return errno!(EINVAL, "Beyond valid memory range");
                     }
                     // TODO: Fixed or Hint? Should hanle mmap flags
                     VMAddrOption::Hint(addr)
@@ -212,7 +212,7 @@ impl ProcessVM {
         options: &VMResizeOptions,
     ) -> Result<usize, Error> {
         // TODO: Implement this!
-        Err(Error::new(Errno::EINVAL, "Not implemented"))
+        errno!(EINVAL, "Not implemented")
     }
 
     pub fn brk(&mut self, new_brk: usize) -> Result<usize, Error> {