libc_util: add helpers to deal with errno-style functions

Author: RalfJung

src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs

@@ -4,6 +4,7 @@ use std::convert::TryInto;
 
 #[path = "../../utils/libc.rs"]
 mod libc_utils;
+use libc_utils::*;
 
 fn main() {
     test_epoll_socketpair();
@@ -51,13 +52,11 @@ fn check_epoll_wait<const N: usize>(epfd: i32, expected_notifications: &[(u32, u
 
 fn test_epoll_socketpair() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
     let fds = [fds[1], fds[0]];
 
     // Write to fd[0]
@@ -92,8 +91,7 @@ fn test_epoll_socketpair() {
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Close the peer socketpair.
-    let res = unsafe { libc::close(fds[0]) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(fds[0]) });
 
     // Check result from epoll_wait.
     // We expect to get a read, write, HUP notification from the close since closing an FD always unblocks reads and writes on its peer.
@@ -108,13 +106,11 @@ fn test_epoll_socketpair() {
 // Also check that the new data value set via MOD is applied properly.
 fn test_epoll_ctl_mod() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register fd[1] with EPOLLIN|EPOLLET, and data of "0".
     let mut ev = libc::epoll_event { events: (libc::EPOLLIN | libc::EPOLLET) as _, u64: 0 };
@@ -164,13 +160,11 @@ fn test_epoll_ctl_mod() {
 
 fn test_epoll_ctl_del() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Write to fd[0]
     let data = "abcde".as_bytes().as_ptr();
@@ -198,8 +192,7 @@ fn test_two_epoll_instance() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Write to the socketpair.
     let data = "abcde".as_bytes().as_ptr();
@@ -224,13 +217,11 @@ fn test_two_epoll_instance() {
 // Notification should be provided for both.
 fn test_two_same_fd_in_same_epoll_instance() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Dup the fd.
     let newfd = unsafe { libc::dup(fds[1]) };
@@ -260,14 +251,13 @@ fn test_two_same_fd_in_same_epoll_instance() {
 fn test_epoll_eventfd() {
     // Create an eventfd instance.
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd = unsafe { libc::eventfd(0, flags) };
+    let fd = errno_result(unsafe { libc::eventfd(0, flags) }).unwrap();
 
     // Write 1 to the eventfd instance.
     libc_utils::write_all_from_slice(fd, &1_u64.to_ne_bytes()).unwrap();
 
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
@@ -308,13 +298,11 @@ fn test_epoll_eventfd() {
 // When read/write happened on one side of the socketpair, only the other side will be notified.
 fn test_epoll_socketpair_both_sides() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register both fd to the same epoll instance.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
@@ -358,12 +346,11 @@ fn test_epoll_socketpair_both_sides() {
 // that file description.
 fn test_closed_fd() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create an eventfd instance.
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd = unsafe { libc::eventfd(0, flags) };
+    let fd = errno_result(unsafe { libc::eventfd(0, flags) }).unwrap();
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
@@ -376,8 +363,7 @@ fn test_closed_fd() {
     assert_eq!(res, 8);
 
     // Close the eventfd.
-    let res = unsafe { libc::close(fd) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(fd) });
 
     // No notification should be provided because the file description is closed.
     check_epoll_wait::<8>(epfd, &[]);
@@ -391,25 +377,22 @@ fn test_closed_fd() {
 // referring to the underlying open file description have been closed.
 fn test_not_fully_closed_fd() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create an eventfd instance.
-    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd = unsafe { libc::eventfd(0, flags) };
+    let fd =
+        errno_result(unsafe { libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC) }).unwrap();
 
     // Dup the fd.
-    let newfd = unsafe { libc::dup(fd) };
-    assert_ne!(newfd, -1);
+    let newfd = errno_result(unsafe { libc::dup(fd) }).unwrap();
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
     assert_eq!(res, 0);
 
     // Close the original fd that being used to register with epoll.
-    let res = unsafe { libc::close(fd) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(fd) });
 
     // Notification should still be provided because the file description is not closed.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
@@ -423,8 +406,7 @@ fn test_not_fully_closed_fd() {
     assert_eq!(res, 8);
 
     // Close the dupped fd.
-    let res = unsafe { libc::close(newfd) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(newfd) });
 
     // No notification should be provided.
     check_epoll_wait::<1>(epfd, &[]);
@@ -434,17 +416,16 @@ fn test_not_fully_closed_fd() {
 // at the moment the latest event occurred.
 fn test_event_overwrite() {
     // Create an eventfd instance.
-    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd = unsafe { libc::eventfd(0, flags) };
+    let fd =
+        errno_result(unsafe { libc::eventfd(0, libc::EFD_NONBLOCK | libc::EFD_CLOEXEC) }).unwrap();
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
     let res = unsafe { libc_utils::write_all(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
     assert_eq!(res, 8);
 
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event {
@@ -469,13 +450,11 @@ fn test_event_overwrite() {
 // This behaviour differs from the real system.
 fn test_socketpair_read() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register both fd to the same epoll instance.
     let mut ev = libc::epoll_event {
@@ -533,13 +512,11 @@ fn test_socketpair_read() {
 // This is to test whether flag that we don't register won't trigger notification.
 fn test_no_notification_for_unregister_flag() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register fd[0] with EPOLLOUT|EPOLLET.
     let mut ev = libc::epoll_event {
@@ -565,8 +542,7 @@ fn test_no_notification_for_unregister_flag() {
 
 fn test_epoll_wait_maxevent_zero() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
     // It is ok to use a dangling pointer here because it will error out before the
     // pointer actually gets accessed.
     let array_ptr = std::ptr::without_provenance_mut::<libc::epoll_event>(0x100);
@@ -578,13 +554,11 @@ fn test_epoll_wait_maxevent_zero() {
 
 fn test_socketpair_epollerr() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Write to fd[0]
     let data = "abcde".as_bytes().as_ptr();
@@ -593,8 +567,7 @@ fn test_socketpair_epollerr() {
 
     // Close fds[1].
     // EPOLLERR will be triggered if we close peer fd that still has data in its read buffer.
-    let res = unsafe { libc::close(fds[1]) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(fds[1]) });
 
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP
     let mut ev = libc::epoll_event {
@@ -617,13 +590,11 @@ fn test_socketpair_epollerr() {
 // epoll can lose events if they don't fit in the output buffer.
 fn test_epoll_lost_events() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register both fd to the same epoll instance.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
@@ -649,13 +620,12 @@ fn test_epoll_lost_events() {
 // Related discussion in https://github.com/rust-lang/miri/pull/3818#discussion_r1720679440.
 fn test_ready_list_fetching_logic() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Create two eventfd instances.
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd0 = unsafe { libc::eventfd(0, flags) };
-    let fd1 = unsafe { libc::eventfd(0, flags) };
+    let fd0 = errno_result(unsafe { libc::eventfd(0, flags) }).unwrap();
+    let fd1 = errno_result(unsafe { libc::eventfd(0, flags) }).unwrap();
 
     // Register both fd to the same epoll instance. At this point, both of them are on the ready list.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fd0 as u64 };
@@ -666,8 +636,7 @@ fn test_ready_list_fetching_logic() {
     assert_eq!(res, 0);
 
     // Close fd0 so the first entry in the ready list will be empty.
-    let res = unsafe { libc::close(fd0) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(fd0) });
 
     // Notification for fd1 should be returned.
     let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
@@ -679,8 +648,7 @@ fn test_ready_list_fetching_logic() {
 // (The docs say loops cause EINVAL, but experiments show it is EFAULT.)
 fn test_epoll_ctl_epfd_equal_fd() {
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     let array_ptr = std::ptr::without_provenance_mut::<libc::epoll_event>(0x100);
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, epfd, array_ptr) };
@@ -699,8 +667,7 @@ fn test_epoll_ctl_notification() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
 
     // Register one side of the socketpair with epoll.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
@@ -736,11 +703,10 @@ fn test_epoll_ctl_notification() {
 fn test_issue_3858() {
     // Create an eventfd instance.
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
-    let fd = unsafe { libc::eventfd(0, flags) };
+    let fd = errno_result(unsafe { libc::eventfd(0, flags) }).unwrap();
 
     // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
+    let epfd = errno_result(unsafe { libc::epoll_create1(0) }).unwrap();
 
     // Register eventfd with EPOLLIN | EPOLLET.
     let mut ev = libc::epoll_event {
@@ -755,8 +721,7 @@ fn test_issue_3858() {
     assert_ne!(newfd, -1);
 
     // Close the old epoll instance, so the new FD is now the only FD.
-    let res = unsafe { libc::close(epfd) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::close(epfd) });
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
@@ -772,8 +737,7 @@ fn test_issue_4374() {
 
     // Create a socketpair instance, make it non-blocking.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
     assert_eq!(unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) }, 0);
     assert_eq!(unsafe { libc::fcntl(fds[1], libc::F_SETFL, libc::O_NONBLOCK) }, 0);
 
@@ -805,8 +769,7 @@ fn test_issue_4374_reads() {
 
     // Create a socketpair instance, make it non-blocking.
     let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
+    errno_check(unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) });
     assert_eq!(unsafe { libc::fcntl(fds[0], libc::F_SETFL, libc::O_NONBLOCK) }, 0);
     assert_eq!(unsafe { libc::fcntl(fds[1], libc::F_SETFL, libc::O_NONBLOCK) }, 0);