calls: Update params in openat2()

src/calls/getfsstat.rs

@@ -5,7 +5,9 @@ pub unsafe fn getfsstat(buf: Option<&mut [statfs_t]>, mode: i32) -> Result<i32,
     let buf_size = buf
         .as_ref()
         .map_or(0, |buf| buf.len() * core::mem::size_of::<statfs_t>());
-    let buf_ptr = buf.map_or(0, |buf| buf.as_mut_ptr() as usize);
+    let buf_ptr = buf.map_or(core::mem::null_mut::<statfs_t>() as usize, |buf| {
+        buf.as_mut_ptr() as usize
+    });
     let mode = mode as usize;
     syscall3(SYS_GETFSSTAT, buf_ptr, buf_size, mode).map(|val| val as i32)
 }

src/calls/getvfsstat.rs

@@ -5,7 +5,9 @@ pub unsafe fn getvfsstat(buf: Option<&mut [statvfs_t]>, mode: i32) -> Result<i32
     let buf_size = buf
         .as_ref()
         .map_or(0, |buf| buf.len() * core::mem::size_of::<statvfs_t>());
-    let buf_ptr = buf.map_or(0, |buf| buf.as_mut_ptr() as usize);
+    let buf_ptr = buf.map_or(core::mem::null_mut::<statvfs_t>() as usize, |buf| {
+        buf.as_mut_ptr() as usize
+    });
     let mode = mode as usize;
     syscall3(SYS_GETVFSSTAT, buf_ptr, buf_size, mode).map(|val| val as i32)
 }

src/calls/openat2_linux.rs → src/calls/openat2.rs

@@ -3,14 +3,12 @@
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -20,11 +18,11 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }

src/platform/linux-aarch64/call.rs

@@ -3959,14 +3959,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -3976,13 +3974,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-arm/call.rs

@@ -4534,14 +4534,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4551,13 +4549,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-mips/call.rs

@@ -4699,14 +4699,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4716,13 +4714,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-mips64/call.rs

@@ -4449,14 +4449,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4466,13 +4464,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-ppc64/call.rs

@@ -4570,14 +4570,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4587,13 +4585,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-riscv64/call.rs

@@ -3959,14 +3959,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -3976,13 +3974,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-s390x/call.rs

@@ -4532,14 +4532,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4549,13 +4547,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-x86/call.rs

@@ -4714,14 +4714,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4731,13 +4729,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file

src/platform/linux-x86_64/call.rs

@@ -4497,14 +4497,12 @@ pub unsafe fn openat<P: AsRef<Path>>(
 /// # Examples
 ///
 /// ```
-/// use core::mem::size_of;
 /// let path = "/etc/passwd";
 /// let mut how = nc::open_how_t{
 ///   flags: nc::O_RDONLY as u64,
 ///   ..nc::open_how_t::default()
 /// };
-/// let how_size = size_of::<nc::open_how_t>();
-/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how, how_size) };
+/// let ret = unsafe { nc::openat2(nc::AT_FDCWD, path, &mut how) };
 /// assert!(ret.is_ok());
 /// let fd = ret.unwrap();
 /// let ret = unsafe { nc::close(fd) };
@@ -4514,13 +4512,13 @@ pub unsafe fn openat2<P: AsRef<Path>>(
     dirfd: i32,
     pathname: P,
     how: &mut open_how_t,
-    size: size_t,
 ) -> Result<i32, Errno> {
     let dirfd = dirfd as usize;
     let pathname = CString::new(pathname.as_ref());
     let pathname_ptr = pathname.as_ptr() as usize;
     let how_ptr = how as *mut open_how_t as usize;
-    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, size).map(|ret| ret as i32)
+    let how_size = core::mem::size_of::<open_how_t>();
+    syscall4(SYS_OPENAT2, dirfd, pathname_ptr, how_ptr, how_size).map(|ret| ret as i32)
 }
 
 /// Obtain handle for an open file