Sync the libc version of PollFd with the linux_raw version.

Port the `set_fd` and `AsFd` implementations from the linux_raw `PollFd`
to the libc `PollFd`.

Author: sunfishcode

src/imp/libc/io/poll_fd.rs

@@ -1,6 +1,6 @@
 use super::super::c;
 use super::super::conv::borrowed_fd;
-use crate::fd::{AsFd, BorrowedFd};
+use crate::fd::{AsFd, AsRawFd, BorrowedFd};
 use bitflags::bitflags;
 use core::marker::PhantomData;
 
@@ -61,6 +61,12 @@ impl<'fd> PollFd<'fd> {
         Self::from_borrowed_fd(fd.as_fd(), events)
     }
 
+    /// Sets the contained file descriptor to `fd`.
+    #[inline]
+    pub fn set_fd<Fd: AsFd>(&mut self, fd: &'fd Fd) {
+        self.pollfd.fd = fd.as_fd().as_raw_fd();
+    }
+
     /// Constructs a new `PollFd` holding `fd` and `events`.
     ///
     /// This is the same as `new`, but can be used to avoid borrowing the
@@ -78,11 +84,22 @@ impl<'fd> PollFd<'fd> {
         }
     }
 
-    /// Return the ready events.
+    /// Returns the ready events.
     #[inline]
     pub fn revents(&self) -> PollFlags {
         // Use `unwrap()` here because in theory we know we know all the bits
         // the OS might set here, but OS's have added extensions in the past.
         PollFlags::from_bits(self.pollfd.revents).unwrap()
     }
 }
+
+impl<'fd> AsFd for PollFd<'fd> {
+    #[inline]
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        // Safety:
+        //
+        // Our constructors and `set_fd` require `pollfd.fd` to be valid
+        // for the `fd lifetime.
+        unsafe { BorrowedFd::borrow_raw_fd(self.pollfd.fd) }
+    }
+}

tests/io/main.rs

@@ -19,6 +19,8 @@ mod isatty;
 #[cfg(not(windows))]
 mod mmap;
 #[cfg(not(windows))]
+mod poll;
+#[cfg(not(windows))]
 mod prot;
 #[cfg(not(windows))]
 #[cfg(not(target_os = "redox"))] // redox doesn't have cwd/openat

tests/io/poll.rs

@@ -0,0 +1,53 @@
+use rustix::fd::{AsFd, AsRawFd, FromRawFd, IntoRawFd, OwnedFd};
+use rustix::io::{pipe, poll, read, with_retrying, write, PollFd, PollFlags};
+
+#[test]
+fn test_poll() {
+    // Create a pipe.
+    let (reader, writer) = pipe().unwrap();
+    let mut poll_fds = [PollFd::new(&reader, PollFlags::IN)];
+    assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
+
+    // `poll` should say there's nothing ready to be read fron the pipe.
+    let num = with_retrying(|| poll(&mut poll_fds, 0)).unwrap();
+    assert_eq!(num, 0);
+    assert!(poll_fds[0].revents().is_empty());
+    assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
+
+    // Write a byte to the pipe.
+    assert_eq!(with_retrying(|| write(&writer, b"a")).unwrap(), 1);
+
+    // `poll` should now say there's data to be read.
+    let num = with_retrying(|| poll(&mut poll_fds, -1)).unwrap();
+    assert_eq!(num, 1);
+    assert_eq!(poll_fds[0].revents(), PollFlags::IN);
+    assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
+
+    // Read the byte from the pipe.
+    let mut buf = [b'\0'];
+    assert_eq!(with_retrying(|| read(&reader, &mut buf)).unwrap(), 1);
+    assert_eq!(buf[0], b'a');
+    assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
+
+    // Poll should now say there's no more data to be read.
+    let num = with_retrying(|| poll(&mut poll_fds, 0)).unwrap();
+    assert_eq!(num, 0);
+    assert!(poll_fds[0].revents().is_empty());
+    assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd());
+}
+
+#[test]
+fn test_poll_fd_set_fd() {
+    // Make up some file descriptors so that we can test that set_fd works.
+    let a = unsafe { OwnedFd::from_raw_fd(777) };
+    let mut poll_fd = PollFd::new(&a, PollFlags::empty());
+    assert_eq!(poll_fd.as_fd().as_raw_fd(), 777);
+
+    let b = unsafe { OwnedFd::from_raw_fd(888) };
+    poll_fd.set_fd(&b);
+    assert_eq!(poll_fd.as_fd().as_raw_fd(), 888);
+
+    // Don't attempt to close our made-up file descriptors.
+    let _ = a.into_raw_fd();
+    let _ = b.into_raw_fd();
+}