calls: Update epoll_wait/epoll_pwait

src/calls/cap_ioctls_get.rs

@@ -3,6 +3,6 @@
 pub unsafe fn cap_ioctls_get(fd: i32, cmds: &mut [usize]) -> Result<ssize_t, Errno> {
     let fd = fd as usize;
     let cmds_ptr = cmds.as_mut_ptr() as usize;
-    let ncmds = cmds.len();
-    syscall3(SYS_CAP_IOCTLS_GET, fd, cmds_ptr, ncmds).map(|val| val as ssize_t)
+    let max_cmds = cmds.len();
+    syscall3(SYS_CAP_IOCTLS_GET, fd, cmds_ptr, max_cmds).map(|val| val as ssize_t)
 }

src/calls/epoll_pwait.rs

@@ -19,19 +19,15 @@
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
+/// let mut events = [nc::epoll_event_t::default(); 4];
 /// let timeout = 0;
-/// let sigmask = nc::sigset_t::default();
-/// let sigmask_size = core::mem::size_of_val(&sigmask);
+/// let sigmask = [nc::sigset_t::default(); 4];
 /// let ret = unsafe {
 ///     nc::epoll_pwait(
 ///         epfd,
 ///         &mut events,
-///         events_len as i32,
 ///         timeout,
 ///         &sigmask,
-///         sigmask_size,
 ///     )
 /// };
 /// assert!(ret.is_ok());
@@ -42,9 +38,8 @@
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -61,16 +56,15 @@
 pub unsafe fn epoll_pwait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
-    sigmask: &sigset_t,
-    sigset_size: usize,
+    sigmask: &[sigset_t],
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
-    let sigmask_ptr = sigmask as *const sigset_t as usize;
+    let sigmask_ptr = sigmask.as_ptr() as usize;
+    let sigset_size = sigmask.len();
     syscall6(
         SYS_EPOLL_PWAIT,
         epfd,

src/calls/epoll_wait.rs

@@ -19,9 +19,8 @@
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
-/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, events_len as i32, 0) };
+/// let mut events = [nc::epoll_event_t::default(); 4];
+/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, 0) };
 /// assert!(ret.is_ok());
 /// assert_eq!(ret, Ok(1));
 ///
@@ -30,9 +29,8 @@
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -49,12 +47,11 @@
 pub unsafe fn epoll_wait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
     syscall4(SYS_EPOLL_WAIT, epfd, events_ptr, max_events, timeout).map(|ret| ret as i32)
 }

src/platform/linux-aarch64/call.rs

@@ -585,19 +585,15 @@ pub unsafe fn epoll_ctl(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
+/// let mut events = [nc::epoll_event_t::default(); 4];
 /// let timeout = 0;
-/// let sigmask = nc::sigset_t::default();
-/// let sigmask_size = core::mem::size_of_val(&sigmask);
+/// let sigmask = [nc::sigset_t::default(); 4];
 /// let ret = unsafe {
 ///     nc::epoll_pwait(
 ///         epfd,
 ///         &mut events,
-///         events_len as i32,
 ///         timeout,
 ///         &sigmask,
-///         sigmask_size,
 ///     )
 /// };
 /// assert!(ret.is_ok());
@@ -608,9 +604,8 @@ pub unsafe fn epoll_ctl(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -627,16 +622,15 @@ pub unsafe fn epoll_ctl(
 pub unsafe fn epoll_pwait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
-    sigmask: &sigset_t,
-    sigset_size: usize,
+    sigmask: &[sigset_t],
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
-    let sigmask_ptr = sigmask as *const sigset_t as usize;
+    let sigmask_ptr = sigmask.as_ptr() as usize;
+    let sigset_size = sigmask.len();
     syscall6(
         SYS_EPOLL_PWAIT,
         epfd,

src/platform/linux-arm/call.rs

@@ -736,19 +736,15 @@ pub unsafe fn epoll_ctl(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
+/// let mut events = [nc::epoll_event_t::default(); 4];
 /// let timeout = 0;
-/// let sigmask = nc::sigset_t::default();
-/// let sigmask_size = core::mem::size_of_val(&sigmask);
+/// let sigmask = [nc::sigset_t::default(); 4];
 /// let ret = unsafe {
 ///     nc::epoll_pwait(
 ///         epfd,
 ///         &mut events,
-///         events_len as i32,
 ///         timeout,
 ///         &sigmask,
-///         sigmask_size,
 ///     )
 /// };
 /// assert!(ret.is_ok());
@@ -759,9 +755,8 @@ pub unsafe fn epoll_ctl(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -778,16 +773,15 @@ pub unsafe fn epoll_ctl(
 pub unsafe fn epoll_pwait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
-    sigmask: &sigset_t,
-    sigset_size: usize,
+    sigmask: &[sigset_t],
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
-    let sigmask_ptr = sigmask as *const sigset_t as usize;
+    let sigmask_ptr = sigmask.as_ptr() as usize;
+    let sigset_size = sigmask.len();
     syscall6(
         SYS_EPOLL_PWAIT,
         epfd,
@@ -821,9 +815,8 @@ pub unsafe fn epoll_pwait(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
-/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, events_len as i32, 0) };
+/// let mut events = [nc::epoll_event_t::default(); 4];
+/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, 0) };
 /// assert!(ret.is_ok());
 /// assert_eq!(ret, Ok(1));
 ///
@@ -832,9 +825,8 @@ pub unsafe fn epoll_pwait(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -851,12 +843,11 @@ pub unsafe fn epoll_pwait(
 pub unsafe fn epoll_wait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
     syscall4(SYS_EPOLL_WAIT, epfd, events_ptr, max_events, timeout).map(|ret| ret as i32)
 }

src/platform/linux-loongarch64/call.rs

@@ -525,19 +525,15 @@ pub unsafe fn epoll_ctl(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
+/// let mut events = [nc::epoll_event_t::default(); 4];
 /// let timeout = 0;
-/// let sigmask = nc::sigset_t::default();
-/// let sigmask_size = core::mem::size_of_val(&sigmask);
+/// let sigmask = [nc::sigset_t::default(); 4];
 /// let ret = unsafe {
 ///     nc::epoll_pwait(
 ///         epfd,
 ///         &mut events,
-///         events_len as i32,
 ///         timeout,
 ///         &sigmask,
-///         sigmask_size,
 ///     )
 /// };
 /// assert!(ret.is_ok());
@@ -548,9 +544,8 @@ pub unsafe fn epoll_ctl(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -567,16 +562,15 @@ pub unsafe fn epoll_ctl(
 pub unsafe fn epoll_pwait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
-    sigmask: &sigset_t,
-    sigset_size: usize,
+    sigmask: &[sigset_t],
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
-    let sigmask_ptr = sigmask as *const sigset_t as usize;
+    let sigmask_ptr = sigmask.as_ptr() as usize;
+    let sigset_size = sigmask.len();
     syscall6(
         SYS_EPOLL_PWAIT,
         epfd,

src/platform/linux-mips/call.rs

@@ -778,19 +778,15 @@ pub unsafe fn epoll_ctl(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
+/// let mut events = [nc::epoll_event_t::default(); 4];
 /// let timeout = 0;
-/// let sigmask = nc::sigset_t::default();
-/// let sigmask_size = core::mem::size_of_val(&sigmask);
+/// let sigmask = [nc::sigset_t::default(); 4];
 /// let ret = unsafe {
 ///     nc::epoll_pwait(
 ///         epfd,
 ///         &mut events,
-///         events_len as i32,
 ///         timeout,
 ///         &sigmask,
-///         sigmask_size,
 ///     )
 /// };
 /// assert!(ret.is_ok());
@@ -801,9 +797,8 @@ pub unsafe fn epoll_ctl(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -820,16 +815,15 @@ pub unsafe fn epoll_ctl(
 pub unsafe fn epoll_pwait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
-    sigmask: &sigset_t,
-    sigset_size: usize,
+    sigmask: &[sigset_t],
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
-    let sigmask_ptr = sigmask as *const sigset_t as usize;
+    let sigmask_ptr = sigmask.as_ptr() as usize;
+    let sigset_size = sigmask.len();
     syscall6(
         SYS_EPOLL_PWAIT,
         epfd,
@@ -863,9 +857,8 @@ pub unsafe fn epoll_pwait(
 /// let ret = unsafe { nc::write(fds[1], msg.as_ptr() as usize, msg.len()) };
 /// assert!(ret.is_ok());
 ///
-/// let mut events = vec![nc::epoll_event_t::default(); 4];
-/// let events_len = events.len();
-/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, events_len as i32, 0) };
+/// let mut events = [nc::epoll_event_t::default(); 4];
+/// let ret = unsafe { nc::epoll_wait(epfd, &mut events, 0) };
 /// assert!(ret.is_ok());
 /// assert_eq!(ret, Ok(1));
 ///
@@ -874,9 +867,8 @@ pub unsafe fn epoll_pwait(
 ///     if event.events == nc::EPOLLIN {
 ///         let ready_fd = unsafe { event.data.fd };
 ///         assert_eq!(ready_fd, fds[0]);
-///         let mut buf = vec![0_u8; 64];
-///         let buf_len = buf.len();
-///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf_len) };
+///         let mut buf = [0_u8; 64];
+///         let ret = unsafe { nc::read(ready_fd, buf.as_mut_ptr() as usize, buf.len()) };
 ///         assert!(ret.is_ok());
 ///         let n_read = ret.unwrap() as usize;
 ///         assert_eq!(msg.as_bytes(), &buf[..n_read]);
@@ -893,12 +885,11 @@ pub unsafe fn epoll_pwait(
 pub unsafe fn epoll_wait(
     epfd: i32,
     events: &mut [epoll_event_t],
-    max_events: i32,
     timeout: i32,
 ) -> Result<i32, Errno> {
     let epfd = epfd as usize;
     let events_ptr = events.as_mut_ptr() as usize;
-    let max_events = max_events as usize;
+    let max_events = events.len();
     let timeout = timeout as usize;
     syscall4(SYS_EPOLL_WAIT, epfd, events_ptr, max_events, timeout).map(|ret| ret as i32)
 }