From 72e01923c91543e64e1a847cf49de8d94ef9c55b Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 16 Jan 2018 18:43:40 +0100 Subject: [PATCH 01/22] Implement From for Timespec --- src/sys/time.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/sys/time.rs b/src/sys/time.rs index 0d9770456d..59904e19b4 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -59,6 +59,12 @@ const TS_MAX_SECONDS: i64 = ::std::isize::MAX as i64; const TS_MIN_SECONDS: i64 = -TS_MAX_SECONDS; +impl From for TimeSpec { + fn from(time: timespec) -> Self { + TimeSpec(time) + } +} + impl AsRef for TimeSpec { fn as_ref(&self) -> ×pec { &self.0 From f11d041c48e74d8ecc0307e1bf1451531017461f Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 16 Jan 2018 18:43:57 +0100 Subject: [PATCH 02/22] Implement From for Timespec --- src/sys/time.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/sys/time.rs b/src/sys/time.rs index 59904e19b4..d6a6d7ab86 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -1,4 +1,6 @@ use std::{cmp, fmt, ops}; +use std::time::Duration; + use libc::{c_long, time_t, suseconds_t, timespec, timeval}; pub trait TimeValLike: Sized { @@ -58,6 +60,14 @@ const TS_MAX_SECONDS: i64 = ::std::isize::MAX as i64; const TS_MIN_SECONDS: i64 = -TS_MAX_SECONDS; +impl From for TimeSpec { + fn from(duration: Duration) -> Self { + TimeSpec(timespec{ + tv_sec: cmp::min(duration.as_secs(), time_t::max_value() as u64) as time_t, + tv_nsec: c_long::from(duration.subsec_nanos()), + }) + } +} impl From for TimeSpec { fn from(time: timespec) -> Self { @@ -260,8 +270,6 @@ impl fmt::Display for TimeSpec { } } - - #[repr(C)] #[derive(Clone, Copy)] pub struct TimeVal(timeval); From 57058722928468b7771f97bb4b9aa4a0662d08b3 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 16 Jan 2018 18:45:40 +0100 Subject: [PATCH 03/22] Change kevent to use Into Removes kevent_ts. --- src/sys/event.rs | 41 +++++++++++++++++------------------------ 1 file changed, 17 insertions(+), 24 deletions(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index 4d5d18806b..fce2c397bc 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -1,15 +1,18 @@ /* TOOD: Implement for other kqueue based systems */ -use {Errno, Result}; +use std::mem; +use std::os::unix::io::RawFd; +use std::ptr; + #[cfg(not(target_os = "netbsd"))] -use libc::{timespec, time_t, c_int, c_long, intptr_t, uintptr_t}; +use libc::{timespec, c_int, intptr_t, uintptr_t}; #[cfg(target_os = "netbsd")] use libc::{timespec, time_t, c_long, intptr_t, uintptr_t, size_t}; use libc; -use std::os::unix::io::RawFd; -use std::ptr; -use std::mem; + +use {Errno, Result}; +use sys::time::TimeSpec; // Redefine kevent in terms of programmer-friendly enums and bitfields. #[derive(Clone, Copy)] @@ -251,20 +254,6 @@ impl KEvent { } } -pub fn kevent(kq: RawFd, - changelist: &[KEvent], - eventlist: &mut [KEvent], - timeout_ms: usize) -> Result { - - // Convert ms to timespec - let timeout = timespec { - tv_sec: (timeout_ms / 1000) as time_t, - tv_nsec: ((timeout_ms % 1000) * 1_000_000) as c_long - }; - - kevent_ts(kq, changelist, eventlist, Some(timeout)) -} - #[cfg(any(target_os = "macos", target_os = "ios", target_os = "freebsd", @@ -274,10 +263,13 @@ type type_of_nchanges = c_int; #[cfg(target_os = "netbsd")] type type_of_nchanges = size_t; -pub fn kevent_ts(kq: RawFd, - changelist: &[KEvent], - eventlist: &mut [KEvent], - timeout_opt: Option) -> Result { +pub fn kevent>(kq: RawFd, changelist: &[KEvent], eventlist: &mut [KEvent], timeout: Option) -> Result { + let timeout = timeout.map(|t| t.into()); + let timeout_ptr = if let Some(ref timeout) = timeout { + timeout.as_ref() as *const timespec + } else { + ptr::null() + }; let res = unsafe { libc::kevent( @@ -286,7 +278,8 @@ pub fn kevent_ts(kq: RawFd, changelist.len() as type_of_nchanges, eventlist.as_mut_ptr() as *mut libc::kevent, eventlist.len() as type_of_nchanges, - if let Some(ref timeout) = timeout_opt {timeout as *const timespec} else {ptr::null()}) + timeout_ptr, + ) }; Errno::result(res).map(|r| r as usize) From f7d60e9ded0b026476bdfece6f327cb788515bee Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Tue, 16 Jan 2018 18:59:57 +0100 Subject: [PATCH 04/22] Add a simple test for kevent --- test/sys/mod.rs | 8 ++++++++ test/sys/test_event.rs | 19 +++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 test/sys/test_event.rs diff --git a/test/sys/mod.rs b/test/sys/mod.rs index 31cf73b1d9..9ab5966601 100644 --- a/test/sys/mod.rs +++ b/test/sys/mod.rs @@ -22,6 +22,14 @@ mod test_uio; #[cfg(target_os = "linux")] mod test_epoll; + +#[cfg(any(target_os = "dragonfly", + target_os = "freebsd", + target_os = "ios", + target_os = "macos", + target_os = "netbsd", + target_os = "openbsd"))] +mod test_event; mod test_pthread; #[cfg(any(target_os = "android", target_os = "linux"))] diff --git a/test/sys/test_event.rs b/test/sys/test_event.rs new file mode 100644 index 0000000000..c116ce2b97 --- /dev/null +++ b/test/sys/test_event.rs @@ -0,0 +1,19 @@ +use std::time::Duration; + +use libc::timespec; +use nix::sys::event::{kqueue, kevent}; + +#[test] +pub fn test_kevent() { + let kq = kqueue().unwrap(); + + let mut events = Vec::new(); + + let timeout = Duration::from_millis(0); + assert_eq!(kevent(kq, &[], &mut events, Some(timeout)).unwrap(), 0); + + let timeout = timespec { tv_sec: 0, tv_nsec: 0}; + assert_eq!(kevent(kq, &[], &mut events, Some(timeout)).unwrap(), 0); + + assert_eq!(kevent::(kq, &[], &mut events, None).unwrap(), 0); +} From 6564a0b9e8d2d5d109e73aa0b7fbd60fd1cbc339 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:34:55 +0100 Subject: [PATCH 05/22] Add documentation to TimeSpec Including examples about converting `Duration` and `libc::timespec` into `TimeSpec`. --- src/sys/time.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/sys/time.rs b/src/sys/time.rs index d6a6d7ab86..68eb8c202c 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -44,6 +44,22 @@ pub trait TimeValLike: Sized { fn num_nanoseconds(&self) -> i64; } +/// A wrapper around `libc::timespec`. +/// +/// # Examples +/// +/// Both `std::time::Duration` and `libc::timespec` implement `Into`, +/// and can be used in any function accepting `Into`. +/// +/// ``` +/// fn with_timeout>(timeout: T) { +/// # drop(timeout); +/// // Code etc. +/// } +/// +/// with_timeout(Duration::from_millis(100)); +/// with_timeout(timespec { tv_sec: 0, tv_nsec: 1000}); +/// ``` #[repr(C)] #[derive(Clone, Copy)] pub struct TimeSpec(timespec); From f94304951dda703e4ccaa454ee63f00edab7fe80 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:47:22 +0100 Subject: [PATCH 06/22] Change ev_set signature to match KEvent::new Changes the `ident` parameter to use `uintptr_t`, rather then `usize`. --- src/sys/event.rs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index fce2c397bc..f33ff4028f 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -286,13 +286,7 @@ pub fn kevent>(kq: RawFd, changelist: &[KEvent], eventlist: &m } #[inline] -pub fn ev_set(ev: &mut KEvent, - ident: usize, - filter: EventFilter, - flags: EventFlag, - fflags: FilterFlag, - udata: intptr_t) { - +pub fn ev_set(ev: &mut KEvent, ident: uintptr_t, filter: EventFilter, flags: EventFlag, fflags: FilterFlag, udata: intptr_t) { ev.kevent.ident = ident as uintptr_t; ev.kevent.filter = filter as type_of_event_filter; ev.kevent.flags = flags.bits(); From ab366d2845aafe58e5cfe146fde26c29c997f689 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:47:33 +0100 Subject: [PATCH 07/22] Document ev_set --- src/sys/event.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index f33ff4028f..e1465615d8 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -285,6 +285,15 @@ pub fn kevent>(kq: RawFd, changelist: &[KEvent], eventlist: &m Errno::result(res).map(|r| r as usize) } +/// Initialize a kevent structure. +/// +/// This API matches the `EV_SET` macro, a better way to create a `KEvent` is to +/// use [`KEvent.new`]. +/// +/// For more information see [kqueue(2)]. +/// +/// [`KEvent.new`]: struct.KEvent.html +/// [kqueue(2)]: https://www.freebsd.org/cgi/man.cgi?query=kqueue #[inline] pub fn ev_set(ev: &mut KEvent, ident: uintptr_t, filter: EventFilter, flags: EventFlag, fflags: FilterFlag, udata: intptr_t) { ev.kevent.ident = ident as uintptr_t; From 4b0e1abe56d8c841863f8f12c50b14e8a47d871c Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:47:42 +0100 Subject: [PATCH 08/22] Document kqueue --- src/sys/event.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index e1465615d8..ee11408f13 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -203,13 +203,17 @@ libc_bitflags!( } ); +/// The `kqueue` system call creates a new kernel event queue and returns a +/// descriptor. +/// +/// For more information see [kqueue(2)]. +/// +/// [kqueue(2)]: https://www.freebsd.org/cgi/man.cgi?query=kqueue pub fn kqueue() -> Result { let res = unsafe { libc::kqueue() }; - Errno::result(res) } - // KEvent can't derive Send because on some operating systems, udata is defined // as a void*. However, KEvent's public API always treats udata as an intptr_t, // which is safe to Send. From ab1363c00f630087fc8cc05ccc305f16f625ca5d Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:58:11 +0100 Subject: [PATCH 09/22] Document kevent --- src/sys/event.rs | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index ee11408f13..c546fae509 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -267,6 +267,44 @@ type type_of_nchanges = c_int; #[cfg(target_os = "netbsd")] type type_of_nchanges = size_t; +/// The `kevent` system call is used to register events with the queue, and +/// return any pending events to the user. +/// +/// For more information see [kqueue(2)]. +/// +/// [kqueue(2)]: https://www.freebsd.org/cgi/man.cgi?query=kqueue +/// +/// # Examples +/// +/// Using `std::time::Duration`. +/// +/// ``` +/// use std::time::Duration; +/// use nix::sys::event::{kqueue, kevent}; +/// +/// let kq = kqueue().unwrap(); +/// let mut events = Vec::new(); +/// +/// // With a timeout. +/// let timeout = Duration::from_millis(100); +/// kevent(kq, &[], &mut events, Some(timeout)).unwrap(); +/// +/// // Without a timeout. +/// kevent::(kq, &[], &mut events, None).unwrap(); +/// ``` +/// +/// Using `libc::timespec` directly. +/// +/// ``` +/// use nix::libc::timespec; +/// use nix::sys::event::{kqueue, kevent}; +/// +/// let kq = kqueue().unwrap(); +/// let mut events = Vec::new(); +/// +/// let timeout = timespec { tv_sec: 0, tv_nsec: 1000}; +/// assert_eq!(kevent(kq, &[], &mut events, Some(timeout)).unwrap(), 0); +/// ``` pub fn kevent>(kq: RawFd, changelist: &[KEvent], eventlist: &mut [KEvent], timeout: Option) -> Result { let timeout = timeout.map(|t| t.into()); let timeout_ptr = if let Some(ref timeout) = timeout { From b03d0a0b484fed97131002fe420fc6b16d2b8057 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 11:58:29 +0100 Subject: [PATCH 10/22] Remove test_kevent This has moved into the kevent documentation. --- test/sys/mod.rs | 7 ------- test/sys/test_event.rs | 19 ------------------- 2 files changed, 26 deletions(-) delete mode 100644 test/sys/test_event.rs diff --git a/test/sys/mod.rs b/test/sys/mod.rs index 9ab5966601..eff2676497 100644 --- a/test/sys/mod.rs +++ b/test/sys/mod.rs @@ -23,13 +23,6 @@ mod test_uio; #[cfg(target_os = "linux")] mod test_epoll; -#[cfg(any(target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd"))] -mod test_event; mod test_pthread; #[cfg(any(target_os = "android", target_os = "linux"))] diff --git a/test/sys/test_event.rs b/test/sys/test_event.rs deleted file mode 100644 index c116ce2b97..0000000000 --- a/test/sys/test_event.rs +++ /dev/null @@ -1,19 +0,0 @@ -use std::time::Duration; - -use libc::timespec; -use nix::sys::event::{kqueue, kevent}; - -#[test] -pub fn test_kevent() { - let kq = kqueue().unwrap(); - - let mut events = Vec::new(); - - let timeout = Duration::from_millis(0); - assert_eq!(kevent(kq, &[], &mut events, Some(timeout)).unwrap(), 0); - - let timeout = timespec { tv_sec: 0, tv_nsec: 0}; - assert_eq!(kevent(kq, &[], &mut events, Some(timeout)).unwrap(), 0); - - assert_eq!(kevent::(kq, &[], &mut events, None).unwrap(), 0); -} From f85707c8b06079653c3422f67c1b54268dfcacc3 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:10:19 +0100 Subject: [PATCH 11/22] Document FilterFlag --- src/sys/event.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index c546fae509..00d1a79ceb 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -114,6 +114,11 @@ libc_bitflags!{ } libc_bitflags!( + /// Filter-specific flags. + /// + /// See [`KEvent`]. + /// + /// [`KEvent`]: struct.KEvent.html pub struct FilterFlag: u32 { #[cfg(any(target_os = "macos", target_os = "ios"))] NOTE_ABSOLUTE; From b2149501fdf9fd904b7157715ea80e3b5ae1d2ab Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:10:29 +0100 Subject: [PATCH 12/22] Document EventFlag --- src/sys/event.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index 00d1a79ceb..86ddefd49c 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -75,7 +75,13 @@ libc_enum! { pub type type_of_event_flag = u16; #[cfg(any(target_os = "netbsd"))] pub type type_of_event_flag = u32; + libc_bitflags!{ + /// Actions to perform on the event. + /// + /// See [`KEvent`]. + /// + /// [`KEvent`]: struct.KEvent.html pub struct EventFlag: type_of_event_flag { EV_ADD; EV_CLEAR; From 0895e01ae0c2c30313d0ef9e3e02551939f9d43d Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:10:50 +0100 Subject: [PATCH 13/22] Document EventFilter --- src/sys/event.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index 86ddefd49c..e8ed6fbcc5 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -38,6 +38,11 @@ type type_of_event_filter = u32; #[cfg(not(target_os = "netbsd"))] type type_of_event_filter = i16; libc_enum! { + /// Identifies the kernel filter used to process this event. + /// + /// See [`KEvent`]. + /// + /// [`KEvent`]: struct.KEvent.html #[cfg_attr(target_os = "netbsd", repr(u32))] #[cfg_attr(not(target_os = "netbsd"), repr(i16))] pub enum EventFilter { From 9204b8ebfdf89ceffa88cf1cc67f1b0dfaab81a8 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:10:59 +0100 Subject: [PATCH 14/22] Document KEvent --- src/sys/event.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index e8ed6fbcc5..93e9aba688 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -14,7 +14,13 @@ use libc; use {Errno, Result}; use sys::time::TimeSpec; -// Redefine kevent in terms of programmer-friendly enums and bitfields. +/// Wrapper around `libc:kevent`. +/// +/// Redefined `kevent` in terms of programmer-friendly enums and bitfields. See +/// [`new`] to create a new `KEvent` and [`ev_set`] to modify an existing event. +/// +/// [`new`]: #method.new +/// [`ev_set`]: fn.ev_set.html #[derive(Clone, Copy)] #[repr(C)] pub struct KEvent { From 4795e22b155f2cde079b1ee518af34696c7fb67c Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:11:25 +0100 Subject: [PATCH 15/22] Document type_of_event_flag --- src/sys/event.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index 93e9aba688..a958704cde 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -80,6 +80,7 @@ libc_enum! { } } +/// The underlying type of `EventFlag`. #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "ios", target_os = "macos", target_os = "openbsd"))] From 222a7dd1b4ea10c6b35550c4b62d967b1b2e85ec Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:11:43 +0100 Subject: [PATCH 16/22] Document the event module And fixes a type-o in the TODO. --- src/sys/event.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index a958704cde..5db2aaf84c 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -1,4 +1,10 @@ -/* TOOD: Implement for other kqueue based systems +//! Kernel event notification mechanism. +//! +//! For more information see [kqueue(2)]. +//! +//! [kqueue(2)]: https://www.freebsd.org/cgi/man.cgi?query=kqueue + +/* TODO: Implement for other kqueue based systems */ use std::mem; From 5b4f3f65000835cb3d0da04ea094711b38b1946a Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:16:24 +0100 Subject: [PATCH 17/22] Fix TimeSpec example --- src/sys/time.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/sys/time.rs b/src/sys/time.rs index 68eb8c202c..31c8f291de 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -52,6 +52,10 @@ pub trait TimeValLike: Sized { /// and can be used in any function accepting `Into`. /// /// ``` +/// use std::time::Duration; +/// use nix::libc::timespec; +/// use nix::sys::time::TimeSpec; +/// /// fn with_timeout>(timeout: T) { /// # drop(timeout); /// // Code etc. From 6f039dfcc86770a64f793835213d49c9beb261f7 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:16:46 +0100 Subject: [PATCH 18/22] Fix conversion of Duration into TimeSpec --- src/sys/time.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sys/time.rs b/src/sys/time.rs index 31c8f291de..ae83bdf9d8 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -83,7 +83,7 @@ const TS_MIN_SECONDS: i64 = -TS_MAX_SECONDS; impl From for TimeSpec { fn from(duration: Duration) -> Self { TimeSpec(timespec{ - tv_sec: cmp::min(duration.as_secs(), time_t::max_value() as u64) as time_t, + tv_sec: duration.as_secs() as time_t, tv_nsec: c_long::from(duration.subsec_nanos()), }) } From bf9cf68b82e55afb8178aa9df21dfae2172e7ae5 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Wed, 17 Jan 2018 12:19:56 +0100 Subject: [PATCH 19/22] Add changes regarding kevent to changelog --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3eb1cf9d5b..6f98621a55 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -96,6 +96,8 @@ This project adheres to [Semantic Versioning](http://semver.org/). ([#814](https://github.com/nix-rust/nix/pull/814)) - Removed return type from `pause`. ([#829](https://github.com/nix-rust/nix/pull/829)) +- Changed the API of `kevent` to accept `Into`. + ([#838](https://github.com/nix-rust/nix/pull/838)) ### Fixed - Fix compilation and tests for OpenBSD targets @@ -116,6 +118,8 @@ This project adheres to [Semantic Versioning](http://semver.org/). - Removed `MS_VERBOSE`, `MS_NOSEC`, and `MS_BORN` from `MsFlags`. These are internal kernel flags and should never have been exposed. ([#814](https://github.com/nix-rust/nix/pull/814)) +- Removed `kevent_ts`, it was merged with `kevent`. + ([#838](https://github.com/nix-rust/nix/pull/838)) ## [0.9.0] 2017-07-23 From 015231c54c683915e98737eb4b552cbd4d52651c Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Fri, 19 Jan 2018 14:48:13 +0100 Subject: [PATCH 20/22] Fix build errors on 32bit architectures MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit c_long on 32 bit is `i32`, which doesn’t implement `From`. --- src/sys/time.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sys/time.rs b/src/sys/time.rs index ae83bdf9d8..73f6b06a5f 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -84,7 +84,7 @@ impl From for TimeSpec { fn from(duration: Duration) -> Self { TimeSpec(timespec{ tv_sec: duration.as_secs() as time_t, - tv_nsec: c_long::from(duration.subsec_nanos()), + tv_nsec: duration.subsec_nanos() as c_long, }) } } From ea5551469741c900ad8c72a78aa9c9fcb4011cac Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Fri, 19 Jan 2018 14:49:05 +0100 Subject: [PATCH 21/22] Remove ev_set MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This doesn’t really make sense as a Rust API. --- src/sys/event.rs | 22 +--------------------- 1 file changed, 1 insertion(+), 21 deletions(-) diff --git a/src/sys/event.rs b/src/sys/event.rs index 5db2aaf84c..fe19232cd4 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -23,10 +23,9 @@ use sys::time::TimeSpec; /// Wrapper around `libc:kevent`. /// /// Redefined `kevent` in terms of programmer-friendly enums and bitfields. See -/// [`new`] to create a new `KEvent` and [`ev_set`] to modify an existing event. +/// [`new`] to create a new `KEvent`. /// /// [`new`]: #method.new -/// [`ev_set`]: fn.ev_set.html #[derive(Clone, Copy)] #[repr(C)] pub struct KEvent { @@ -356,25 +355,6 @@ pub fn kevent>(kq: RawFd, changelist: &[KEvent], eventlist: &m Errno::result(res).map(|r| r as usize) } -/// Initialize a kevent structure. -/// -/// This API matches the `EV_SET` macro, a better way to create a `KEvent` is to -/// use [`KEvent.new`]. -/// -/// For more information see [kqueue(2)]. -/// -/// [`KEvent.new`]: struct.KEvent.html -/// [kqueue(2)]: https://www.freebsd.org/cgi/man.cgi?query=kqueue -#[inline] -pub fn ev_set(ev: &mut KEvent, ident: uintptr_t, filter: EventFilter, flags: EventFlag, fflags: FilterFlag, udata: intptr_t) { - ev.kevent.ident = ident as uintptr_t; - ev.kevent.filter = filter as type_of_event_filter; - ev.kevent.flags = flags.bits(); - ev.kevent.fflags = fflags.bits(); - ev.kevent.data = 0; - ev.kevent.udata = udata as type_of_udata; -} - #[test] fn test_struct_kevent() { let udata : intptr_t = 12345; From ecc992466eed15e111e94cd2110d1f04deb41b56 Mon Sep 17 00:00:00 2001 From: Thomas de Zeeuw Date: Fri, 19 Jan 2018 14:49:24 +0100 Subject: [PATCH 22/22] Document all methods on KEvent --- src/sys/event.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/sys/event.rs b/src/sys/event.rs index fe19232cd4..dde46ba745 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -249,6 +249,7 @@ unsafe impl Send for KEvent { } impl KEvent { + /// Create a new `KEvent`. pub fn new(ident: uintptr_t, filter: EventFilter, flags: EventFlag, fflags:FilterFlag, data: intptr_t, udata: intptr_t) -> KEvent { KEvent { kevent: libc::kevent { @@ -261,26 +262,32 @@ impl KEvent { } } } + /// Get the identifier for this event. pub fn ident(&self) -> uintptr_t { self.kevent.ident } + /// Get the kernal filter for this event. pub fn filter(&self) -> EventFilter { unsafe { mem::transmute(self.kevent.filter as type_of_event_filter) } } + /// Get the action to performan for this event. pub fn flags(&self) -> EventFlag { EventFlag::from_bits(self.kevent.flags).unwrap() } + /// Get the filter flags. pub fn fflags(&self) -> FilterFlag { FilterFlag::from_bits(self.kevent.fflags).unwrap() } + /// Get the filter data. pub fn data(&self) -> intptr_t { self.kevent.data as intptr_t } + /// Get the user data indentifier. pub fn udata(&self) -> intptr_t { self.kevent.udata as intptr_t }