From a0ab26a7677eed4698f9728e42a13c760fa85e7c Mon Sep 17 00:00:00 2001
From: Matthias Schiffer <mschiffer@universe-factory.net>
Date: Sat, 30 Sep 2023 23:01:17 +0200
Subject: runner: jobserver: use OwnedFds

---
 crates/runner/src/jobserver.rs | 44 ++++++++++++++++++++----------------------
 crates/runner/src/util/unix.rs | 19 +++++++++++-------
 2 files changed, 33 insertions(+), 30 deletions(-)

diff --git a/crates/runner/src/jobserver.rs b/crates/runner/src/jobserver.rs
index a44ba6c..2422a75 100644
--- a/crates/runner/src/jobserver.rs
+++ b/crates/runner/src/jobserver.rs
@@ -1,5 +1,5 @@
 use std::{
-	os::{fd::BorrowedFd, unix::prelude::RawFd},
+	os::fd::{AsRawFd, FromRawFd, OwnedFd},
 	slice,
 };
 
@@ -12,38 +12,37 @@ use super::util::unix;
 #[derive(Debug)]
 pub struct Jobserver {
 	tokens: usize,
-	r: RawFd,
-	w: RawFd,
+	r: OwnedFd,
+	w: OwnedFd,
 }
 
 impl Jobserver {
 	pub fn new(tokens: usize) -> Result<Jobserver> {
-		let (r, w) = unistd::pipe2(OFlag::O_CLOEXEC | OFlag::O_NONBLOCK).context("pipe()")?;
+		let (piper, pipew) =
+			unistd::pipe2(OFlag::O_CLOEXEC | OFlag::O_NONBLOCK).context("pipe()")?;
+		let r = unsafe { OwnedFd::from_raw_fd(piper) };
+		let w = unsafe { OwnedFd::from_raw_fd(pipew) };
 
 		for _ in 0..tokens {
-			if unistd::write(w, b"+").is_err() {
+			if unistd::write(w.as_raw_fd(), b"+").is_err() {
 				break;
 			}
 		}
-		unix::set_blocking(w, true)?;
+		unix::set_blocking(&w, true)?;
 
 		Ok(Jobserver { tokens, r, w })
 	}
 
-	fn read_fd(&self) -> BorrowedFd<'_> {
-		unsafe { BorrowedFd::borrow_raw(self.r) }
-	}
-
 	pub fn wait(&mut self) -> u8 {
 		loop {
 			poll::poll(
-				&mut [poll::PollFd::new(&self.read_fd(), poll::PollFlags::POLLIN)],
+				&mut [poll::PollFd::new(&self.r, poll::PollFlags::POLLIN)],
 				-1,
 			)
 			.expect("poll()");
 
 			let mut token = 0;
-			match unistd::read(self.r, slice::from_mut(&mut token)) {
+			match unistd::read(self.r.as_raw_fd(), slice::from_mut(&mut token)) {
 				Ok(n) => {
 					assert!(n == 1);
 					return token;
@@ -60,25 +59,24 @@ impl Jobserver {
 	}
 
 	pub fn post(&mut self, token: u8) {
-		let n = unistd::write(self.w, slice::from_ref(&token)).expect("write()");
+		let n = unistd::write(self.w.as_raw_fd(), slice::from_ref(&token)).expect("write()");
 		assert!(n == 1);
 	}
 
 	pub fn set_cloexec(&mut self, cloexec: bool) -> Result<()> {
-		unix::set_cloexec(self.r, cloexec)?;
-		unix::set_cloexec(self.w, cloexec)?;
+		unix::set_cloexec(&self.r, cloexec)?;
+		unix::set_cloexec(&self.w, cloexec)?;
 		Ok(())
 	}
 
 	pub fn to_makeflags(&self) -> String {
-		format!(" -j{} --jobserver-auth={},{}", self.tokens, self.r, self.w)
+		format!(
+			" -j{} --jobserver-auth={},{}",
+			self.tokens,
+			self.r.as_raw_fd(),
+			self.w.as_raw_fd(),
+		)
 	}
 }
 
-impl Drop for Jobserver {
-	fn drop(&mut self) {
-		// FIXME Logging
-		let _ = unistd::close(self.r);
-		let _ = unistd::close(self.w);
-	}
-}
+// FIXME Log lost tokens on drop
diff --git a/crates/runner/src/util/unix.rs b/crates/runner/src/util/unix.rs
index c3e9ddb..156e441 100644
--- a/crates/runner/src/util/unix.rs
+++ b/crates/runner/src/util/unix.rs
@@ -10,9 +10,11 @@ use common::error::*;
 
 use super::fs;
 
-pub fn set_blocking(fd: RawFd, blocking: bool) -> Result<()> {
+pub fn set_blocking<Fd: AsFd>(fd: &Fd, blocking: bool) -> Result<()> {
+	let raw_fd = fd.as_fd().as_raw_fd();
+
 	let flags =
-		OFlag::from_bits_retain(fcntl::fcntl(fd, FcntlArg::F_GETFL).context("fcntl(F_GETFL)")?);
+		OFlag::from_bits_retain(fcntl::fcntl(raw_fd, FcntlArg::F_GETFL).context("fcntl(F_GETFL)")?);
 
 	let new_flags = if blocking {
 		flags & !OFlag::O_NONBLOCK
@@ -21,15 +23,18 @@ pub fn set_blocking(fd: RawFd, blocking: bool) -> Result<()> {
 	};
 
 	if new_flags != flags {
-		fcntl::fcntl(fd, FcntlArg::F_SETFL(new_flags)).context("fcntl(F_SETFL)")?;
+		fcntl::fcntl(raw_fd, FcntlArg::F_SETFL(new_flags)).context("fcntl(F_SETFL)")?;
 	}
 
 	Ok(())
 }
 
-pub fn set_cloexec(fd: RawFd, cloexec: bool) -> Result<()> {
-	let flags =
-		FdFlag::from_bits_retain(fcntl::fcntl(fd, FcntlArg::F_GETFD).context("fcntl(F_GETFD)")?);
+pub fn set_cloexec<Fd: AsFd>(fd: &Fd, cloexec: bool) -> Result<()> {
+	let raw_fd = fd.as_fd().as_raw_fd();
+
+	let flags = FdFlag::from_bits_retain(
+		fcntl::fcntl(raw_fd, FcntlArg::F_GETFD).context("fcntl(F_GETFD)")?,
+	);
 
 	let new_flags = if cloexec {
 		flags | FdFlag::FD_CLOEXEC
@@ -38,7 +43,7 @@ pub fn set_cloexec(fd: RawFd, cloexec: bool) -> Result<()> {
 	};
 
 	if new_flags != flags {
-		fcntl::fcntl(fd, FcntlArg::F_SETFD(new_flags)).context("fcntl(F_SETFD)")?;
+		fcntl::fcntl(raw_fd, FcntlArg::F_SETFD(new_flags)).context("fcntl(F_SETFD)")?;
 	}
 
 	Ok(())
-- 
cgit v1.2.3