From 9797e0c9f4288a3b7652c5fe6532f7379dfb9b8c Mon Sep 17 00:00:00 2001 From: Alan Somers Date: Sat, 10 Dec 2022 11:46:04 -0700 Subject: Deprecate the signalfd function. The SignalFd type is just as capable and easier to use. --- src/sys/signalfd.rs | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'src/sys') diff --git a/src/sys/signalfd.rs b/src/sys/signalfd.rs index a53c8611..2b80ea64 100644 --- a/src/sys/signalfd.rs +++ b/src/sys/signalfd.rs @@ -44,7 +44,12 @@ pub const SIGNALFD_SIGINFO_SIZE: usize = mem::size_of::(); /// signalfd (the default handler will be invoked instead). /// /// See [the signalfd man page for more information](https://man7.org/linux/man-pages/man2/signalfd.2.html) +#[deprecated(since = "0.27.0", note = "Use SignalFd instead")] pub fn signalfd(fd: Option, mask: &SigSet, flags: SfdFlags) -> Result { + _signalfd(fd, mask, flags) +} + +fn _signalfd(fd: Option, mask: &SigSet, flags: SfdFlags) -> Result { let raw_fd = fd.map_or(-1, |x|x.as_fd().as_raw_fd()); unsafe { Errno::result(libc::signalfd( @@ -90,13 +95,13 @@ impl SignalFd { } pub fn with_flags(mask: &SigSet, flags: SfdFlags) -> Result { - let fd = signalfd(None::, mask, flags)?; + let fd = _signalfd(None::, mask, flags)?; Ok(SignalFd(fd)) } pub fn set_mask(&mut self, mask: &SigSet) -> Result<()> { - signalfd(Some(self.0.as_fd()), mask, SfdFlags::empty()).map(drop) + _signalfd(Some(self.0.as_fd()), mask, SfdFlags::empty()).map(drop) } pub fn read_signal(&mut self) -> Result> { -- cgit v1.2.3 From 27d1844952386a52f190935f8fde1cc967f1e01f Mon Sep 17 00:00:00 2001 From: Steve Lau Date: Sun, 11 Dec 2022 12:19:58 +0800 Subject: feat: I/O safety for 'sys/memfd' & 'sys/event' & 'sys/eventfd' --- src/sys/epoll.rs | 2 +- src/sys/event.rs | 16 ++++++++-------- src/sys/eventfd.rs | 6 +++--- src/sys/memfd.rs | 6 +++--- 4 files changed, 15 insertions(+), 15 deletions(-) (limited to 'src/sys') diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs index 9fdb1495..36f9c17d 100644 --- a/src/sys/epoll.rs +++ b/src/sys/epoll.rs @@ -83,7 +83,7 @@ impl EpollEvent { /// let epoll = Epoll::new(EpollCreateFlags::empty())?; /// /// // Create eventfd & Add event -/// let eventfd = unsafe { OwnedFd::from_raw_fd(eventfd(0, EfdFlags::empty())?) }; +/// let eventfd = eventfd(0, EfdFlags::empty())?; /// epoll.add(&eventfd, EpollEvent::new(EpollFlags::EPOLLIN,DATA))?; /// /// // Arm eventfd & Time wait diff --git a/src/sys/event.rs b/src/sys/event.rs index d8ad628e..f21ba173 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -8,7 +8,7 @@ use libc::{c_int, c_long, intptr_t, time_t, timespec, uintptr_t}; use libc::{c_long, intptr_t, size_t, time_t, timespec, uintptr_t}; use std::convert::TryInto; use std::mem; -use std::os::unix::io::RawFd; +use std::os::unix::io::{AsFd, AsRawFd, FromRawFd, OwnedFd}; use std::ptr; // Redefine kevent in terms of programmer-friendly enums and bitfields. @@ -207,10 +207,10 @@ libc_bitflags!( } ); -pub fn kqueue() -> Result { +pub fn kqueue() -> Result { let res = unsafe { libc::kqueue() }; - Errno::result(res) + Errno::result(res).map(|fd| unsafe { OwnedFd::from_raw_fd(fd) }) } // KEvent can't derive Send because on some operating systems, udata is defined @@ -267,8 +267,8 @@ impl KEvent { } } -pub fn kevent( - kq: RawFd, +pub fn kevent( + kq: Fd, changelist: &[KEvent], eventlist: &mut [KEvent], timeout_ms: usize, @@ -293,15 +293,15 @@ type type_of_nchanges = c_int; #[cfg(target_os = "netbsd")] type type_of_nchanges = size_t; -pub fn kevent_ts( - kq: RawFd, +pub fn kevent_ts( + kq: Fd, changelist: &[KEvent], eventlist: &mut [KEvent], timeout_opt: Option, ) -> Result { let res = unsafe { libc::kevent( - kq, + kq.as_fd().as_raw_fd(), changelist.as_ptr() as *const libc::kevent, changelist.len() as type_of_nchanges, eventlist.as_mut_ptr() as *mut libc::kevent, diff --git a/src/sys/eventfd.rs b/src/sys/eventfd.rs index cd906720..f1723519 100644 --- a/src/sys/eventfd.rs +++ b/src/sys/eventfd.rs @@ -1,6 +1,6 @@ use crate::errno::Errno; use crate::Result; -use std::os::unix::io::RawFd; +use std::os::unix::io::{FromRawFd, OwnedFd}; libc_bitflags! { pub struct EfdFlags: libc::c_int { @@ -10,8 +10,8 @@ libc_bitflags! { } } -pub fn eventfd(initval: libc::c_uint, flags: EfdFlags) -> Result { +pub fn eventfd(initval: libc::c_uint, flags: EfdFlags) -> Result { let res = unsafe { libc::eventfd(initval, flags.bits()) }; - Errno::result(res).map(|r| r as RawFd) + Errno::result(res).map(|r| unsafe { OwnedFd::from_raw_fd(r) }) } diff --git a/src/sys/memfd.rs b/src/sys/memfd.rs index ad9345e8..f349a743 100644 --- a/src/sys/memfd.rs +++ b/src/sys/memfd.rs @@ -1,7 +1,7 @@ //! Interfaces for managing memory-backed files. use cfg_if::cfg_if; -use std::os::unix::io::RawFd; +use std::os::unix::io::{FromRawFd, OwnedFd, RawFd}; use crate::errno::Errno; use crate::Result; @@ -40,7 +40,7 @@ libc_bitflags!( /// For more information, see [`memfd_create(2)`]. /// /// [`memfd_create(2)`]: https://man7.org/linux/man-pages/man2/memfd_create.2.html -pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result { +pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result { let res = unsafe { cfg_if! { if #[cfg(all( @@ -60,5 +60,5 @@ pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result { } }; - Errno::result(res).map(|r| r as RawFd) + Errno::result(res).map(|r| unsafe { OwnedFd::from_raw_fd(r as RawFd) }) } -- cgit v1.2.3