Snap for 10447354 from 7d7d6b1b864f59139bad9bed64193786e1367bfe to mainline-wifi-releaseaml_wif_341610000aml_wif_341510000aml_wif_341410080aml_wif_341310010aml_wif_341110010aml_wif_341011010aml_wif_340913010android14-mainline-wifi-release

Change-Id: I31efdfb3a3e819921f34fe74ef54aaf4065bd667

110 files changed, 16385 insertions, 7371 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 90eb8fa..b9cb2ab 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "afba7c5a33dd4fd62b047e64089487cf822ccec2"
+    "sha1": "1e3f062fd842b7ce130ea6c792a8eab7f78f82e3"
   },
   "path_in_vcs": ""
 }
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index 88940a1..f44d482 100644
--- a/Android.bp
+++ b/Android.bp
@@ -26,21 +26,61 @@ rust_library {
     host_supported: true,
     crate_name: "nix",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.23.1",
+    cargo_pkg_version: "0.26.2",
     srcs: ["src/lib.rs"],
     edition: "2018",
+    features: [
+        "acct",
+        "aio",
+        "default",
+        "dir",
+        "env",
+        "event",
+        "feature",
+        "fs",
+        "hostname",
+        "inotify",
+        "ioctl",
+        "kmod",
+        "memoffset",
+        "mman",
+        "mount",
+        "mqueue",
+        "net",
+        "personality",
+        "pin-utils",
+        "poll",
+        "process",
+        "pthread",
+        "ptrace",
+        "quota",
+        "reboot",
+        "resource",
+        "sched",
+        "signal",
+        "socket",
+        "term",
+        "time",
+        "ucontext",
+        "uio",
+        "user",
+        "zerocopy",
+    ],
     rustlibs: [
-        "libbitflags",
+        "libbitflags-1.3.2",
         "libcfg_if",
         "liblibc",
         "libmemoffset",
+        "libpin_utils",
+        "libstatic_assertions",
     ],
     apex_available: [
         "//apex_available:platform",
-        "com.android.bluetooth",
+        "com.android.btservices",
         "com.android.compos",
         "com.android.virt",
     ],
+    product_available: true,
     vendor_available: true,
     min_sdk_version: "29",
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 77d5b2a..283cb86 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,9 +3,276 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
-## [0.23.1] - 2021-12-16
+## [0.26.2] - 2023-01-18
+### Fixed
+- Fix `SockaddrIn6` bug that was swapping flowinfo and scope_id byte ordering.
+  ([#1964](https://github.com/nix-rust/nix/pull/1964))
+
+## [0.26.1] - 2022-11-29
+### Fixed
+- Fix UB with `sys::socket::sockopt::SockType` using `SOCK_PACKET`.
+  ([#1821](https://github.com/nix-rust/nix/pull/1821))
+
+## [0.26.0] - 2022-11-29
+### Added
+
+- Added `SockaddrStorage::{as_unix_addr, as_unix_addr_mut}`
+  ([#1871](https://github.com/nix-rust/nix/pull/1871))
+- Added `MntFlags` and `unmount` on all of the BSDs.
+- Added `any()` and `all()` to `poll::PollFd`.
+  ([#1877](https://github.com/nix-rust/nix/pull/1877))
+- Add `MntFlags` and `unmount` on all of the BSDs.
+  ([#1849](https://github.com/nix-rust/nix/pull/1849))
+- Added a `Statfs::flags` method.
+  ([#1849](https://github.com/nix-rust/nix/pull/1849))
+- Added `NSFS_MAGIC` FsType on Linux and Android.
+  ([#1829](https://github.com/nix-rust/nix/pull/1829))
+- Added `sched_getcpu` on platforms that support it.
+  ([#1825](https://github.com/nix-rust/nix/pull/1825))
+- Added `sched_getaffinity` and `sched_setaffinity` on FreeBSD.
+  ([#1804](https://github.com/nix-rust/nix/pull/1804))
+- Added `line_discipline` field to `Termios` on Linux, Android and Haiku
+  ([#1805](https://github.com/nix-rust/nix/pull/1805))
+- Expose the memfd module on FreeBSD (memfd was added in FreeBSD 13)
+  ([#1808](https://github.com/nix-rust/nix/pull/1808))
+- Added `domainname` field of `UtsName` on Android and Linux
+  ([#1817](https://github.com/nix-rust/nix/pull/1817))
+- Re-export `RLIM_INFINITY` from `libc`
+  ([#1831](https://github.com/nix-rust/nix/pull/1831))
+- Added `syncfs(2)` on Linux
+  ([#1833](https://github.com/nix-rust/nix/pull/1833))
+- Added `faccessat(2)` on illumos
+  ([#1841](https://github.com/nix-rust/nix/pull/1841))
+- Added `eaccess()` on FreeBSD, DragonFly and Linux (glibc and musl).
+  ([#1842](https://github.com/nix-rust/nix/pull/1842))
+- Added `IP_TOS` `SO_PRIORITY` and `IPV6_TCLASS` sockopts for Linux
+  ([#1853](https://github.com/nix-rust/nix/pull/1853))
+- Added `new_unnamed` and `is_unnamed` for `UnixAddr` on Linux and Android.
+  ([#1857](https://github.com/nix-rust/nix/pull/1857))
+- Added `SockProtocol::Raw` for raw sockets
+  ([#1848](https://github.com/nix-rust/nix/pull/1848))
+- added `IP_MTU` (`IpMtu`) `IPPROTO_IP` sockopt on Linux and Android.
+  ([#1865](https://github.com/nix-rust/nix/pull/1865))
+
+### Changed
 
+- The MSRV is now 1.56.1
+  ([#1792](https://github.com/nix-rust/nix/pull/1792))
+- The `addr` argument of `sys::mman::mmap` is now of type `Option<NonZeroUsize>`.
+  ([#1870](https://github.com/nix-rust/nix/pull/1870))
+- The `length` argument of `sys::mman::mmap` is now of type `NonZeroUsize`.
+  ([#1873](https://github.com/nix-rust/nix/pull/1873))
+
+### Fixed
+
+- Fixed using `SockaddrStorage` to store a Unix-domain socket address on Linux.
+  ([#1871](https://github.com/nix-rust/nix/pull/1871))
+- Fix microsecond calculation for `TimeSpec`.
+  ([#1801](https://github.com/nix-rust/nix/pull/1801))
+- Fix `User::from_name` and `Group::from_name` panicking
+  when given a name containing a nul.
+  ([#1815](https://github.com/nix-rust/nix/pull/1815))
+- Fix `User::from_uid` and `User::from_name` crash on Android platform.
+  ([#1824](https://github.com/nix-rust/nix/pull/1824))
+- Workaround XNU bug causing netmasks returned by `getifaddrs` to misbehave.
+  ([#1788](https://github.com/nix-rust/nix/pull/1788))
+  
+### Removed
+
+- Removed deprecated error constants and conversions.
+  ([#1860](https://github.com/nix-rust/nix/pull/1860))
+
+## [0.25.0] - 2022-08-13
 ### Added
+
+- Added `faccessat`
+  ([#1780](https://github.com/nix-rust/nix/pull/1780))
+- Added `memfd` on Android.
+  (#[1773](https://github.com/nix-rust/nix/pull/1773))
+- Added `ETH_P_ALL` to `SockProtocol` enum
+  (#[1768](https://github.com/nix-rust/nix/pull/1768))
+- Added four non-standard Linux `SysconfVar` variants
+  (#[1761](https://github.com/nix-rust/nix/pull/1761))
+- Added const constructors for `TimeSpec` and `TimeVal`
+  (#[1760](https://github.com/nix-rust/nix/pull/1760))
+- Added `chflags`.
+  (#[1758](https://github.com/nix-rust/nix/pull/1758))
+- Added `aio_writev` and `aio_readv`.
+  (#[1713](https://github.com/nix-rust/nix/pull/1713))
+- impl `From<uid_t>` for `Uid` and `From<gid_t>` for `Gid`
+  (#[1727](https://github.com/nix-rust/nix/pull/1727))
+- impl `From<SockaddrIn>` for `std::net::SocketAddrV4` and
+  impl `From<SockaddrIn6>` for `std::net::SocketAddrV6`.
+  (#[1711](https://github.com/nix-rust/nix/pull/1711))
+- Added support for the `x86_64-unknown-haiku` target.
+  (#[1703](https://github.com/nix-rust/nix/pull/1703))
+- Added `ptrace::read_user` and `ptrace::write_user` for Linux.
+  (#[1697](https://github.com/nix-rust/nix/pull/1697))
+- Added `getrusage` and helper types `UsageWho` and `Usage`
+  (#[1747](https://github.com/nix-rust/nix/pull/1747))
+- Added the `DontRoute` SockOpt
+  (#[1752](https://github.com/nix-rust/nix/pull/1752))
+- Added `signal::SigSet::from_sigset_t_unchecked()`.
+  (#[1741](https://github.com/nix-rust/nix/pull/1741))
+- Added the `Ipv4OrigDstAddr` sockopt and control message.
+  (#[1772](https://github.com/nix-rust/nix/pull/1772))
+- Added the `Ipv6OrigDstAddr` sockopt and control message.
+  (#[1772](https://github.com/nix-rust/nix/pull/1772))
+- Added the `Ipv4SendSrcAddr` control message.
+  (#[1776](https://github.com/nix-rust/nix/pull/1776))
+
+### Changed
+
+- Reimplemented sendmmsg/recvmmsg to avoid allocations and with better API
+  (#[1744](https://github.com/nix-rust/nix/pull/1744))
+
+- Rewrote the aio module.  The new module:
+  * Does more type checking at compile time rather than runtime.
+  * Gives the caller control over whether and when to `Box` an aio operation.
+  * Changes the type of the `priority` arguments to `i32`.
+  * Changes the return type of `aio_return` to `usize`.
+  (#[1713](https://github.com/nix-rust/nix/pull/1713))
+- `nix::poll::ppoll`: `sigmask` parameter is now optional.
+  (#[1739](https://github.com/nix-rust/nix/pull/1739))
+- Changed `gethostname` to return an owned `OsString`.
+  (#[1745](https://github.com/nix-rust/nix/pull/1745))
+- `signal:SigSet` is now marked as `repr(transparent)`.
+  (#[1741](https://github.com/nix-rust/nix/pull/1741))
+
+### Removed
+
+- Removed support for resubmitting partially complete `lio_listio` operations.
+  It was too complicated, and didn't fit Nix's theme of zero-cost abstractions.
+  Instead, it can be reimplemented downstream.
+  (#[1713](https://github.com/nix-rust/nix/pull/1713))
+
+## [0.24.2] - 2022-07-17
+### Fixed
+
+- Fixed buffer overflow in `nix::sys::socket::recvfrom`.
+  (#[1763](https://github.com/nix-rust/nix/pull/1763))
+- Enabled `SockaddrStorage::{as_link_addr, as_link_addr_mut}` for Linux-like
+  operating systems.
+  (#[1729](https://github.com/nix-rust/nix/pull/1729))
+- Fixed `SockaddrLike::from_raw` implementations for `VsockAddr` and
+  `SysControlAddr`.
+  (#[1736](https://github.com/nix-rust/nix/pull/1736))
+
+## [0.24.1] - 2022-04-22
+### Fixed
+
+- Fixed `UnixAddr::size` on Linux-based OSes.
+  (#[1702](https://github.com/nix-rust/nix/pull/1702))
+
+## [0.24.0] - 2022-04-21
+### Added
+
+- Added fine-grained features flags.  Most Nix functionality can now be
+  conditionally enabled.  By default, all features are enabled.
+  (#[1611](https://github.com/nix-rust/nix/pull/1611))
+- Added statfs FS type magic constants for `target_os = "android"`
+  and synced constants with libc v0.2.121.
+  (#[1690](https://github.com/nix-rust/nix/pull/1690))
+- Added `fexecve` on DragonFly.
+  (#[1577](https://github.com/nix-rust/nix/pull/1577))
+- `sys::uio::IoVec` is now `Send` and `Sync`
+  (#[1582](https://github.com/nix-rust/nix/pull/1582))
+- Added `EPOLLEXCLUSIVE` on Android.
+  (#[1567](https://github.com/nix-rust/nix/pull/1567))
+- Added `fdatasync` for FreeBSD, Fuchsia, NetBSD, and OpenBSD.
+  (#[1581](https://github.com/nix-rust/nix/pull/1581))
+- Added `sched_setaffinity` and `sched_getaffinity` on DragonFly.
+  (#[1537](https://github.com/nix-rust/nix/pull/1537))
+- Added `posix_fallocate` on DragonFly.
+  (#[1621](https://github.com/nix-rust/nix/pull/1621))
+- Added `SO_TIMESTAMPING` support
+  (#[1547](https://github.com/nix-rust/nix/pull/1547))
+- Added getter methods to `MqAttr` struct
+  (#[1619](https://github.com/nix-rust/nix/pull/1619))
+- Added the `TxTime` sockopt and control message.
+  (#[1564](https://github.com/nix-rust/nix/pull/1564))
+- Added POSIX per-process timer support
+  (#[1622](https://github.com/nix-rust/nix/pull/1622))
+- Added `sendfile` on DragonFly.
+  (#[1615](https://github.com/nix-rust/nix/pull/1615))
+- Added `UMOUNT_NOFOLLOW`, `FUSE_SUPER_MAGIC` on Linux.
+  (#[1634](https://github.com/nix-rust/nix/pull/1634))
+- Added `getresuid`, `setresuid`, `getresgid`, and `setresgid` on DragonFly, FreeBSD, and OpenBSD.
+  (#[1628](https://github.com/nix-rust/nix/pull/1628))
+- Added `MAP_FIXED_NOREPLACE` on Linux.
+  (#[1636](https://github.com/nix-rust/nix/pull/1636))
+- Added `fspacectl` on FreeBSD
+  (#[1640](https://github.com/nix-rust/nix/pull/1640))
+- Added `accept4` on DragonFly, Emscripten, Fuchsia, Illumos, and NetBSD.
+  (#[1654](https://github.com/nix-rust/nix/pull/1654))
+- Added `AsRawFd` implementation on `OwningIter`.
+  (#[1563](https://github.com/nix-rust/nix/pull/1563))
+- Added `process_vm_readv` and `process_vm_writev` on Android.
+  (#[1557](https://github.com/nix-rust/nix/pull/1557))
+- Added `nix::uncontext` module on s390x.
+  (#[1662](https://github.com/nix-rust/nix/pull/1662))
+- Implemented `Extend`, `FromIterator`, and `IntoIterator` for `SigSet` and
+  added `SigSet::iter` and `SigSetIter`.
+  (#[1553](https://github.com/nix-rust/nix/pull/1553))
+- Added `ENOTRECOVERABLE` and `EOWNERDEAD` error codes on DragonFly.
+  (#[1665](https://github.com/nix-rust/nix/pull/1665))
+- Implemented `Read` and `Write` for `&PtyMaster`
+  (#[1664](https://github.com/nix-rust/nix/pull/1664))
+- Added `MSG_NOSIGNAL` for Android, Dragonfly, FreeBSD, Fuchsia, Haiku, Illumos, Linux, NetBSD, OpenBSD and Solaris.
+  (#[1670](https://github.com/nix-rust/nix/pull/1670))
+- Added `waitid`.
+  (#[1584](https://github.com/nix-rust/nix/pull/1584))
+- Added `Ipv6DontFrag` for android, iOS, linux and macOS.
+- Added `IpDontFrag` for iOS, macOS.
+  (#[1692](https://github.com/nix-rust/nix/pull/1692))
+
+### Changed
+
+- `mqueue` functions now operate on a distinct type, `nix::mqueue::MqdT`.
+  Accessors take this type by reference, not by value.
+  (#[1639](https://github.com/nix-rust/nix/pull/1639))
+- Removed `SigSet::extend` in favor of `<SigSet as Extend<Signal>>::extend`.
+  Because of this change, you now need `use std::iter::Extend` to call `extend`
+  on a `SigSet`.
+  (#[1553](https://github.com/nix-rust/nix/pull/1553))
+- Removed the the `PATH_MAX` restriction from APIs accepting paths. Paths
+  will now be allocated on the heap if they are too long. In addition, large
+  instruction count improvements (~30x) were made to path handling.
+  (#[1656](https://github.com/nix-rust/nix/pull/1656))
+- Changed `getrlimit` and `setrlimit` to use `rlim_t` directly
+  instead of `Option<rlim_t>`.
+  (#[1668](https://github.com/nix-rust/nix/pull/1668))
+- Deprecated `InetAddr` and `SockAddr` in favor of `SockaddrIn`, `SockaddrIn6`,
+  and `SockaddrStorage`.
+  (#[1684](https://github.com/nix-rust/nix/pull/1684))
+- Deprecated `IpAddr`, `Ipv4Addr`, and `Ipv6Addr` in favor of their equivalents
+  from the standard library.
+  (#[1685](https://github.com/nix-rust/nix/pull/1685))
+- `uname` now returns a `Result<UtsName>` instead of just a `UtsName` and
+  ignoring failures from libc.  And getters on the `UtsName` struct now return
+  an `&OsStr` instead of `&str`.
+  (#[1672](https://github.com/nix-rust/nix/pull/1672))
+- Replaced `IoVec` with `IoSlice` and `IoSliceMut`, and replaced `IoVec::from_slice` with
+  `IoSlice::new`. (#[1643](https://github.com/nix-rust/nix/pull/1643))
+
+### Fixed
+
+- `InetAddr::from_std` now sets the `sin_len`/`sin6_len` fields on the BSDs.
+  (#[1642](https://github.com/nix-rust/nix/pull/1642))
+- Fixed a panic in `LinkAddr::addr`.  That function now returns an `Option`.
+  (#[1675](https://github.com/nix-rust/nix/pull/1675))
+  (#[1677](https://github.com/nix-rust/nix/pull/1677))
+
+### Removed
+
+- Removed public access to the inner fields of `NetlinkAddr`, `AlgAddr`,
+  `SysControlAddr`, `LinkAddr`, and `VsockAddr`.
+  (#[1614](https://github.com/nix-rust/nix/pull/1614))
+- Removed `EventFlag::EV_SYSFLAG`.
+  (#[1635](https://github.com/nix-rust/nix/pull/1635))
+
+## [0.23.1] - 2021-12-16
+
 ### Changed
 
 - Relaxed the bitflags requirement from 1.3.1 to 1.1.  This partially reverts
@@ -20,8 +287,6 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   `0..FD_SETSIZE`.
   (#[1575](https://github.com/nix-rust/nix/pull/1575))
 
-### Removed
-
 ## [0.23.0] - 2021-09-28
 ### Added
 
@@ -130,6 +395,30 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Removed `SigevNotify` on OpenBSD and Redox.
   (#[1511](https://github.com/nix-rust/nix/pull/1511))
 
+## [0.22.3] - 22 January 2022
+### Changed
+- Relaxed the bitflags requirement from 1.3.1 to 1.1.  This partially reverts
+  #1492.  From now on, the MSRV is not guaranteed to work with all versions of
+  all dependencies, just with some version of all dependencies.
+  (#[1607](https://github.com/nix-rust/nix/pull/1607))
+
+## [0.22.2] - 28 September 2021
+### Fixed
+- Fixed buffer overflow in `unistd::getgrouplist`.
+  (#[1545](https://github.com/nix-rust/nix/pull/1545))
+- Added more errno definitions for better backwards compatibility with
+  Nix 0.21.0.
+  (#[1467](https://github.com/nix-rust/nix/pull/1467))
+
+## [0.22.1] - 13 August 2021
+### Fixed
+- Locked bitflags to < 1.3.0 to fix the build with rust < 1.46.0.
+
+### Removed
+- Removed a couple of termios constants on redox that were never actually
+  supported.
+  (#[1483](https://github.com/nix-rust/nix/pull/1483))
+
 ## [0.22.0] - 9 July 2021
 ### Added
 - Added `if_nameindex` (#[1445](https://github.com/nix-rust/nix/pull/1445))
@@ -155,8 +444,19 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   `nix::Error::EINVAL`.
   ([#1446](https://github.com/nix-rust/nix/pull/1446))
 
+## [0.21.2] - 29 September 2021
+### Fixed
+- Fixed buffer overflow in `unistd::getgrouplist`.
+  (#[1545](https://github.com/nix-rust/nix/pull/1545))
+
+## [0.21.1] - 13 August 2021
 ### Fixed
+- Locked bitflags to < 1.3.0 to fix the build with rust < 1.46.0.
+
 ### Removed
+- Removed a couple of termios constants on redox that were never actually
+  supported.
+  (#[1483](https://github.com/nix-rust/nix/pull/1483))
 
 ## [0.21.0] - 31 May 2021
 ### Added
@@ -212,6 +512,20 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Removed some Errno values from platforms where they aren't actually defined.
   (#[1452](https://github.com/nix-rust/nix/pull/1452))
 
+## [0.20.2] - 28 September 2021
+### Fixed
+- Fixed buffer overflow in `unistd::getgrouplist`.
+  (#[1545](https://github.com/nix-rust/nix/pull/1545))
+
+## [0.20.1] - 13 August 2021
+### Fixed
+- Locked bitflags to < 1.3.0 to fix the build with rust < 1.46.0.
+
+### Removed
+- Removed a couple of termios constants on redox that were never actually
+  supported.
+  (#[1483](https://github.com/nix-rust/nix/pull/1483))
+
 ## [0.20.0] - 20 February 2021
 ### Added
 
@@ -275,8 +589,6 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   (#[1278](https://github.com/nix-rust/nix/pull/1278))
 - Made `unistd::fork` an unsafe funtion, bringing it in line with [libstd's decision](https://github.com/rust-lang/rust/pull/58059).
   (#[1293](https://github.com/nix-rust/nix/pull/1293))
-### Fixed
-### Removed
 
 ## [0.18.0] - 26 July 2020
 ### Added
@@ -389,22 +701,16 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 ### Added
 - Add `CLK_TCK` to `SysconfVar`
   (#[1177](https://github.com/nix-rust/nix/pull/1177))
-### Changed
-### Fixed
 ### Removed
 - Removed deprecated Error::description from error types
   (#[1175](https://github.com/nix-rust/nix/pull/1175))
 
 ## [0.16.1] - 23 December 2019
-### Added
-### Changed
 ### Fixed
 
 - Fixed the build for OpenBSD
   (#[1168](https://github.com/nix-rust/nix/pull/1168))
 
-### Removed
-
 ## [0.16.0] - 1 December 2019
 ### Added
 - Added `ptrace::seize()`: similar to `attach()` on Linux
@@ -532,8 +838,6 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Enabled `sched_yield` for all nix hosts.
   ([#1090](https://github.com/nix-rust/nix/pull/1090))
 
-### Removed
-
 ## [0.14.1] - 2019-06-06
 ### Added
 - Macros exported by `nix` may now be imported via `use` on the Rust 2018
@@ -558,8 +862,6 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Fix the build on Android and Linux/mips with recent versions of libc.
   ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
 
-### Removed
-
 ## [0.14.0] - 2019-05-21
 ### Added
 - Add IP_RECVIF & IP_RECVDSTADDR. Enable IP_PKTINFO and IP6_PKTINFO on netbsd/openbsd.
@@ -628,6 +930,23 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   should've been defined in the first place.
   ([#1055](https://github.com/nix-rust/nix/pull/1055))
 
+## [0.13.1] - 2019-06-10
+### Changed
+- Changed some public types from reexports of libc types like `uint32_t` to the
+  native equivalents like `u32.`
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+
+### Fixed
+- Fix the build on Android and Linux/mips with recent versions of libc.
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+- Fixed build on Linux/arm and Linux/s390x with the latest Rust libc
+  ([52102cb](https://github.com/nix-rust/nix/commit/52102cb76398c4dfb9ea141b98c5b01a2e050973))
+
+### Removed
+- `Daemon`, `NOTE_REAP`, and `NOTE_EXIT_REPARENTED` are now deprecated on OSX
+  and iOS.
+  ([#1033](https://github.com/nix-rust/nix/pull/1033))
+
 ## [0.13.0] - 2019-01-15
 ### Added
 - Added PKTINFO(V4) & V6PKTINFO cmsg support - Android/FreeBSD/iOS/Linux/MacOS.
@@ -645,14 +964,30 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Added an `mprotect` wrapper.
   ([#991](https://github.com/nix-rust/nix/pull/991))
 
-### Changed
 ### Fixed
 - `lutimes` never worked on OpenBSD as it is not implemented on OpenBSD. It has
   been removed. ([#1000](https://github.com/nix-rust/nix/pull/1000))
 - `fexecve` never worked on NetBSD or on OpenBSD as it is not implemented on
   either OS. It has been removed. ([#1000](https://github.com/nix-rust/nix/pull/1000))
 
+## [0.12.1] 2019-06-08
+### Changed
+- Changed some public types from reexports of libc types like `uint32_t` to the
+  native equivalents like `u32.`
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+
+### Fixed
+- Fix the build on Android and Linux/mips with recent versions of libc.
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+- Fixed build on Linux/arm and Linux/s390x with the latest Rust libc
+  ([52102cb](https://github.com/nix-rust/nix/commit/52102cb76398c4dfb9ea141b98c5b01a2e050973))
+
 ### Removed
+- `fexecve` never worked on NetBSD or on OpenBSD as it is not implemented on
+  either OS. It has been removed. ([#1000](https://github.com/nix-rust/nix/pull/1000))
+- `Daemon`, `NOTE_REAP`, and `NOTE_EXIT_REPARENTED` are now deprecated on OSX
+  and iOS.
+  ([#1033](https://github.com/nix-rust/nix/pull/1033))
 
 ## [0.12.0] 2018-11-28
 
@@ -704,7 +1039,24 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Fixed passing multiple file descriptors over Unix Sockets.
   ([#918](https://github.com/nix-rust/nix/pull/918))
 
+## [0.11.1] 2019-06-06
+### Changed
+- Changed some public types from reexports of libc types like `uint32_t` to the
+  native equivalents like `u32.`
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+
+### Fixed
+- Fix the build on Android and Linux/mips with recent versions of libc.
+  ([#1072](https://github.com/nix-rust/nix/pull/1072/commits))
+- Fixed build on Linux/arm and Linux/s390x with the latest Rust libc
+  ([52102cb](https://github.com/nix-rust/nix/commit/52102cb76398c4dfb9ea141b98c5b01a2e050973))
+
 ### Removed
+- `fexecve` never worked on NetBSD or on OpenBSD as it is not implemented on
+  either OS. It has been removed. ([#1000](https://github.com/nix-rust/nix/pull/1000))
+- `Daemon`, `NOTE_REAP`, and `NOTE_EXIT_REPARENTED` are now deprecated on OSX
+  and iOS.
+  ([#1033](https://github.com/nix-rust/nix/pull/1033))
 
 ## [0.11.0] 2018-06-01
 
diff --git a/Cargo.toml b/Cargo.toml
index 122c1af..0afc445 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,17 +11,41 @@
 
 [package]
 edition = "2018"
-rust-version = "1.46"
+rust-version = "1.56"
 name = "nix"
-version = "0.23.1"
+version = "0.26.2"
 authors = ["The nix-rust Project Developers"]
-include = ["src/**/*", "test/**/*", "LICENSE", "README.md", "CHANGELOG.md"]
+include = [
+    "src/**/*",
+    "test/**/*",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+]
 description = "Rust friendly bindings to *nix APIs"
+readme = "README.md"
 categories = ["os::unix-apis"]
 license = "MIT"
 repository = "https://github.com/nix-rust/nix"
+
 [package.metadata.docs.rs]
-targets = ["x86_64-unknown-linux-gnu", "aarch64-linux-android", "x86_64-apple-darwin", "aarch64-apple-ios", "x86_64-unknown-freebsd", "x86_64-unknown-openbsd", "x86_64-unknown-netbsd", "x86_64-unknown-dragonfly", "x86_64-fuchsia", "x86_64-unknown-redox", "x86_64-unknown-illumos"]
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+targets = [
+    "x86_64-unknown-linux-gnu",
+    "aarch64-linux-android",
+    "x86_64-apple-darwin",
+    "aarch64-apple-ios",
+    "x86_64-unknown-freebsd",
+    "x86_64-unknown-openbsd",
+    "x86_64-unknown-netbsd",
+    "x86_64-unknown-dragonfly",
+    "x86_64-fuchsia",
+    "x86_64-unknown-redox",
+    "x86_64-unknown-illumos",
+]
 
 [[test]]
 name = "test"
@@ -36,10 +60,6 @@ name = "test-clearenv"
 path = "test/test_clearenv.rs"
 
 [[test]]
-name = "test-lio-listio-resubmit"
-path = "test/sys/test_lio_listio_resubmit.rs"
-
-[[test]]
 name = "test-mount"
 path = "test/test_mount.rs"
 harness = false
@@ -47,6 +67,7 @@ harness = false
 [[test]]
 name = "test-ptymaster-drop"
 path = "test/test_ptymaster_drop.rs"
+
 [dependencies.bitflags]
 version = "1.1"
 
@@ -54,30 +75,111 @@ version = "1.1"
 version = "1.0"
 
 [dependencies.libc]
-version = "0.2.102"
+version = "0.2.137"
 features = ["extra_traits"]
+
+[dependencies.pin-utils]
+version = "0.1.0"
+optional = true
+
+[dependencies.static_assertions]
+version = "1"
+
 [dev-dependencies.assert-impl]
 version = "0.1"
 
 [dev-dependencies.lazy_static]
-version = "1.2"
+version = "1.4"
 
 [dev-dependencies.parking_lot]
-version = "0.11.2"
+version = "0.12"
 
 [dev-dependencies.rand]
 version = "0.8"
 
 [dev-dependencies.semver]
-version = "1.0.0"
+version = "1.0.7"
 
 [dev-dependencies.tempfile]
-version = "3.2.0"
+version = "3.3.0"
+
+[features]
+acct = []
+aio = ["pin-utils"]
+default = [
+    "acct",
+    "aio",
+    "dir",
+    "env",
+    "event",
+    "feature",
+    "fs",
+    "hostname",
+    "inotify",
+    "ioctl",
+    "kmod",
+    "mman",
+    "mount",
+    "mqueue",
+    "net",
+    "personality",
+    "poll",
+    "process",
+    "pthread",
+    "ptrace",
+    "quota",
+    "reboot",
+    "resource",
+    "sched",
+    "signal",
+    "socket",
+    "term",
+    "time",
+    "ucontext",
+    "uio",
+    "user",
+    "zerocopy",
+]
+dir = ["fs"]
+env = []
+event = []
+feature = []
+fs = []
+hostname = []
+inotify = []
+ioctl = []
+kmod = []
+mman = []
+mount = ["uio"]
+mqueue = ["fs"]
+net = ["socket"]
+personality = []
+poll = []
+process = []
+pthread = []
+ptrace = ["process"]
+quota = []
+reboot = []
+resource = []
+sched = ["process"]
+signal = ["process"]
+socket = ["memoffset"]
+term = []
+time = []
+ucontext = ["signal"]
+uio = []
+user = ["feature"]
+zerocopy = [
+    "fs",
+    "uio",
+]
+
 [target."cfg(any(target_os = \"android\", target_os = \"linux\"))".dev-dependencies.caps]
-version = "0.5.1"
+version = "0.5.3"
+
 [target."cfg(not(target_os = \"redox\"))".dependencies.memoffset]
-version = "0.6.3"
-[target."cfg(target_os = \"dragonfly\")".build-dependencies.cc]
-version = "1"
+version = "0.7"
+optional = true
+
 [target."cfg(target_os = \"freebsd\")".dev-dependencies.sysctl]
-version = "0.1"
+version = "0.4"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index d2ca8ee..8b1d873 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -2,8 +2,8 @@
 name        = "nix"
 description = "Rust friendly bindings to *nix APIs"
 edition     = "2018"
-version     = "0.23.1"
-rust-version = "1.46"
+version     = "0.26.2"
+rust-version = "1.56"
 authors     = ["The nix-rust Project Developers"]
 repository  = "https://github.com/nix-rust/nix"
 license     = "MIT"
@@ -11,6 +11,7 @@ categories  = ["os::unix-apis"]
 include = ["src/**/*", "test/**/*", "LICENSE", "README.md", "CHANGELOG.md"]
 
 [package.metadata.docs.rs]
+rustdoc-args = ["--cfg", "docsrs"]
 targets = [
   "x86_64-unknown-linux-gnu",
   "aarch64-linux-android",
@@ -26,29 +27,70 @@ targets = [
 ]
 
 [dependencies]
-libc = { version = "0.2.102", features = [ "extra_traits" ] }
+libc = { version = "0.2.137", features = [ "extra_traits" ] }
 bitflags = "1.1"
 cfg-if = "1.0"
+pin-utils = { version = "0.1.0", optional = true }
+static_assertions = "1"
 
 [target.'cfg(not(target_os = "redox"))'.dependencies]
-memoffset = "0.6.3"
+memoffset = { version = "0.7", optional = true }
 
-[target.'cfg(target_os = "dragonfly")'.build-dependencies]
-cc = "1"
+[features]
+default = [
+  "acct", "aio", "dir", "env", "event", "feature", "fs",
+  "hostname", "inotify", "ioctl", "kmod", "mman", "mount", "mqueue",
+  "net", "personality", "poll", "process", "pthread", "ptrace", "quota",
+  "reboot", "resource", "sched", "signal", "socket", "term", "time",
+  "ucontext", "uio", "user", "zerocopy",
+]
+
+acct = []
+aio = ["pin-utils"]
+dir = ["fs"]
+env = []
+event = []
+feature = []
+fs = []
+hostname = []
+inotify = []
+ioctl = []
+kmod = []
+mman = []
+mount = ["uio"]
+mqueue = ["fs"]
+net = ["socket"]
+personality = []
+poll = []
+pthread = []
+ptrace = ["process"]
+quota = []
+process = []
+reboot = []
+resource = []
+sched = ["process"]
+signal = ["process"]
+socket = ["memoffset"]
+term = []
+time = []
+ucontext = ["signal"]
+uio = []
+user = ["feature"]
+zerocopy = ["fs", "uio"]
 
 [dev-dependencies]
 assert-impl = "0.1"
-lazy_static = "1.2"
-parking_lot = "0.11.2"
+lazy_static = "1.4"
+parking_lot = "0.12"
 rand = "0.8"
-tempfile = "3.2.0"
-semver = "1.0.0"
+tempfile = "3.3.0"
+semver = "1.0.7"
 
 [target.'cfg(any(target_os = "android", target_os = "linux"))'.dev-dependencies]
-caps = "0.5.1"
+caps = "0.5.3"
 
 [target.'cfg(target_os = "freebsd")'.dev-dependencies]
-sysctl = "0.1"
+sysctl = "0.4"
 
 [[test]]
 name = "test"
@@ -63,10 +105,6 @@ name = "test-clearenv"
 path = "test/test_clearenv.rs"
 
 [[test]]
-name = "test-lio-listio-resubmit"
-path = "test/sys/test_lio_listio_resubmit.rs"
-
-[[test]]
 name = "test-mount"
 path = "test/test_mount.rs"
 harness = false
diff --git a/METADATA b/METADATA
index e0fef6c..b1b992d 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,7 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/nix
+# For more info, check https://cs.android.com/android/platform/superproject/+/master:tools/external_updater/README.md
+
 name: "nix"
 description: "Rust friendly bindings to *nix APIs"
 third_party {
@@ -7,13 +11,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/nix/nix-0.23.1.crate"
+    value: "https://static.crates.io/crates/nix/nix-0.26.2.crate"
   }
-  version: "0.23.1"
+  version: "0.26.2"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2022
-    month: 3
+    year: 2023
+    month: 2
     day: 16
   }
 }
diff --git a/README.md b/README.md
index a8759f1..2c42b90 100644
--- a/README.md
+++ b/README.md
@@ -24,8 +24,8 @@ call:
 // libc api (unsafe, requires handling return code/errno)
 pub unsafe extern fn gethostname(name: *mut c_char, len: size_t) -> c_int;
 
-// nix api (returns a nix::Result<CStr>)
-pub fn gethostname<'a>(buffer: &'a mut [u8]) -> Result<&'a CStr>;
+// nix api (returns a nix::Result<OsString>)
+pub fn gethostname() -> Result<OsString>;
 ```
 
 ## Supported Platforms
@@ -47,6 +47,7 @@ limitations. Support for platforms is split into three tiers:
 The following targets are supported by `nix`:
 
 Tier 1:
+  * aarch64-apple-darwin
   * aarch64-unknown-linux-gnu
   * arm-unknown-linux-gnueabi
   * armv7-unknown-linux-gnueabihf
@@ -58,7 +59,6 @@ Tier 1:
   * mips64el-unknown-linux-gnuabi64
   * mipsel-unknown-linux-gnu
   * powerpc64le-unknown-linux-gnu
-  * x86_64-apple-darwin
   * x86_64-unknown-freebsd
   * x86_64-unknown-linux-gnu
   * x86_64-unknown-linux-musl
@@ -74,19 +74,22 @@ Tier 2:
   * s390x-unknown-linux-gnu
   * x86_64-apple-ios
   * x86_64-linux-android
+  * x86_64-apple-darwin
   * x86_64-unknown-illumos
   * x86_64-unknown-netbsd
 
 Tier 3:
+  * armv7-unknown-linux-uclibceabihf
   * x86_64-fuchsia
   * x86_64-unknown-dragonfly
+  * x86_64-unknown-haiku
   * x86_64-unknown-linux-gnux32
   * x86_64-unknown-openbsd
   * x86_64-unknown-redox
 
 ## Minimum Supported Rust Version (MSRV)
 
-nix is supported on Rust 1.46.0 and higher.  It's MSRV will not be
+nix is supported on Rust 1.56.1 and higher.  Its MSRV will not be
 changed in the future without bumping the major or minor version.
 
 ## Contributing
diff --git a/TEST_MAPPING b/TEST_MAPPING
index b44b9e2..10e0efb 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -3,100 +3,45 @@
   "imports": [
     {
       "path": "external/rust/crates/tokio"
-    }
-  ],
-  "presubmit": [
-    {
-      "name": "ZipFuseTest"
-    },
-    {
-      "name": "apkdmverity.test"
-    },
-    {
-      "name": "authfs_device_test_src_lib"
-    },
-    {
-      "name": "diced_open_dice_cbor_test"
-    },
-    {
-      "name": "diced_sample_inputs_test"
-    },
-    {
-      "name": "diced_test"
-    },
-    {
-      "name": "diced_utils_test"
-    },
-    {
-      "name": "diced_vendor_test"
-    },
-    {
-      "name": "keystore2_crypto_test_rust"
-    },
-    {
-      "name": "keystore2_selinux_concurrency_test"
-    },
-    {
-      "name": "keystore2_test"
-    },
-    {
-      "name": "keystore2_test_utils_test"
-    },
-    {
-      "name": "legacykeystore_test"
-    },
-    {
-      "name": "microdroid_manager_test"
-    },
-    {
-      "name": "virtualizationservice_device_test"
-    }
-  ],
-  "presubmit-rust": [
-    {
-      "name": "ZipFuseTest"
-    },
-    {
-      "name": "apkdmverity.test"
     },
     {
-      "name": "authfs_device_test_src_lib"
+      "path": "packages/modules/Virtualization/apkdmverity"
     },
     {
-      "name": "diced_open_dice_cbor_test"
+      "path": "packages/modules/Virtualization/authfs"
     },
     {
-      "name": "diced_sample_inputs_test"
+      "path": "packages/modules/Virtualization/encryptedstore"
     },
     {
-      "name": "diced_test"
+      "path": "packages/modules/Virtualization/libs/capabilities"
     },
     {
-      "name": "diced_utils_test"
+      "path": "packages/modules/Virtualization/libs/devicemapper"
     },
     {
-      "name": "diced_vendor_test"
+      "path": "packages/modules/Virtualization/microdroid_manager"
     },
     {
-      "name": "keystore2_crypto_test_rust"
+      "path": "packages/modules/Virtualization/virtualizationmanager"
     },
     {
-      "name": "keystore2_selinux_concurrency_test"
+      "path": "packages/modules/Virtualization/vm"
     },
     {
-      "name": "keystore2_test"
+      "path": "packages/modules/Virtualization/zipfuse"
     },
     {
-      "name": "keystore2_test_utils_test"
+      "path": "system/security/diced"
     },
     {
-      "name": "legacykeystore_test"
+      "path": "system/security/keystore2"
     },
     {
-      "name": "microdroid_manager_test"
+      "path": "system/security/keystore2/legacykeystore"
     },
     {
-      "name": "virtualizationservice_device_test"
+      "path": "system/security/keystore2/src/crypto"
     }
   ]
 }
diff --git a/cargo2android.json b/cargo2android.json
index f8fb37c..ece6226 100644
--- a/cargo2android.json
+++ b/cargo2android.json
@@ -1,7 +1,7 @@
 {
   "apex-available": [
     "//apex_available:platform",
-    "com.android.bluetooth",
+    "com.android.btservices",
     "com.android.compos",
     "com.android.virt"
   ],
diff --git a/patches/Android.bp.diff b/patches/Android.bp.diff
new file mode 100644
index 0000000..c7025be
--- /dev/null
+++ b/patches/Android.bp.diff
@@ -0,0 +1,13 @@
+diff --git a/Android.bp b/Android.bp
+index f471209..f44d482 100644
+--- a/Android.bp
++++ b/Android.bp
+@@ -67,7 +67,7 @@ rust_library {
+         "zerocopy",
+     ],
+     rustlibs: [
+-        "libbitflags",
++        "libbitflags-1.3.2",
+         "libcfg_if",
+         "liblibc",
+         "libmemoffset",
diff --git a/patches/memfd.diff b/patches/memfd.diff
new file mode 100644
index 0000000..a5d4609
--- /dev/null
+++ b/patches/memfd.diff
@@ -0,0 +1,15 @@
+diff --git a/src/sys/memfd.rs b/src/sys/memfd.rs
+index ad9345e..e43e1e5 100644
+--- a/src/sys/memfd.rs
++++ b/src/sys/memfd.rs
+@@ -49,7 +49,9 @@ pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result<RawFd> {
+                 any(
+                     target_os = "freebsd",
+                     // If the OS is Linux, gnu and musl expose a memfd_create symbol but not uclibc
+-                    target_env = "gnu",
++                    //
++                    // ANDROID: Our glibc is too old to have memfd_create.
++                    // target_env = "gnu",
+                     target_env = "musl",
+                 )))]
+             {
diff --git a/patches/unistd.diff b/patches/unistd.diff
new file mode 100644
index 0000000..4815309
--- /dev/null
+++ b/patches/unistd.diff
@@ -0,0 +1,22 @@
+diff --git a/src/unistd.rs b/src/unistd.rs
+index 42e1456..8cdb54b 100644
+--- a/src/unistd.rs
++++ b/src/unistd.rs
+@@ -2984,12 +2984,12 @@ impl From<&libc::passwd> for User {
+     fn from(pw: &libc::passwd) -> User {
+         unsafe {
+             User {
+-                name: CStr::from_ptr(pw.pw_name).to_string_lossy().into_owned(),
+-                passwd: CString::new(CStr::from_ptr(pw.pw_passwd).to_bytes()).unwrap(),
++                name: if pw.pw_name.is_null() { Default::default() } else { CStr::from_ptr(pw.pw_name).to_string_lossy().into_owned() },
++                passwd: if pw.pw_passwd.is_null() { Default::default() } else { CString::new(CStr::from_ptr(pw.pw_passwd).to_bytes()).unwrap() },
+                 #[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
+-                gecos: CString::new(CStr::from_ptr(pw.pw_gecos).to_bytes()).unwrap(),
+-                dir: PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_dir).to_bytes())),
+-                shell: PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_shell).to_bytes())),
++                gecos: if pw.pw_gecos.is_null() { Default::default() } else { CString::new(CStr::from_ptr(pw.pw_gecos).to_bytes()).unwrap() },
++                dir: if pw.pw_dir.is_null() { Default::default() } else { PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_dir).to_bytes())) },
++                shell: if pw.pw_shell.is_null() { Default::default() } else { PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_shell).to_bytes())) },
+                 uid: Uid::from_raw(pw.pw_uid),
+                 gid: Gid::from_raw(pw.pw_gid),
+                 #[cfg(not(any(target_os = "android",
diff --git a/src/dir.rs b/src/dir.rs
index ed70a45..5ce5036 100644
--- a/src/dir.rs
+++ b/src/dir.rs
@@ -1,10 +1,13 @@
-use crate::{Error, NixPath, Result};
+//! List directory contents
+
 use crate::errno::Errno;
 use crate::fcntl::{self, OFlag};
+use crate::sys;
+use crate::{Error, NixPath, Result};
+use cfg_if::cfg_if;
+use std::ffi;
 use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
 use std::ptr;
-use std::ffi;
-use crate::sys;
 
 #[cfg(target_os = "linux")]
 use libc::{dirent64 as dirent, readdir64_r as readdir_r};
@@ -26,21 +29,26 @@ use libc::{dirent, readdir_r};
 ///    * returns entries' names as a `CStr` (no allocation or conversion beyond whatever libc
 ///      does).
 #[derive(Debug, Eq, Hash, PartialEq)]
-pub struct Dir(
-    ptr::NonNull<libc::DIR>
-);
+pub struct Dir(ptr::NonNull<libc::DIR>);
 
 impl Dir {
     /// Opens the given path as with `fcntl::open`.
-    pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag,
-                                     mode: sys::stat::Mode) -> Result<Self> {
+    pub fn open<P: ?Sized + NixPath>(
+        path: &P,
+        oflag: OFlag,
+        mode: sys::stat::Mode,
+    ) -> Result<Self> {
         let fd = fcntl::open(path, oflag, mode)?;
         Dir::from_fd(fd)
     }
 
     /// Opens the given path as with `fcntl::openat`.
-    pub fn openat<P: ?Sized + NixPath>(dirfd: RawFd, path: &P, oflag: OFlag,
-                                       mode: sys::stat::Mode) -> Result<Self> {
+    pub fn openat<P: ?Sized + NixPath>(
+        dirfd: RawFd,
+        path: &P,
+        oflag: OFlag,
+        mode: sys::stat::Mode,
+    ) -> Result<Self> {
         let fd = fcntl::openat(dirfd, path, oflag, mode)?;
         Dir::from_fd(fd)
     }
@@ -52,12 +60,15 @@ impl Dir {
     }
 
     /// Converts from a file descriptor, closing it on success or failure.
+    #[doc(alias("fdopendir"))]
     pub fn from_fd(fd: RawFd) -> Result<Self> {
-        let d = ptr::NonNull::new(unsafe { libc::fdopendir(fd) }).ok_or_else(|| {
-            let e = Error::last();
-            unsafe { libc::close(fd) };
-            e
-        })?;
+        let d = ptr::NonNull::new(unsafe { libc::fdopendir(fd) }).ok_or_else(
+            || {
+                let e = Error::last();
+                unsafe { libc::close(fd) };
+                e
+            },
+        )?;
         Ok(Dir(d))
     }
 
@@ -99,9 +110,11 @@ fn next(dir: &mut Dir) -> Option<Result<Entry>> {
         // Probably fine here too then.
         let mut ent = std::mem::MaybeUninit::<dirent>::uninit();
         let mut result = ptr::null_mut();
-        if let Err(e) = Errno::result(
-            readdir_r(dir.0.as_ptr(), ent.as_mut_ptr(), &mut result))
-        {
+        if let Err(e) = Errno::result(readdir_r(
+            dir.0.as_ptr(),
+            ent.as_mut_ptr(),
+            &mut result,
+        )) {
             return Some(Err(e));
         }
         if result.is_null() {
@@ -112,6 +125,7 @@ fn next(dir: &mut Dir) -> Option<Result<Entry>> {
     }
 }
 
+/// Return type of [`Dir::iter`].
 #[derive(Debug, Eq, Hash, PartialEq)]
 pub struct Iter<'d>(&'d mut Dir);
 
@@ -141,6 +155,14 @@ impl Iterator for OwningIter {
     }
 }
 
+/// The file descriptor continues to be owned by the `OwningIter`,
+/// so callers must not keep a `RawFd` after the `OwningIter` is dropped.
+impl AsRawFd for OwningIter {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
 impl IntoIterator for Dir {
     type Item = Result<Entry>;
     type IntoIter = OwningIter;
@@ -173,47 +195,47 @@ impl IntoIterator for Dir {
 #[repr(transparent)]
 pub struct Entry(dirent);
 
+/// Type of file referenced by a directory entry
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
 pub enum Type {
+    /// FIFO (Named pipe)
     Fifo,
+    /// Character device
     CharacterDevice,
+    /// Directory
     Directory,
+    /// Block device
     BlockDevice,
+    /// Regular file
     File,
+    /// Symbolic link
     Symlink,
+    /// Unix-domain socket
     Socket,
 }
 
 impl Entry {
     /// Returns the inode number (`d_ino`) of the underlying `dirent`.
-    #[cfg(any(target_os = "android",
-              target_os = "emscripten",
-              target_os = "fuchsia",
-              target_os = "haiku",
-              target_os = "illumos",
-              target_os = "ios",
-              target_os = "l4re",
-              target_os = "linux",
-              target_os = "macos",
-              target_os = "solaris"))]
-    pub fn ino(&self) -> u64 {
-        self.0.d_ino as u64
-    }
-
-    /// Returns the inode number (`d_fileno`) of the underlying `dirent`.
-    #[cfg(not(any(target_os = "android",
-                  target_os = "emscripten",
-                  target_os = "fuchsia",
-                  target_os = "haiku",
-                  target_os = "illumos",
-                  target_os = "ios",
-                  target_os = "l4re",
-                  target_os = "linux",
-                  target_os = "macos",
-                  target_os = "solaris")))]
-    #[allow(clippy::useless_conversion)]    // Not useless on all OSes
+    #[allow(clippy::useless_conversion)] // Not useless on all OSes
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     pub fn ino(&self) -> u64 {
-        u64::from(self.0.d_fileno)
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                         target_os = "emscripten",
+                         target_os = "fuchsia",
+                         target_os = "haiku",
+                         target_os = "illumos",
+                         target_os = "ios",
+                         target_os = "l4re",
+                         target_os = "linux",
+                         target_os = "macos",
+                         target_os = "solaris"))] {
+                self.0.d_ino as u64
+            } else {
+                u64::from(self.0.d_fileno)
+            }
+        }
     }
 
     /// Returns the bare file name of this directory entry without any other leading path component.
@@ -227,7 +249,11 @@ impl Entry {
     /// notably, some Linux filesystems don't implement this. The caller should use `stat` or
     /// `fstat` if this returns `None`.
     pub fn file_type(&self) -> Option<Type> {
-        #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+        #[cfg(not(any(
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "haiku"
+        )))]
         match self.0.d_type {
             libc::DT_FIFO => Some(Type::Fifo),
             libc::DT_CHR => Some(Type::CharacterDevice),
@@ -239,8 +265,12 @@ impl Entry {
             /* libc::DT_UNKNOWN | */ _ => None,
         }
 
-        // illumos and Solaris systems do not have the d_type member at all:
-        #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        // illumos, Solaris, and Haiku systems do not have the d_type member at all:
+        #[cfg(any(
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "haiku"
+        ))]
         None
     }
 }
diff --git a/src/env.rs b/src/env.rs
index bcae287..95177a1 100644
--- a/src/env.rs
+++ b/src/env.rs
@@ -42,7 +42,6 @@ pub unsafe fn clearenv() -> std::result::Result<(), ClearEnvError> {
     cfg_if! {
         if #[cfg(any(target_os = "fuchsia",
                      target_os = "wasi",
-                     target_env = "wasi",
                      target_env = "uclibc",
                      target_os = "linux",
                      target_os = "android",
diff --git a/src/errno.rs b/src/errno.rs
index 3da246e..d8ad28d 100644
--- a/src/errno.rs
+++ b/src/errno.rs
@@ -1,8 +1,8 @@
+use crate::Result;
 use cfg_if::cfg_if;
 use libc::{c_int, c_void};
 use std::convert::TryFrom;
-use std::{fmt, io, error};
-use crate::{Error, Result};
+use std::{error, fmt, io};
 
 pub use self::consts::*;
 
@@ -30,6 +30,10 @@ cfg_if! {
         unsafe fn errno_location() -> *mut c_int {
             libc::___errno()
         }
+    } else if #[cfg(any(target_os = "haiku",))] {
+        unsafe fn errno_location() -> *mut c_int {
+            libc::_errnop()
+        }
     }
 }
 
@@ -43,49 +47,10 @@ fn clear() {
 
 /// Returns the platform-specific value of errno
 pub fn errno() -> i32 {
-    unsafe {
-        (*errno_location()) as i32
-    }
+    unsafe { *errno_location() }
 }
 
 impl Errno {
-    /// Convert this `Error` to an [`Errno`](enum.Errno.html).
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use nix::Error;
-    /// # use nix::errno::Errno;
-    /// let e = Error::from(Errno::EPERM);
-    /// assert_eq!(Some(Errno::EPERM), e.as_errno());
-    /// ```
-    #[deprecated(
-        since = "0.22.0",
-        note = "It's a no-op now; just delete it."
-    )]
-    pub const fn as_errno(self) -> Option<Self> {
-        Some(self)
-    }
-
-    /// Create a nix Error from a given errno
-    #[deprecated(
-        since = "0.22.0",
-        note = "It's a no-op now; just delete it."
-    )]
-    #[allow(clippy::wrong_self_convention)] // False positive
-    pub fn from_errno(errno: Errno) -> Error {
-        errno
-    }
-
-    /// Create a new invalid argument error (`EINVAL`)
-    #[deprecated(
-        since = "0.22.0",
-        note = "Use Errno::EINVAL instead"
-    )]
-    pub const fn invalid_argument() -> Error {
-        Errno::EINVAL
-    }
-
     pub fn last() -> Self {
         last()
     }
@@ -112,21 +77,6 @@ impl Errno {
             Ok(value)
         }
     }
-
-    /// Backwards compatibility hack for Nix <= 0.21.0 users
-    ///
-    /// In older versions of Nix, `Error::Sys` was an enum variant.  Now it's a
-    /// function, which is compatible with most of the former use cases of the
-    /// enum variant.  But you should use `Error(Errno::...)` instead.
-    #[deprecated(
-        since = "0.22.0",
-        note = "Use Errno::... instead"
-    )]
-    #[allow(non_snake_case)]
-    #[inline]
-    pub const fn Sys(errno: Errno) -> Error {
-        errno
-    }
 }
 
 /// The sentinel value indicates that a function failed and more detailed
@@ -136,23 +86,33 @@ pub trait ErrnoSentinel: Sized {
 }
 
 impl ErrnoSentinel for isize {
-    fn sentinel() -> Self { -1 }
+    fn sentinel() -> Self {
+        -1
+    }
 }
 
 impl ErrnoSentinel for i32 {
-    fn sentinel() -> Self { -1 }
+    fn sentinel() -> Self {
+        -1
+    }
 }
 
 impl ErrnoSentinel for i64 {
-    fn sentinel() -> Self { -1 }
+    fn sentinel() -> Self {
+        -1
+    }
 }
 
 impl ErrnoSentinel for *mut c_void {
-    fn sentinel() -> Self { -1isize as *mut c_void }
+    fn sentinel() -> Self {
+        -1isize as *mut c_void
+    }
 }
 
 impl ErrnoSentinel for libc::sighandler_t {
-    fn sentinel() -> Self { libc::SIG_ERR }
+    fn sentinel() -> Self {
+        libc::SIG_ERR
+    }
 }
 
 impl error::Error for Errno {}
@@ -173,9 +133,7 @@ impl TryFrom<io::Error> for Errno {
     type Error = io::Error;
 
     fn try_from(ioerror: io::Error) -> std::result::Result<Self, io::Error> {
-        ioerror.raw_os_error()
-            .map(Errno::from_i32)
-            .ok_or(ioerror)
+        ioerror.raw_os_error().map(Errno::from_i32).ok_or(ioerror)
     }
 }
 
@@ -186,748 +144,1123 @@ fn last() -> Errno {
 fn desc(errno: Errno) -> &'static str {
     use self::Errno::*;
     match errno {
-        UnknownErrno    => "Unknown errno",
-        EPERM           => "Operation not permitted",
-        ENOENT          => "No such file or directory",
-        ESRCH           => "No such process",
-        EINTR           => "Interrupted system call",
-        EIO             => "I/O error",
-        ENXIO           => "No such device or address",
-        E2BIG           => "Argument list too long",
-        ENOEXEC         => "Exec format error",
-        EBADF           => "Bad file number",
-        ECHILD          => "No child processes",
-        EAGAIN          => "Try again",
-        ENOMEM          => "Out of memory",
-        EACCES          => "Permission denied",
-        EFAULT          => "Bad address",
-        ENOTBLK         => "Block device required",
-        EBUSY           => "Device or resource busy",
-        EEXIST          => "File exists",
-        EXDEV           => "Cross-device link",
-        ENODEV          => "No such device",
-        ENOTDIR         => "Not a directory",
-        EISDIR          => "Is a directory",
-        EINVAL          => "Invalid argument",
-        ENFILE          => "File table overflow",
-        EMFILE          => "Too many open files",
-        ENOTTY          => "Not a typewriter",
-        ETXTBSY         => "Text file busy",
-        EFBIG           => "File too large",
-        ENOSPC          => "No space left on device",
-        ESPIPE          => "Illegal seek",
-        EROFS           => "Read-only file system",
-        EMLINK          => "Too many links",
-        EPIPE           => "Broken pipe",
-        EDOM            => "Math argument out of domain of func",
-        ERANGE          => "Math result not representable",
-        EDEADLK         => "Resource deadlock would occur",
-        ENAMETOOLONG    => "File name too long",
-        ENOLCK          => "No record locks available",
-        ENOSYS          => "Function not implemented",
-        ENOTEMPTY       => "Directory not empty",
-        ELOOP           => "Too many symbolic links encountered",
-        ENOMSG          => "No message of desired type",
-        EIDRM           => "Identifier removed",
-        EINPROGRESS     => "Operation now in progress",
-        EALREADY        => "Operation already in progress",
-        ENOTSOCK        => "Socket operation on non-socket",
-        EDESTADDRREQ    => "Destination address required",
-        EMSGSIZE        => "Message too long",
-        EPROTOTYPE      => "Protocol wrong type for socket",
-        ENOPROTOOPT     => "Protocol not available",
+        UnknownErrno => "Unknown errno",
+        EPERM => "Operation not permitted",
+        ENOENT => "No such file or directory",
+        ESRCH => "No such process",
+        EINTR => "Interrupted system call",
+        EIO => "I/O error",
+        ENXIO => "No such device or address",
+        E2BIG => "Argument list too long",
+        ENOEXEC => "Exec format error",
+        EBADF => "Bad file number",
+        ECHILD => "No child processes",
+        EAGAIN => "Try again",
+        ENOMEM => "Out of memory",
+        EACCES => "Permission denied",
+        EFAULT => "Bad address",
+        #[cfg(not(target_os = "haiku"))]
+        ENOTBLK => "Block device required",
+        EBUSY => "Device or resource busy",
+        EEXIST => "File exists",
+        EXDEV => "Cross-device link",
+        ENODEV => "No such device",
+        ENOTDIR => "Not a directory",
+        EISDIR => "Is a directory",
+        EINVAL => "Invalid argument",
+        ENFILE => "File table overflow",
+        EMFILE => "Too many open files",
+        ENOTTY => "Not a typewriter",
+        ETXTBSY => "Text file busy",
+        EFBIG => "File too large",
+        ENOSPC => "No space left on device",
+        ESPIPE => "Illegal seek",
+        EROFS => "Read-only file system",
+        EMLINK => "Too many links",
+        EPIPE => "Broken pipe",
+        EDOM => "Math argument out of domain of func",
+        ERANGE => "Math result not representable",
+        EDEADLK => "Resource deadlock would occur",
+        ENAMETOOLONG => "File name too long",
+        ENOLCK => "No record locks available",
+        ENOSYS => "Function not implemented",
+        ENOTEMPTY => "Directory not empty",
+        ELOOP => "Too many symbolic links encountered",
+        ENOMSG => "No message of desired type",
+        EIDRM => "Identifier removed",
+        EINPROGRESS => "Operation now in progress",
+        EALREADY => "Operation already in progress",
+        ENOTSOCK => "Socket operation on non-socket",
+        EDESTADDRREQ => "Destination address required",
+        EMSGSIZE => "Message too long",
+        EPROTOTYPE => "Protocol wrong type for socket",
+        ENOPROTOOPT => "Protocol not available",
         EPROTONOSUPPORT => "Protocol not supported",
+        #[cfg(not(target_os = "haiku"))]
         ESOCKTNOSUPPORT => "Socket type not supported",
-        EPFNOSUPPORT    => "Protocol family not supported",
-        EAFNOSUPPORT    => "Address family not supported by protocol",
-        EADDRINUSE      => "Address already in use",
-        EADDRNOTAVAIL   => "Cannot assign requested address",
-        ENETDOWN        => "Network is down",
-        ENETUNREACH     => "Network is unreachable",
-        ENETRESET       => "Network dropped connection because of reset",
-        ECONNABORTED    => "Software caused connection abort",
-        ECONNRESET      => "Connection reset by peer",
-        ENOBUFS         => "No buffer space available",
-        EISCONN         => "Transport endpoint is already connected",
-        ENOTCONN        => "Transport endpoint is not connected",
-        ESHUTDOWN       => "Cannot send after transport endpoint shutdown",
-        ETOOMANYREFS    => "Too many references: cannot splice",
-        ETIMEDOUT       => "Connection timed out",
-        ECONNREFUSED    => "Connection refused",
-        EHOSTDOWN       => "Host is down",
-        EHOSTUNREACH    => "No route to host",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ECHRNG          => "Channel number out of range",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EL2NSYNC        => "Level 2 not synchronized",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EL3HLT          => "Level 3 halted",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EL3RST          => "Level 3 reset",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELNRNG          => "Link number out of range",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EUNATCH         => "Protocol driver not attached",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOCSI          => "No CSI structure available",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EL2HLT          => "Level 2 halted",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBADE           => "Invalid exchange",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBADR           => "Invalid request descriptor",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EXFULL          => "Exchange full",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOANO          => "No anode",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBADRQC         => "Invalid request code",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBADSLT         => "Invalid slot",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBFONT          => "Bad font file format",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOSTR          => "Device not a stream",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENODATA         => "No data available",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ETIME           => "Timer expired",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOSR           => "Out of streams resources",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENONET          => "Machine is not on the network",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOPKG          => "Package not installed",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EREMOTE         => "Object is remote",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOLINK         => "Link has been severed",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EADV            => "Advertise error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ESRMNT          => "Srmount error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ECOMM           => "Communication error on send",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EPROTO          => "Protocol error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EMULTIHOP       => "Multihop attempted",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EDOTDOT         => "RFS specific error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EBADMSG         => "Not a data message",
+        #[cfg(not(target_os = "haiku"))]
+        EPFNOSUPPORT => "Protocol family not supported",
+        #[cfg(not(target_os = "haiku"))]
+        EAFNOSUPPORT => "Address family not supported by protocol",
+        EADDRINUSE => "Address already in use",
+        EADDRNOTAVAIL => "Cannot assign requested address",
+        ENETDOWN => "Network is down",
+        ENETUNREACH => "Network is unreachable",
+        ENETRESET => "Network dropped connection because of reset",
+        ECONNABORTED => "Software caused connection abort",
+        ECONNRESET => "Connection reset by peer",
+        ENOBUFS => "No buffer space available",
+        EISCONN => "Transport endpoint is already connected",
+        ENOTCONN => "Transport endpoint is not connected",
+        ESHUTDOWN => "Cannot send after transport endpoint shutdown",
+        #[cfg(not(target_os = "haiku"))]
+        ETOOMANYREFS => "Too many references: cannot splice",
+        ETIMEDOUT => "Connection timed out",
+        ECONNREFUSED => "Connection refused",
+        EHOSTDOWN => "Host is down",
+        EHOSTUNREACH => "No route to host",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ECHRNG => "Channel number out of range",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EL2NSYNC => "Level 2 not synchronized",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EL3HLT => "Level 3 halted",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EL3RST => "Level 3 reset",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELNRNG => "Link number out of range",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EUNATCH => "Protocol driver not attached",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOCSI => "No CSI structure available",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EL2HLT => "Level 2 halted",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBADE => "Invalid exchange",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBADR => "Invalid request descriptor",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EXFULL => "Exchange full",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOANO => "No anode",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBADRQC => "Invalid request code",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBADSLT => "Invalid slot",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBFONT => "Bad font file format",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOSTR => "Device not a stream",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENODATA => "No data available",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ETIME => "Timer expired",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOSR => "Out of streams resources",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENONET => "Machine is not on the network",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOPKG => "Package not installed",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EREMOTE => "Object is remote",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOLINK => "Link has been severed",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EADV => "Advertise error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ESRMNT => "Srmount error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ECOMM => "Communication error on send",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EPROTO => "Protocol error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EMULTIHOP => "Multihop attempted",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EDOTDOT => "RFS specific error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EBADMSG => "Not a data message",
 
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-        EBADMSG         => "Trying to read unreadable message",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EOVERFLOW       => "Value too large for defined data type",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ENOTUNIQ        => "Name not unique on network",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EBADFD          => "File descriptor in bad state",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EREMCHG         => "Remote address changed",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELIBACC         => "Can not access a needed shared library",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELIBBAD         => "Accessing a corrupted shared library",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELIBSCN         => ".lib section in a.out corrupted",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELIBMAX         => "Attempting to link in too many shared libraries",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ELIBEXEC        => "Cannot exec a shared library directly",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia", target_os = "openbsd"))]
-        EILSEQ          => "Illegal byte sequence",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ERESTART        => "Interrupted system call should be restarted",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ESTRPIPE        => "Streams pipe error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        EUSERS          => "Too many users",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia", target_os = "netbsd",
-                  target_os = "redox"))]
-        EOPNOTSUPP      => "Operation not supported on transport endpoint",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        ESTALE          => "Stale file handle",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EUCLEAN         => "Structure needs cleaning",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        ENOTNAM         => "Not a XENIX named type file",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        ENAVAIL         => "No XENIX semaphores available",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EISNAM          => "Is a named type file",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EREMOTEIO       => "Remote I/O error",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EDQUOT          => "Quota exceeded",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia", target_os = "openbsd",
-                  target_os = "dragonfly"))]
-        ENOMEDIUM       => "No medium found",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia", target_os = "openbsd"))]
-        EMEDIUMTYPE     => "Wrong medium type",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "illumos", target_os = "solaris",
-                  target_os = "fuchsia"))]
-        ECANCELED       => "Operation canceled",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        ENOKEY          => "Required key not available",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EKEYEXPIRED     => "Key has expired",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EKEYREVOKED     => "Key has been revoked",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EKEYREJECTED    => "Key was rejected by service",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
-        EOWNERDEAD      => "Owner died",
-
-        #[cfg(any( target_os = "illumos", target_os = "solaris"))]
-        EOWNERDEAD      => "Process died with lock",
-
-        #[cfg(any(target_os = "linux", target_os = "android",
-                  target_os = "fuchsia"))]
+        EBADMSG => "Trying to read unreadable message",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia",
+            target_os = "haiku"
+        ))]
+        EOVERFLOW => "Value too large for defined data type",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ENOTUNIQ => "Name not unique on network",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EBADFD => "File descriptor in bad state",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EREMCHG => "Remote address changed",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELIBACC => "Can not access a needed shared library",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELIBBAD => "Accessing a corrupted shared library",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELIBSCN => ".lib section in a.out corrupted",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELIBMAX => "Attempting to link in too many shared libraries",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ELIBEXEC => "Cannot exec a shared library directly",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia",
+            target_os = "openbsd"
+        ))]
+        EILSEQ => "Illegal byte sequence",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ERESTART => "Interrupted system call should be restarted",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        ESTRPIPE => "Streams pipe error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia"
+        ))]
+        EUSERS => "Too many users",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        EOPNOTSUPP => "Operation not supported on transport endpoint",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        ESTALE => "Stale file handle",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EUCLEAN => "Structure needs cleaning",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        ENOTNAM => "Not a XENIX named type file",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        ENAVAIL => "No XENIX semaphores available",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EISNAM => "Is a named type file",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EREMOTEIO => "Remote I/O error",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EDQUOT => "Quota exceeded",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia",
+            target_os = "openbsd",
+            target_os = "dragonfly"
+        ))]
+        ENOMEDIUM => "No medium found",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia",
+            target_os = "openbsd"
+        ))]
+        EMEDIUMTYPE => "Wrong medium type",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "fuchsia",
+            target_os = "haiku"
+        ))]
+        ECANCELED => "Operation canceled",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        ENOKEY => "Required key not available",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EKEYEXPIRED => "Key has expired",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EKEYREVOKED => "Key has been revoked",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EKEYREJECTED => "Key was rejected by service",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
+        EOWNERDEAD => "Owner died",
+
+        #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        EOWNERDEAD => "Process died with lock",
+
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "fuchsia"
+        ))]
         ENOTRECOVERABLE => "State not recoverable",
 
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
         ENOTRECOVERABLE => "Lock is not recoverable",
 
-        #[cfg(any(all(target_os = "linux", not(target_arch="mips")),
-                  target_os = "fuchsia"))]
-        ERFKILL         => "Operation not possible due to RF-kill",
+        #[cfg(any(
+            all(target_os = "linux", not(target_arch = "mips")),
+            target_os = "fuchsia"
+        ))]
+        ERFKILL => "Operation not possible due to RF-kill",
 
-        #[cfg(any(all(target_os = "linux", not(target_arch="mips")),
-                  target_os = "fuchsia"))]
-        EHWPOISON       => "Memory page has hardware error",
+        #[cfg(any(
+            all(target_os = "linux", not(target_arch = "mips")),
+            target_os = "fuchsia"
+        ))]
+        EHWPOISON => "Memory page has hardware error",
 
         #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-        EDOOFUS         => "Programming error",
-
-        #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "redox"))]
-        EMULTIHOP       => "Multihop attempted",
-
-        #[cfg(any(target_os = "freebsd", target_os = "dragonfly",
-                  target_os = "redox"))]
-        ENOLINK         => "Link has been severed",
+        EDOOFUS => "Programming error",
+
+        #[cfg(any(
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "redox"
+        ))]
+        EMULTIHOP => "Multihop attempted",
+
+        #[cfg(any(
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "redox"
+        ))]
+        ENOLINK => "Link has been severed",
 
         #[cfg(target_os = "freebsd")]
-        ENOTCAPABLE     => "Capabilities insufficient",
+        ENOTCAPABLE => "Capabilities insufficient",
 
         #[cfg(target_os = "freebsd")]
-        ECAPMODE        => "Not permitted in capability mode",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        ENEEDAUTH       => "Need authenticator",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox", target_os = "illumos",
-                  target_os = "solaris"))]
-        EOVERFLOW       => "Value too large to be stored in data type",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "netbsd", target_os = "redox"))]
-        EILSEQ          => "Illegal byte sequence",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        ENOATTR         => "Attribute not found",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox"))]
-        EBADMSG         => "Bad message",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox"))]
-        EPROTO          => "Protocol error",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "ios", target_os = "openbsd"))]
+        ECAPMODE => "Not permitted in capability mode",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        ENEEDAUTH => "Need authenticator",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "illumos",
+            target_os = "solaris"
+        ))]
+        EOVERFLOW => "Value too large to be stored in data type",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "haiku"
+        ))]
+        EILSEQ => "Illegal byte sequence",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "haiku"
+        ))]
+        ENOATTR => "Attribute not found",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "haiku"
+        ))]
+        EBADMSG => "Bad message",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "haiku"
+        ))]
+        EPROTO => "Protocol error",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd"
+        ))]
         ENOTRECOVERABLE => "State not recoverable",
 
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "ios", target_os = "openbsd"))]
-        EOWNERDEAD      => "Previous owner died",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "illumos", target_os = "solaris"))]
-        ENOTSUP         => "Operation not supported",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EPROCLIM        => "Too many processes",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox"))]
-        EUSERS          => "Too many users",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox", target_os = "illumos",
-                  target_os = "solaris"))]
-        EDQUOT          => "Disc quota exceeded",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox", target_os = "illumos",
-                  target_os = "solaris"))]
-        ESTALE          => "Stale NFS file handle",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox"))]
-        EREMOTE         => "Too many levels of remote in path",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EBADRPC         => "RPC struct is bad",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        ERPCMISMATCH    => "RPC version wrong",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EPROGUNAVAIL    => "RPC prog. not avail",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EPROGMISMATCH   => "Program version wrong",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EPROCUNAVAIL    => "Bad procedure for program",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EFTYPE          => "Inappropriate file type or format",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd"))]
-        EAUTH           => "Authentication error",
-
-        #[cfg(any(target_os = "macos", target_os = "freebsd",
-                  target_os = "dragonfly", target_os = "ios",
-                  target_os = "openbsd", target_os = "netbsd",
-                  target_os = "redox"))]
-        ECANCELED       => "Operation canceled",
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd"
+        ))]
+        EOWNERDEAD => "Previous owner died",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "haiku"
+        ))]
+        ENOTSUP => "Operation not supported",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EPROCLIM => "Too many processes",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        EUSERS => "Too many users",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "haiku"
+        ))]
+        EDQUOT => "Disc quota exceeded",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox",
+            target_os = "illumos",
+            target_os = "solaris",
+            target_os = "haiku"
+        ))]
+        ESTALE => "Stale NFS file handle",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        EREMOTE => "Too many levels of remote in path",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EBADRPC => "RPC struct is bad",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        ERPCMISMATCH => "RPC version wrong",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EPROGUNAVAIL => "RPC prog. not avail",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EPROGMISMATCH => "Program version wrong",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EPROCUNAVAIL => "Bad procedure for program",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EFTYPE => "Inappropriate file type or format",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        EAUTH => "Authentication error",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "freebsd",
+            target_os = "dragonfly",
+            target_os = "ios",
+            target_os = "openbsd",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        ECANCELED => "Operation canceled",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EPWROFF         => "Device power is off",
+        EPWROFF => "Device power is off",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EDEVERR         => "Device error, e.g. paper out",
+        EDEVERR => "Device error, e.g. paper out",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EBADEXEC        => "Bad executable",
+        EBADEXEC => "Bad executable",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EBADARCH        => "Bad CPU type in executable",
+        EBADARCH => "Bad CPU type in executable",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        ESHLIBVERS      => "Shared library version mismatch",
+        ESHLIBVERS => "Shared library version mismatch",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EBADMACHO       => "Malformed Macho file",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd"))]
-        EMULTIHOP       => "Reserved",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd", target_os = "redox"))]
-        ENODATA         => "No message available on STREAM",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd"))]
-        ENOLINK         => "Reserved",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd", target_os = "redox"))]
-        ENOSR           => "No STREAM resources",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd", target_os = "redox"))]
-        ENOSTR          => "Not a STREAM",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "netbsd", target_os = "redox"))]
-        ETIME           => "STREAM ioctl timeout",
-
-        #[cfg(any(target_os = "macos", target_os = "ios",
-                  target_os = "illumos", target_os = "solaris"))]
-        EOPNOTSUPP      => "Operation not supported on socket",
+        EBADMACHO => "Malformed Macho file",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "haiku"
+        ))]
+        EMULTIHOP => "Reserved",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        ENODATA => "No message available on STREAM",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "haiku"
+        ))]
+        ENOLINK => "Reserved",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        ENOSR => "No STREAM resources",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        ENOSTR => "Not a STREAM",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "netbsd",
+            target_os = "redox"
+        ))]
+        ETIME => "STREAM ioctl timeout",
+
+        #[cfg(any(
+            target_os = "macos",
+            target_os = "ios",
+            target_os = "illumos",
+            target_os = "solaris"
+        ))]
+        EOPNOTSUPP => "Operation not supported on socket",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        ENOPOLICY       => "No such policy registered",
+        ENOPOLICY => "No such policy registered",
 
         #[cfg(any(target_os = "macos", target_os = "ios"))]
-        EQFULL          => "Interface output queue is full",
+        EQFULL => "Interface output queue is full",
 
         #[cfg(target_os = "openbsd")]
-        EOPNOTSUPP      => "Operation not supported",
+        EOPNOTSUPP => "Operation not supported",
 
         #[cfg(target_os = "openbsd")]
-        EIPSEC          => "IPsec processing failure",
+        EIPSEC => "IPsec processing failure",
 
         #[cfg(target_os = "dragonfly")]
-        EASYNC          => "Async",
+        EASYNC => "Async",
 
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-        EDEADLOCK       => "Resource deadlock would occur",
+        EDEADLOCK => "Resource deadlock would occur",
 
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-        ELOCKUNMAPPED   => "Locked lock was unmapped",
+        ELOCKUNMAPPED => "Locked lock was unmapped",
 
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-        ENOTACTIVE      => "Facility is not active",
+        ENOTACTIVE => "Facility is not active",
     }
 }
 
-#[cfg(any(target_os = "linux", target_os = "android",
-          target_os = "fuchsia"))]
+#[cfg(any(target_os = "linux", target_os = "android", target_os = "fuchsia"))]
 mod consts {
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EAGAIN          = libc::EAGAIN,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EDEADLK         = libc::EDEADLK,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        ELOOP           = libc::ELOOP,
-        ENOMSG          = libc::ENOMSG,
-        EIDRM           = libc::EIDRM,
-        ECHRNG          = libc::ECHRNG,
-        EL2NSYNC        = libc::EL2NSYNC,
-        EL3HLT          = libc::EL3HLT,
-        EL3RST          = libc::EL3RST,
-        ELNRNG          = libc::ELNRNG,
-        EUNATCH         = libc::EUNATCH,
-        ENOCSI          = libc::ENOCSI,
-        EL2HLT          = libc::EL2HLT,
-        EBADE           = libc::EBADE,
-        EBADR           = libc::EBADR,
-        EXFULL          = libc::EXFULL,
-        ENOANO          = libc::ENOANO,
-        EBADRQC         = libc::EBADRQC,
-        EBADSLT         = libc::EBADSLT,
-        EBFONT          = libc::EBFONT,
-        ENOSTR          = libc::ENOSTR,
-        ENODATA         = libc::ENODATA,
-        ETIME           = libc::ETIME,
-        ENOSR           = libc::ENOSR,
-        ENONET          = libc::ENONET,
-        ENOPKG          = libc::ENOPKG,
-        EREMOTE         = libc::EREMOTE,
-        ENOLINK         = libc::ENOLINK,
-        EADV            = libc::EADV,
-        ESRMNT          = libc::ESRMNT,
-        ECOMM           = libc::ECOMM,
-        EPROTO          = libc::EPROTO,
-        EMULTIHOP       = libc::EMULTIHOP,
-        EDOTDOT         = libc::EDOTDOT,
-        EBADMSG         = libc::EBADMSG,
-        EOVERFLOW       = libc::EOVERFLOW,
-        ENOTUNIQ        = libc::ENOTUNIQ,
-        EBADFD          = libc::EBADFD,
-        EREMCHG         = libc::EREMCHG,
-        ELIBACC         = libc::ELIBACC,
-        ELIBBAD         = libc::ELIBBAD,
-        ELIBSCN         = libc::ELIBSCN,
-        ELIBMAX         = libc::ELIBMAX,
-        ELIBEXEC        = libc::ELIBEXEC,
-        EILSEQ          = libc::EILSEQ,
-        ERESTART        = libc::ERESTART,
-        ESTRPIPE        = libc::ESTRPIPE,
-        EUSERS          = libc::EUSERS,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EAGAIN = libc::EAGAIN,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EDEADLK = libc::EDEADLK,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        ELOOP = libc::ELOOP,
+        ENOMSG = libc::ENOMSG,
+        EIDRM = libc::EIDRM,
+        ECHRNG = libc::ECHRNG,
+        EL2NSYNC = libc::EL2NSYNC,
+        EL3HLT = libc::EL3HLT,
+        EL3RST = libc::EL3RST,
+        ELNRNG = libc::ELNRNG,
+        EUNATCH = libc::EUNATCH,
+        ENOCSI = libc::ENOCSI,
+        EL2HLT = libc::EL2HLT,
+        EBADE = libc::EBADE,
+        EBADR = libc::EBADR,
+        EXFULL = libc::EXFULL,
+        ENOANO = libc::ENOANO,
+        EBADRQC = libc::EBADRQC,
+        EBADSLT = libc::EBADSLT,
+        EBFONT = libc::EBFONT,
+        ENOSTR = libc::ENOSTR,
+        ENODATA = libc::ENODATA,
+        ETIME = libc::ETIME,
+        ENOSR = libc::ENOSR,
+        ENONET = libc::ENONET,
+        ENOPKG = libc::ENOPKG,
+        EREMOTE = libc::EREMOTE,
+        ENOLINK = libc::ENOLINK,
+        EADV = libc::EADV,
+        ESRMNT = libc::ESRMNT,
+        ECOMM = libc::ECOMM,
+        EPROTO = libc::EPROTO,
+        EMULTIHOP = libc::EMULTIHOP,
+        EDOTDOT = libc::EDOTDOT,
+        EBADMSG = libc::EBADMSG,
+        EOVERFLOW = libc::EOVERFLOW,
+        ENOTUNIQ = libc::ENOTUNIQ,
+        EBADFD = libc::EBADFD,
+        EREMCHG = libc::EREMCHG,
+        ELIBACC = libc::ELIBACC,
+        ELIBBAD = libc::ELIBBAD,
+        ELIBSCN = libc::ELIBSCN,
+        ELIBMAX = libc::ELIBMAX,
+        ELIBEXEC = libc::ELIBEXEC,
+        EILSEQ = libc::EILSEQ,
+        ERESTART = libc::ERESTART,
+        ESTRPIPE = libc::ESTRPIPE,
+        EUSERS = libc::EUSERS,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        EOPNOTSUPP      = libc::EOPNOTSUPP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        EALREADY        = libc::EALREADY,
-        EINPROGRESS     = libc::EINPROGRESS,
-        ESTALE          = libc::ESTALE,
-        EUCLEAN         = libc::EUCLEAN,
-        ENOTNAM         = libc::ENOTNAM,
-        ENAVAIL         = libc::ENAVAIL,
-        EISNAM          = libc::EISNAM,
-        EREMOTEIO       = libc::EREMOTEIO,
-        EDQUOT          = libc::EDQUOT,
-        ENOMEDIUM       = libc::ENOMEDIUM,
-        EMEDIUMTYPE     = libc::EMEDIUMTYPE,
-        ECANCELED       = libc::ECANCELED,
-        ENOKEY          = libc::ENOKEY,
-        EKEYEXPIRED     = libc::EKEYEXPIRED,
-        EKEYREVOKED     = libc::EKEYREVOKED,
-        EKEYREJECTED    = libc::EKEYREJECTED,
-        EOWNERDEAD      = libc::EOWNERDEAD,
+        EOPNOTSUPP = libc::EOPNOTSUPP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        EALREADY = libc::EALREADY,
+        EINPROGRESS = libc::EINPROGRESS,
+        ESTALE = libc::ESTALE,
+        EUCLEAN = libc::EUCLEAN,
+        ENOTNAM = libc::ENOTNAM,
+        ENAVAIL = libc::ENAVAIL,
+        EISNAM = libc::EISNAM,
+        EREMOTEIO = libc::EREMOTEIO,
+        EDQUOT = libc::EDQUOT,
+        ENOMEDIUM = libc::ENOMEDIUM,
+        EMEDIUMTYPE = libc::EMEDIUMTYPE,
+        ECANCELED = libc::ECANCELED,
+        ENOKEY = libc::ENOKEY,
+        EKEYEXPIRED = libc::EKEYEXPIRED,
+        EKEYREVOKED = libc::EKEYREVOKED,
+        EKEYREJECTED = libc::EKEYREJECTED,
+        EOWNERDEAD = libc::EOWNERDEAD,
         ENOTRECOVERABLE = libc::ENOTRECOVERABLE,
-        #[cfg(not(any(target_os = "android", target_arch="mips")))]
-        ERFKILL         = libc::ERFKILL,
-        #[cfg(not(any(target_os = "android", target_arch="mips")))]
-        EHWPOISON       = libc::EHWPOISON,
+        #[cfg(not(any(target_os = "android", target_arch = "mips")))]
+        ERFKILL = libc::ERFKILL,
+        #[cfg(not(any(target_os = "android", target_arch = "mips")))]
+        EHWPOISON = libc::EHWPOISON,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EDEADLOCK instead"
-    )]
-    pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ENOTSUP instead"
-    )]
-    pub const ENOTSUP:  Errno = Errno::EOPNOTSUPP;
-
     impl Errno {
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-        pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-        pub const ENOTSUP:     Errno = Errno::EOPNOTSUPP;
+        pub const EDEADLOCK: Errno = Errno::EDEADLK;
+        pub const ENOTSUP: Errno = Errno::EOPNOTSUPP;
     }
 
     pub const fn from_i32(e: i32) -> Errno {
@@ -1063,11 +1396,11 @@ mod consts {
             libc::EKEYREJECTED => EKEYREJECTED,
             libc::EOWNERDEAD => EOWNERDEAD,
             libc::ENOTRECOVERABLE => ENOTRECOVERABLE,
-            #[cfg(not(any(target_os = "android", target_arch="mips")))]
+            #[cfg(not(any(target_os = "android", target_arch = "mips")))]
             libc::ERFKILL => ERFKILL,
-            #[cfg(not(any(target_os = "android", target_arch="mips")))]
+            #[cfg(not(any(target_os = "android", target_arch = "mips")))]
             libc::EHWPOISON => EHWPOISON,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
@@ -1078,135 +1411,119 @@ mod consts {
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EDEADLK         = libc::EDEADLK,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EAGAIN          = libc::EAGAIN,
-        EINPROGRESS     = libc::EINPROGRESS,
-        EALREADY        = libc::EALREADY,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        ENOTSUP         = libc::ENOTSUP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        ELOOP           = libc::ELOOP,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        EPROCLIM        = libc::EPROCLIM,
-        EUSERS          = libc::EUSERS,
-        EDQUOT          = libc::EDQUOT,
-        ESTALE          = libc::ESTALE,
-        EREMOTE         = libc::EREMOTE,
-        EBADRPC         = libc::EBADRPC,
-        ERPCMISMATCH    = libc::ERPCMISMATCH,
-        EPROGUNAVAIL    = libc::EPROGUNAVAIL,
-        EPROGMISMATCH   = libc::EPROGMISMATCH,
-        EPROCUNAVAIL    = libc::EPROCUNAVAIL,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        EFTYPE          = libc::EFTYPE,
-        EAUTH           = libc::EAUTH,
-        ENEEDAUTH       = libc::ENEEDAUTH,
-        EPWROFF         = libc::EPWROFF,
-        EDEVERR         = libc::EDEVERR,
-        EOVERFLOW       = libc::EOVERFLOW,
-        EBADEXEC        = libc::EBADEXEC,
-        EBADARCH        = libc::EBADARCH,
-        ESHLIBVERS      = libc::ESHLIBVERS,
-        EBADMACHO       = libc::EBADMACHO,
-        ECANCELED       = libc::ECANCELED,
-        EIDRM           = libc::EIDRM,
-        ENOMSG          = libc::ENOMSG,
-        EILSEQ          = libc::EILSEQ,
-        ENOATTR         = libc::ENOATTR,
-        EBADMSG         = libc::EBADMSG,
-        EMULTIHOP       = libc::EMULTIHOP,
-        ENODATA         = libc::ENODATA,
-        ENOLINK         = libc::ENOLINK,
-        ENOSR           = libc::ENOSR,
-        ENOSTR          = libc::ENOSTR,
-        EPROTO          = libc::EPROTO,
-        ETIME           = libc::ETIME,
-        EOPNOTSUPP      = libc::EOPNOTSUPP,
-        ENOPOLICY       = libc::ENOPOLICY,
+        ENOTSUP = libc::ENOTSUP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EPROCLIM = libc::EPROCLIM,
+        EUSERS = libc::EUSERS,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        EREMOTE = libc::EREMOTE,
+        EBADRPC = libc::EBADRPC,
+        ERPCMISMATCH = libc::ERPCMISMATCH,
+        EPROGUNAVAIL = libc::EPROGUNAVAIL,
+        EPROGMISMATCH = libc::EPROGMISMATCH,
+        EPROCUNAVAIL = libc::EPROCUNAVAIL,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EFTYPE = libc::EFTYPE,
+        EAUTH = libc::EAUTH,
+        ENEEDAUTH = libc::ENEEDAUTH,
+        EPWROFF = libc::EPWROFF,
+        EDEVERR = libc::EDEVERR,
+        EOVERFLOW = libc::EOVERFLOW,
+        EBADEXEC = libc::EBADEXEC,
+        EBADARCH = libc::EBADARCH,
+        ESHLIBVERS = libc::ESHLIBVERS,
+        EBADMACHO = libc::EBADMACHO,
+        ECANCELED = libc::ECANCELED,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        EILSEQ = libc::EILSEQ,
+        ENOATTR = libc::ENOATTR,
+        EBADMSG = libc::EBADMSG,
+        EMULTIHOP = libc::EMULTIHOP,
+        ENODATA = libc::ENODATA,
+        ENOLINK = libc::ENOLINK,
+        ENOSR = libc::ENOSR,
+        ENOSTR = libc::ENOSTR,
+        EPROTO = libc::EPROTO,
+        ETIME = libc::ETIME,
+        EOPNOTSUPP = libc::EOPNOTSUPP,
+        ENOPOLICY = libc::ENOPOLICY,
         ENOTRECOVERABLE = libc::ENOTRECOVERABLE,
-        EOWNERDEAD      = libc::EOWNERDEAD,
-        EQFULL          = libc::EQFULL,
+        EOWNERDEAD = libc::EOWNERDEAD,
+        EQFULL = libc::EQFULL,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST:  Errno = Errno::EQFULL;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EDEADLOCK instead"
-    )]
-    pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::EQFULL;
+        pub const ELAST: Errno = Errno::EQFULL;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-        pub const EDEADLOCK:   Errno = Errno::EDEADLK;
+        pub const EDEADLOCK: Errno = Errno::EDEADLK;
     }
 
     pub const fn from_i32(e: i32) -> Errno {
@@ -1319,7 +1636,7 @@ mod consts {
             libc::ENOTRECOVERABLE => ENOTRECOVERABLE,
             libc::EOWNERDEAD => EOWNERDEAD,
             libc::EQFULL => EQFULL,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
@@ -1330,131 +1647,110 @@ mod consts {
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EDEADLK         = libc::EDEADLK,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EAGAIN          = libc::EAGAIN,
-        EINPROGRESS     = libc::EINPROGRESS,
-        EALREADY        = libc::EALREADY,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        ENOTSUP         = libc::ENOTSUP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        ELOOP           = libc::ELOOP,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        EPROCLIM        = libc::EPROCLIM,
-        EUSERS          = libc::EUSERS,
-        EDQUOT          = libc::EDQUOT,
-        ESTALE          = libc::ESTALE,
-        EREMOTE         = libc::EREMOTE,
-        EBADRPC         = libc::EBADRPC,
-        ERPCMISMATCH    = libc::ERPCMISMATCH,
-        EPROGUNAVAIL    = libc::EPROGUNAVAIL,
-        EPROGMISMATCH   = libc::EPROGMISMATCH,
-        EPROCUNAVAIL    = libc::EPROCUNAVAIL,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        EFTYPE          = libc::EFTYPE,
-        EAUTH           = libc::EAUTH,
-        ENEEDAUTH       = libc::ENEEDAUTH,
-        EIDRM           = libc::EIDRM,
-        ENOMSG          = libc::ENOMSG,
-        EOVERFLOW       = libc::EOVERFLOW,
-        ECANCELED       = libc::ECANCELED,
-        EILSEQ          = libc::EILSEQ,
-        ENOATTR         = libc::ENOATTR,
-        EDOOFUS         = libc::EDOOFUS,
-        EBADMSG         = libc::EBADMSG,
-        EMULTIHOP       = libc::EMULTIHOP,
-        ENOLINK         = libc::ENOLINK,
-        EPROTO          = libc::EPROTO,
-        ENOTCAPABLE     = libc::ENOTCAPABLE,
-        ECAPMODE        = libc::ECAPMODE,
+        ENOTSUP = libc::ENOTSUP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EPROCLIM = libc::EPROCLIM,
+        EUSERS = libc::EUSERS,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        EREMOTE = libc::EREMOTE,
+        EBADRPC = libc::EBADRPC,
+        ERPCMISMATCH = libc::ERPCMISMATCH,
+        EPROGUNAVAIL = libc::EPROGUNAVAIL,
+        EPROGMISMATCH = libc::EPROGMISMATCH,
+        EPROCUNAVAIL = libc::EPROCUNAVAIL,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EFTYPE = libc::EFTYPE,
+        EAUTH = libc::EAUTH,
+        ENEEDAUTH = libc::ENEEDAUTH,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        EOVERFLOW = libc::EOVERFLOW,
+        ECANCELED = libc::ECANCELED,
+        EILSEQ = libc::EILSEQ,
+        ENOATTR = libc::ENOATTR,
+        EDOOFUS = libc::EDOOFUS,
+        EBADMSG = libc::EBADMSG,
+        EMULTIHOP = libc::EMULTIHOP,
+        ENOLINK = libc::ENOLINK,
+        EPROTO = libc::EPROTO,
+        ENOTCAPABLE = libc::ENOTCAPABLE,
+        ECAPMODE = libc::ECAPMODE,
         ENOTRECOVERABLE = libc::ENOTRECOVERABLE,
-        EOWNERDEAD      = libc::EOWNERDEAD,
+        EOWNERDEAD = libc::EOWNERDEAD,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST: Errno       = Errno::EOWNERDEAD;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EDEADLOCK instead"
-    )]
-    pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EOPNOTSUPP instead"
-    )]
-    pub const EOPNOTSUPP:  Errno = Errno::ENOTSUP;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::EOWNERDEAD;
+        pub const ELAST: Errno = Errno::EOWNERDEAD;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-        pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-        pub const EOPNOTSUPP:  Errno = Errno::ENOTSUP;
+        pub const EDEADLOCK: Errno = Errno::EDEADLK;
+        pub const EOPNOTSUPP: Errno = Errno::ENOTSUP;
     }
 
     pub const fn from_i32(e: i32) -> Errno {
@@ -1557,141 +1853,121 @@ mod consts {
             libc::ECAPMODE => ECAPMODE,
             libc::ENOTRECOVERABLE => ENOTRECOVERABLE,
             libc::EOWNERDEAD => EOWNERDEAD,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
 
-
 #[cfg(target_os = "dragonfly")]
 mod consts {
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EDEADLK         = libc::EDEADLK,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EAGAIN          = libc::EAGAIN,
-        EINPROGRESS     = libc::EINPROGRESS,
-        EALREADY        = libc::EALREADY,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        ENOTSUP         = libc::ENOTSUP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        ELOOP           = libc::ELOOP,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        EPROCLIM        = libc::EPROCLIM,
-        EUSERS          = libc::EUSERS,
-        EDQUOT          = libc::EDQUOT,
-        ESTALE          = libc::ESTALE,
-        EREMOTE         = libc::EREMOTE,
-        EBADRPC         = libc::EBADRPC,
-        ERPCMISMATCH    = libc::ERPCMISMATCH,
-        EPROGUNAVAIL    = libc::EPROGUNAVAIL,
-        EPROGMISMATCH   = libc::EPROGMISMATCH,
-        EPROCUNAVAIL    = libc::EPROCUNAVAIL,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        EFTYPE          = libc::EFTYPE,
-        EAUTH           = libc::EAUTH,
-        ENEEDAUTH       = libc::ENEEDAUTH,
-        EIDRM           = libc::EIDRM,
-        ENOMSG          = libc::ENOMSG,
-        EOVERFLOW       = libc::EOVERFLOW,
-        ECANCELED       = libc::ECANCELED,
-        EILSEQ          = libc::EILSEQ,
-        ENOATTR         = libc::ENOATTR,
-        EDOOFUS         = libc::EDOOFUS,
-        EBADMSG         = libc::EBADMSG,
-        EMULTIHOP       = libc::EMULTIHOP,
-        ENOLINK         = libc::ENOLINK,
-        EPROTO          = libc::EPROTO,
-        ENOMEDIUM       = libc::ENOMEDIUM,
-        EASYNC          = libc::EASYNC,
+        ENOTSUP = libc::ENOTSUP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EPROCLIM = libc::EPROCLIM,
+        EUSERS = libc::EUSERS,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        EREMOTE = libc::EREMOTE,
+        EBADRPC = libc::EBADRPC,
+        ERPCMISMATCH = libc::ERPCMISMATCH,
+        EPROGUNAVAIL = libc::EPROGUNAVAIL,
+        EPROGMISMATCH = libc::EPROGMISMATCH,
+        EPROCUNAVAIL = libc::EPROCUNAVAIL,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EFTYPE = libc::EFTYPE,
+        EAUTH = libc::EAUTH,
+        ENEEDAUTH = libc::ENEEDAUTH,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        EOVERFLOW = libc::EOVERFLOW,
+        ECANCELED = libc::ECANCELED,
+        EILSEQ = libc::EILSEQ,
+        ENOATTR = libc::ENOATTR,
+        EDOOFUS = libc::EDOOFUS,
+        EBADMSG = libc::EBADMSG,
+        EMULTIHOP = libc::EMULTIHOP,
+        ENOLINK = libc::ENOLINK,
+        EPROTO = libc::EPROTO,
+        ENOMEDIUM = libc::ENOMEDIUM,
+        ENOTRECOVERABLE = libc::ENOTRECOVERABLE,
+        EOWNERDEAD = libc::EOWNERDEAD,
+        EASYNC = libc::EASYNC,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST: Errno       = Errno::EASYNC;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EDEADLOCK instead"
-    )]
-    pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EOPNOTSUPP instead"
-    )]
-    pub const EOPNOTSUPP:  Errno = Errno::ENOTSUP;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::EASYNC;
+        pub const ELAST: Errno = Errno::EASYNC;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-        pub const EDEADLOCK:   Errno = Errno::EDEADLK;
-        pub const EOPNOTSUPP:  Errno = Errno::ENOTSUP;
+        pub const EDEADLOCK: Errno = Errno::EDEADLK;
+        pub const EOPNOTSUPP: Errno = Errno::ENOTSUP;
     }
 
     pub const fn from_i32(e: i32) -> Errno {
@@ -1718,7 +1994,7 @@ mod consts {
             libc::EXDEV => EXDEV,
             libc::ENODEV => ENODEV,
             libc::ENOTDIR => ENOTDIR,
-            libc::EISDIR=> EISDIR,
+            libc::EISDIR => EISDIR,
             libc::EINVAL => EINVAL,
             libc::ENFILE => ENFILE,
             libc::EMFILE => EMFILE,
@@ -1792,129 +2068,117 @@ mod consts {
             libc::EPROTO => EPROTO,
             libc::ENOMEDIUM => ENOMEDIUM,
             libc::EASYNC => EASYNC,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
 
-
 #[cfg(target_os = "openbsd")]
 mod consts {
     #[derive(Clone, Copy, Debug, Eq, PartialEq)]
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EDEADLK         = libc::EDEADLK,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EAGAIN          = libc::EAGAIN,
-        EINPROGRESS     = libc::EINPROGRESS,
-        EALREADY        = libc::EALREADY,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        EOPNOTSUPP      = libc::EOPNOTSUPP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        ELOOP           = libc::ELOOP,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        EPROCLIM        = libc::EPROCLIM,
-        EUSERS          = libc::EUSERS,
-        EDQUOT          = libc::EDQUOT,
-        ESTALE          = libc::ESTALE,
-        EREMOTE         = libc::EREMOTE,
-        EBADRPC         = libc::EBADRPC,
-        ERPCMISMATCH    = libc::ERPCMISMATCH,
-        EPROGUNAVAIL    = libc::EPROGUNAVAIL,
-        EPROGMISMATCH   = libc::EPROGMISMATCH,
-        EPROCUNAVAIL    = libc::EPROCUNAVAIL,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        EFTYPE          = libc::EFTYPE,
-        EAUTH           = libc::EAUTH,
-        ENEEDAUTH       = libc::ENEEDAUTH,
-        EIPSEC          = libc::EIPSEC,
-        ENOATTR         = libc::ENOATTR,
-        EILSEQ          = libc::EILSEQ,
-        ENOMEDIUM       = libc::ENOMEDIUM,
-        EMEDIUMTYPE     = libc::EMEDIUMTYPE,
-        EOVERFLOW       = libc::EOVERFLOW,
-        ECANCELED       = libc::ECANCELED,
-        EIDRM           = libc::EIDRM,
-        ENOMSG          = libc::ENOMSG,
-        ENOTSUP         = libc::ENOTSUP,
-        EBADMSG         = libc::EBADMSG,
+        EOPNOTSUPP = libc::EOPNOTSUPP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EPROCLIM = libc::EPROCLIM,
+        EUSERS = libc::EUSERS,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        EREMOTE = libc::EREMOTE,
+        EBADRPC = libc::EBADRPC,
+        ERPCMISMATCH = libc::ERPCMISMATCH,
+        EPROGUNAVAIL = libc::EPROGUNAVAIL,
+        EPROGMISMATCH = libc::EPROGMISMATCH,
+        EPROCUNAVAIL = libc::EPROCUNAVAIL,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EFTYPE = libc::EFTYPE,
+        EAUTH = libc::EAUTH,
+        ENEEDAUTH = libc::ENEEDAUTH,
+        EIPSEC = libc::EIPSEC,
+        ENOATTR = libc::ENOATTR,
+        EILSEQ = libc::EILSEQ,
+        ENOMEDIUM = libc::ENOMEDIUM,
+        EMEDIUMTYPE = libc::EMEDIUMTYPE,
+        EOVERFLOW = libc::EOVERFLOW,
+        ECANCELED = libc::ECANCELED,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        ENOTSUP = libc::ENOTSUP,
+        EBADMSG = libc::EBADMSG,
         ENOTRECOVERABLE = libc::ENOTRECOVERABLE,
-        EOWNERDEAD      = libc::EOWNERDEAD,
-        EPROTO          = libc::EPROTO,
+        EOWNERDEAD = libc::EOWNERDEAD,
+        EPROTO = libc::EPROTO,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST: Errno       = Errno::ENOTSUP;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::ENOTSUP;
+        pub const ELAST: Errno = Errno::ENOTSUP;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
     }
 
@@ -2017,7 +2281,7 @@ mod consts {
             libc::ENOTRECOVERABLE => ENOTRECOVERABLE,
             libc::EOWNERDEAD => EOWNERDEAD,
             libc::EPROTO => EPROTO,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
@@ -2028,118 +2292,107 @@ mod consts {
     #[repr(i32)]
     #[non_exhaustive]
     pub enum Errno {
-        UnknownErrno    = 0,
-        EPERM           = libc::EPERM,
-        ENOENT          = libc::ENOENT,
-        ESRCH           = libc::ESRCH,
-        EINTR           = libc::EINTR,
-        EIO             = libc::EIO,
-        ENXIO           = libc::ENXIO,
-        E2BIG           = libc::E2BIG,
-        ENOEXEC         = libc::ENOEXEC,
-        EBADF           = libc::EBADF,
-        ECHILD          = libc::ECHILD,
-        EDEADLK         = libc::EDEADLK,
-        ENOMEM          = libc::ENOMEM,
-        EACCES          = libc::EACCES,
-        EFAULT          = libc::EFAULT,
-        ENOTBLK         = libc::ENOTBLK,
-        EBUSY           = libc::EBUSY,
-        EEXIST          = libc::EEXIST,
-        EXDEV           = libc::EXDEV,
-        ENODEV          = libc::ENODEV,
-        ENOTDIR         = libc::ENOTDIR,
-        EISDIR          = libc::EISDIR,
-        EINVAL          = libc::EINVAL,
-        ENFILE          = libc::ENFILE,
-        EMFILE          = libc::EMFILE,
-        ENOTTY          = libc::ENOTTY,
-        ETXTBSY         = libc::ETXTBSY,
-        EFBIG           = libc::EFBIG,
-        ENOSPC          = libc::ENOSPC,
-        ESPIPE          = libc::ESPIPE,
-        EROFS           = libc::EROFS,
-        EMLINK          = libc::EMLINK,
-        EPIPE           = libc::EPIPE,
-        EDOM            = libc::EDOM,
-        ERANGE          = libc::ERANGE,
-        EAGAIN          = libc::EAGAIN,
-        EINPROGRESS     = libc::EINPROGRESS,
-        EALREADY        = libc::EALREADY,
-        ENOTSOCK        = libc::ENOTSOCK,
-        EDESTADDRREQ    = libc::EDESTADDRREQ,
-        EMSGSIZE        = libc::EMSGSIZE,
-        EPROTOTYPE      = libc::EPROTOTYPE,
-        ENOPROTOOPT     = libc::ENOPROTOOPT,
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        ENOTBLK = libc::ENOTBLK,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
         EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
         ESOCKTNOSUPPORT = libc::ESOCKTNOSUPPORT,
-        EOPNOTSUPP      = libc::EOPNOTSUPP,
-        EPFNOSUPPORT    = libc::EPFNOSUPPORT,
-        EAFNOSUPPORT    = libc::EAFNOSUPPORT,
-        EADDRINUSE      = libc::EADDRINUSE,
-        EADDRNOTAVAIL   = libc::EADDRNOTAVAIL,
-        ENETDOWN        = libc::ENETDOWN,
-        ENETUNREACH     = libc::ENETUNREACH,
-        ENETRESET       = libc::ENETRESET,
-        ECONNABORTED    = libc::ECONNABORTED,
-        ECONNRESET      = libc::ECONNRESET,
-        ENOBUFS         = libc::ENOBUFS,
-        EISCONN         = libc::EISCONN,
-        ENOTCONN        = libc::ENOTCONN,
-        ESHUTDOWN       = libc::ESHUTDOWN,
-        ETOOMANYREFS    = libc::ETOOMANYREFS,
-        ETIMEDOUT       = libc::ETIMEDOUT,
-        ECONNREFUSED    = libc::ECONNREFUSED,
-        ELOOP           = libc::ELOOP,
-        ENAMETOOLONG    = libc::ENAMETOOLONG,
-        EHOSTDOWN       = libc::EHOSTDOWN,
-        EHOSTUNREACH    = libc::EHOSTUNREACH,
-        ENOTEMPTY       = libc::ENOTEMPTY,
-        EPROCLIM        = libc::EPROCLIM,
-        EUSERS          = libc::EUSERS,
-        EDQUOT          = libc::EDQUOT,
-        ESTALE          = libc::ESTALE,
-        EREMOTE         = libc::EREMOTE,
-        EBADRPC         = libc::EBADRPC,
-        ERPCMISMATCH    = libc::ERPCMISMATCH,
-        EPROGUNAVAIL    = libc::EPROGUNAVAIL,
-        EPROGMISMATCH   = libc::EPROGMISMATCH,
-        EPROCUNAVAIL    = libc::EPROCUNAVAIL,
-        ENOLCK          = libc::ENOLCK,
-        ENOSYS          = libc::ENOSYS,
-        EFTYPE          = libc::EFTYPE,
-        EAUTH           = libc::EAUTH,
-        ENEEDAUTH       = libc::ENEEDAUTH,
-        EIDRM           = libc::EIDRM,
-        ENOMSG          = libc::ENOMSG,
-        EOVERFLOW       = libc::EOVERFLOW,
-        EILSEQ          = libc::EILSEQ,
-        ENOTSUP         = libc::ENOTSUP,
-        ECANCELED       = libc::ECANCELED,
-        EBADMSG         = libc::EBADMSG,
-        ENODATA         = libc::ENODATA,
-        ENOSR           = libc::ENOSR,
-        ENOSTR          = libc::ENOSTR,
-        ETIME           = libc::ETIME,
-        ENOATTR         = libc::ENOATTR,
-        EMULTIHOP       = libc::EMULTIHOP,
-        ENOLINK         = libc::ENOLINK,
-        EPROTO          = libc::EPROTO,
+        EOPNOTSUPP = libc::EOPNOTSUPP,
+        EPFNOSUPPORT = libc::EPFNOSUPPORT,
+        EAFNOSUPPORT = libc::EAFNOSUPPORT,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETOOMANYREFS = libc::ETOOMANYREFS,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EPROCLIM = libc::EPROCLIM,
+        EUSERS = libc::EUSERS,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        EREMOTE = libc::EREMOTE,
+        EBADRPC = libc::EBADRPC,
+        ERPCMISMATCH = libc::ERPCMISMATCH,
+        EPROGUNAVAIL = libc::EPROGUNAVAIL,
+        EPROGMISMATCH = libc::EPROGMISMATCH,
+        EPROCUNAVAIL = libc::EPROCUNAVAIL,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EFTYPE = libc::EFTYPE,
+        EAUTH = libc::EAUTH,
+        ENEEDAUTH = libc::ENEEDAUTH,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        EOVERFLOW = libc::EOVERFLOW,
+        EILSEQ = libc::EILSEQ,
+        ENOTSUP = libc::ENOTSUP,
+        ECANCELED = libc::ECANCELED,
+        EBADMSG = libc::EBADMSG,
+        ENODATA = libc::ENODATA,
+        ENOSR = libc::ENOSR,
+        ENOSTR = libc::ENOSTR,
+        ETIME = libc::ETIME,
+        ENOATTR = libc::ENOATTR,
+        EMULTIHOP = libc::EMULTIHOP,
+        ENOLINK = libc::ENOLINK,
+        EPROTO = libc::EPROTO,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST: Errno       = Errno::ENOTSUP;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::ENOTSUP;
+        pub const ELAST: Errno = Errno::ENOTSUP;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
     }
 
@@ -2243,7 +2496,7 @@ mod consts {
             libc::EMULTIHOP => EMULTIHOP,
             libc::ENOLINK => ENOLINK,
             libc::EPROTO => EPROTO,
-            _   => UnknownErrno,
+            _ => UnknownErrno,
         }
     }
 }
@@ -2342,12 +2595,6 @@ mod consts {
         EPROTO = libc::EPROTO,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-
     impl Errno {
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
     }
@@ -2576,19 +2823,8 @@ mod consts {
         ESTALE = libc::ESTALE,
     }
 
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::ELAST instead"
-    )]
-    pub const ELAST: Errno = Errno::ELAST;
-    #[deprecated(
-        since = "0.22.1",
-        note = "use nix::errno::Errno::EWOULDBLOCK instead"
-    )]
-    pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
-
     impl Errno {
-        pub const ELAST: Errno       = Errno::ESTALE;
+        pub const ELAST: Errno = Errno::ESTALE;
         pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
     }
 
@@ -2721,3 +2957,177 @@ mod consts {
         }
     }
 }
+
+#[cfg(target_os = "haiku")]
+mod consts {
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    #[repr(i32)]
+    #[non_exhaustive]
+    pub enum Errno {
+        UnknownErrno = 0,
+        EPERM = libc::EPERM,
+        ENOENT = libc::ENOENT,
+        ESRCH = libc::ESRCH,
+        EINTR = libc::EINTR,
+        EIO = libc::EIO,
+        ENXIO = libc::ENXIO,
+        E2BIG = libc::E2BIG,
+        ENOEXEC = libc::ENOEXEC,
+        EBADF = libc::EBADF,
+        ECHILD = libc::ECHILD,
+        EDEADLK = libc::EDEADLK,
+        ENOMEM = libc::ENOMEM,
+        EACCES = libc::EACCES,
+        EFAULT = libc::EFAULT,
+        EBUSY = libc::EBUSY,
+        EEXIST = libc::EEXIST,
+        EXDEV = libc::EXDEV,
+        ENODEV = libc::ENODEV,
+        ENOTDIR = libc::ENOTDIR,
+        EISDIR = libc::EISDIR,
+        EINVAL = libc::EINVAL,
+        ENFILE = libc::ENFILE,
+        EMFILE = libc::EMFILE,
+        ENOTTY = libc::ENOTTY,
+        ETXTBSY = libc::ETXTBSY,
+        EFBIG = libc::EFBIG,
+        ENOSPC = libc::ENOSPC,
+        ESPIPE = libc::ESPIPE,
+        EROFS = libc::EROFS,
+        EMLINK = libc::EMLINK,
+        EPIPE = libc::EPIPE,
+        EDOM = libc::EDOM,
+        ERANGE = libc::ERANGE,
+        EAGAIN = libc::EAGAIN,
+        EINPROGRESS = libc::EINPROGRESS,
+        EALREADY = libc::EALREADY,
+        ENOTSOCK = libc::ENOTSOCK,
+        EDESTADDRREQ = libc::EDESTADDRREQ,
+        EMSGSIZE = libc::EMSGSIZE,
+        EPROTOTYPE = libc::EPROTOTYPE,
+        ENOPROTOOPT = libc::ENOPROTOOPT,
+        EPROTONOSUPPORT = libc::EPROTONOSUPPORT,
+        ENOTSUP = libc::ENOTSUP,
+        EADDRINUSE = libc::EADDRINUSE,
+        EADDRNOTAVAIL = libc::EADDRNOTAVAIL,
+        ENETDOWN = libc::ENETDOWN,
+        ENETUNREACH = libc::ENETUNREACH,
+        ENETRESET = libc::ENETRESET,
+        ECONNABORTED = libc::ECONNABORTED,
+        ECONNRESET = libc::ECONNRESET,
+        ENOBUFS = libc::ENOBUFS,
+        EISCONN = libc::EISCONN,
+        ENOTCONN = libc::ENOTCONN,
+        ESHUTDOWN = libc::ESHUTDOWN,
+        ETIMEDOUT = libc::ETIMEDOUT,
+        ECONNREFUSED = libc::ECONNREFUSED,
+        ELOOP = libc::ELOOP,
+        ENAMETOOLONG = libc::ENAMETOOLONG,
+        EHOSTDOWN = libc::EHOSTDOWN,
+        EHOSTUNREACH = libc::EHOSTUNREACH,
+        ENOTEMPTY = libc::ENOTEMPTY,
+        EDQUOT = libc::EDQUOT,
+        ESTALE = libc::ESTALE,
+        ENOLCK = libc::ENOLCK,
+        ENOSYS = libc::ENOSYS,
+        EIDRM = libc::EIDRM,
+        ENOMSG = libc::ENOMSG,
+        EOVERFLOW = libc::EOVERFLOW,
+        ECANCELED = libc::ECANCELED,
+        EILSEQ = libc::EILSEQ,
+        ENOATTR = libc::ENOATTR,
+        EBADMSG = libc::EBADMSG,
+        EMULTIHOP = libc::EMULTIHOP,
+        ENOLINK = libc::ENOLINK,
+        EPROTO = libc::EPROTO,
+    }
+
+    impl Errno {
+        pub const EWOULDBLOCK: Errno = Errno::EAGAIN;
+        pub const EDEADLOCK: Errno = Errno::EDEADLK;
+        pub const EOPNOTSUPP: Errno = Errno::ENOTSUP;
+    }
+
+    pub const fn from_i32(e: i32) -> Errno {
+        use self::Errno::*;
+
+        match e {
+            libc::EPERM => EPERM,
+            libc::ENOENT => ENOENT,
+            libc::ESRCH => ESRCH,
+            libc::EINTR => EINTR,
+            libc::EIO => EIO,
+            libc::ENXIO => ENXIO,
+            libc::E2BIG => E2BIG,
+            libc::ENOEXEC => ENOEXEC,
+            libc::EBADF => EBADF,
+            libc::ECHILD => ECHILD,
+            libc::EDEADLK => EDEADLK,
+            libc::ENOMEM => ENOMEM,
+            libc::EACCES => EACCES,
+            libc::EFAULT => EFAULT,
+            libc::EBUSY => EBUSY,
+            libc::EEXIST => EEXIST,
+            libc::EXDEV => EXDEV,
+            libc::ENODEV => ENODEV,
+            libc::ENOTDIR => ENOTDIR,
+            libc::EISDIR => EISDIR,
+            libc::EINVAL => EINVAL,
+            libc::ENFILE => ENFILE,
+            libc::EMFILE => EMFILE,
+            libc::ENOTTY => ENOTTY,
+            libc::ETXTBSY => ETXTBSY,
+            libc::EFBIG => EFBIG,
+            libc::ENOSPC => ENOSPC,
+            libc::ESPIPE => ESPIPE,
+            libc::EROFS => EROFS,
+            libc::EMLINK => EMLINK,
+            libc::EPIPE => EPIPE,
+            libc::EDOM => EDOM,
+            libc::ERANGE => ERANGE,
+            libc::EAGAIN => EAGAIN,
+            libc::EINPROGRESS => EINPROGRESS,
+            libc::EALREADY => EALREADY,
+            libc::ENOTSOCK => ENOTSOCK,
+            libc::EDESTADDRREQ => EDESTADDRREQ,
+            libc::EMSGSIZE => EMSGSIZE,
+            libc::EPROTOTYPE => EPROTOTYPE,
+            libc::ENOPROTOOPT => ENOPROTOOPT,
+            libc::EPROTONOSUPPORT => EPROTONOSUPPORT,
+            libc::ENOTSUP => ENOTSUP,
+            libc::EADDRINUSE => EADDRINUSE,
+            libc::EADDRNOTAVAIL => EADDRNOTAVAIL,
+            libc::ENETDOWN => ENETDOWN,
+            libc::ENETUNREACH => ENETUNREACH,
+            libc::ENETRESET => ENETRESET,
+            libc::ECONNABORTED => ECONNABORTED,
+            libc::ECONNRESET => ECONNRESET,
+            libc::ENOBUFS => ENOBUFS,
+            libc::EISCONN => EISCONN,
+            libc::ENOTCONN => ENOTCONN,
+            libc::ESHUTDOWN => ESHUTDOWN,
+            libc::ETIMEDOUT => ETIMEDOUT,
+            libc::ECONNREFUSED => ECONNREFUSED,
+            libc::ELOOP => ELOOP,
+            libc::ENAMETOOLONG => ENAMETOOLONG,
+            libc::EHOSTDOWN => EHOSTDOWN,
+            libc::EHOSTUNREACH => EHOSTUNREACH,
+            libc::ENOTEMPTY => ENOTEMPTY,
+            libc::EDQUOT => EDQUOT,
+            libc::ESTALE => ESTALE,
+            libc::ENOLCK => ENOLCK,
+            libc::ENOSYS => ENOSYS,
+            libc::EIDRM => EIDRM,
+            libc::ENOMSG => ENOMSG,
+            libc::EOVERFLOW => EOVERFLOW,
+            libc::ECANCELED => ECANCELED,
+            libc::EILSEQ => EILSEQ,
+            libc::ENOATTR => ENOATTR,
+            libc::EBADMSG => EBADMSG,
+            libc::EMULTIHOP => EMULTIHOP,
+            libc::ENOLINK => ENOLINK,
+            libc::EPROTO => EPROTO,
+            _ => UnknownErrno,
+        }
+    }
+}
diff --git a/src/fcntl.rs b/src/fcntl.rs
index dd8e59a..6508283 100644
--- a/src/fcntl.rs
+++ b/src/fcntl.rs
@@ -5,27 +5,28 @@ use std::ffi::OsString;
 use std::os::raw;
 use std::os::unix::ffi::OsStringExt;
 use std::os::unix::io::RawFd;
-use crate::sys::stat::Mode;
-use crate::{NixPath, Result};
 
+#[cfg(feature = "fs")]
+use crate::{sys::stat::Mode, NixPath, Result};
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use std::ptr; // For splice and copy_file_range
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::sys::uio::IoVec; // For vmsplice
 
 #[cfg(any(
     target_os = "linux",
     target_os = "android",
     target_os = "emscripten",
     target_os = "fuchsia",
-    any(target_os = "wasi", target_env = "wasi"),
+    target_os = "wasi",
     target_env = "uclibc",
     target_os = "freebsd"
 ))]
-pub use self::posix_fadvise::*;
+#[cfg(feature = "fs")]
+pub use self::posix_fadvise::{posix_fadvise, PosixFadviseAdvice};
 
 #[cfg(not(target_os = "redox"))]
+#[cfg(any(feature = "fs", feature = "process"))]
 libc_bitflags! {
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "fs", feature = "process"))))]
     pub struct AtFlags: c_int {
         AT_REMOVEDIR;
         AT_SYMLINK_FOLLOW;
@@ -39,18 +40,22 @@ libc_bitflags! {
     }
 }
 
+#[cfg(any(feature = "fs", feature = "term"))]
 libc_bitflags!(
     /// Configuration options for opened files.
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "fs", feature = "term"))))]
     pub struct OFlag: c_int {
         /// Mask for the access mode of the file.
         O_ACCMODE;
         /// Use alternate I/O semantics.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_ALT_IO;
         /// Open the file in append-only mode.
         O_APPEND;
         /// Generate a signal when input or output becomes possible.
-        #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+        #[cfg(not(any(target_os = "illumos", target_os = "solaris", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_ASYNC;
         /// Closes the file descriptor once an `execve` call is made.
         ///
@@ -64,9 +69,11 @@ libc_bitflags!(
                   target_os = "freebsd",
                   target_os = "linux",
                   target_os = "netbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_DIRECT;
         /// If the specified path isn't a directory, fail.
         #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_DIRECTORY;
         /// Implicitly follow each `write()` with an `fdatasync()`.
         #[cfg(any(target_os = "android",
@@ -75,11 +82,13 @@ libc_bitflags!(
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_DSYNC;
         /// Error out if a file was not created.
         O_EXCL;
         /// Open for execute only.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_EXEC;
         /// Open with an exclusive file lock.
         #[cfg(any(target_os = "dragonfly",
@@ -89,6 +98,7 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_EXLOCK;
         /// Same as `O_SYNC`.
         #[cfg(any(target_os = "dragonfly",
@@ -99,18 +109,23 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_FSYNC;
         /// Allow files whose sizes can't be represented in an `off_t` to be opened.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_LARGEFILE;
         /// Do not update the file last access time during `read(2)`s.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_NOATIME;
         /// Don't attach the device as the process' controlling terminal.
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_NOCTTY;
         /// Same as `O_NONBLOCK`.
-        #[cfg(not(target_os = "redox"))]
+        #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_NDELAY;
         /// `open()` will fail if the given path is a symbolic link.
         O_NOFOLLOW;
@@ -118,11 +133,13 @@ libc_bitflags!(
         O_NONBLOCK;
         /// Don't deliver `SIGPIPE`.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_NOSIGPIPE;
         /// Obtain a file descriptor for low-level access.
         ///
         /// The file itself is not opened and other file operations will fail.
         #[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_PATH;
         /// Only allow reading.
         ///
@@ -134,9 +151,11 @@ libc_bitflags!(
         O_RDWR;
         /// Similar to `O_DSYNC` but applies to `read`s instead.
         #[cfg(any(target_os = "linux", target_os = "netbsd", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_RSYNC;
         /// Skip search permission checks.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_SEARCH;
         /// Open with a shared file lock.
         #[cfg(any(target_os = "dragonfly",
@@ -146,17 +165,21 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_SHLOCK;
         /// Implicitly follow each `write()` with an `fsync()`.
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_SYNC;
         /// Create an unnamed temporary file.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_TMPFILE;
         /// Truncate an existing regular file to 0 length if it allows writing.
         O_TRUNC;
         /// Restore default TTY attributes.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_TTY_INIT;
         /// Only allow writing.
         ///
@@ -165,6 +188,9 @@ libc_bitflags!(
     }
 );
 
+feature! {
+#![feature = "fs"]
+
 // The conversion is not identical on all operating systems.
 #[allow(clippy::useless_conversion)]
 pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag, mode: Mode) -> Result<RawFd> {
@@ -209,12 +235,12 @@ pub fn renameat<P1: ?Sized + NixPath, P2: ?Sized + NixPath>(
     })??;
     Errno::result(res).map(drop)
 }
+}
 
-#[cfg(all(
-    target_os = "linux",
-    target_env = "gnu",
-))]
+#[cfg(all(target_os = "linux", target_env = "gnu",))]
+#[cfg(feature = "fs")]
 libc_bitflags! {
+    #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
     pub struct RenameFlags: u32 {
         RENAME_EXCHANGE;
         RENAME_NOREPLACE;
@@ -222,6 +248,8 @@ libc_bitflags! {
     }
 }
 
+feature! {
+#![feature = "fs"]
 #[cfg(all(
     target_os = "linux",
     target_env = "gnu",
@@ -348,10 +376,13 @@ pub(crate) fn at_rawfd(fd: Option<RawFd>) -> raw::c_int {
         Some(fd) => fd,
     }
 }
+}
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
+#[cfg(feature = "fs")]
 libc_bitflags!(
     /// Additional flags for file sealing, which allows for limiting operations on a file.
+    #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
     pub struct SealFlag: c_int {
         /// Prevents further calls to `fcntl()` with `F_ADD_SEALS`.
         F_SEAL_SEAL;
@@ -364,14 +395,19 @@ libc_bitflags!(
     }
 );
 
+#[cfg(feature = "fs")]
 libc_bitflags!(
     /// Additional configuration flags for `fcntl`'s `F_SETFD`.
+    #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
     pub struct FdFlag: c_int {
         /// The file descriptor will automatically be closed during a successful `execve(2)`.
         FD_CLOEXEC;
     }
 );
 
+feature! {
+#![feature = "fs"]
+
 #[cfg(not(target_os = "redox"))]
 #[derive(Debug, Eq, Hash, PartialEq)]
 #[non_exhaustive]
@@ -391,9 +427,9 @@ pub enum FcntlArg<'a> {
     F_OFD_SETLKW(&'a libc::flock),
     #[cfg(any(target_os = "linux", target_os = "android"))]
     F_OFD_GETLK(&'a mut libc::flock),
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
     F_ADD_SEALS(SealFlag),
-    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
     F_GET_SEALS,
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     F_FULLFSYNC,
@@ -439,9 +475,9 @@ pub fn fcntl(fd: RawFd, arg: FcntlArg) -> Result<c_int> {
             F_OFD_SETLKW(flock) => libc::fcntl(fd, libc::F_OFD_SETLKW, flock),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             F_OFD_GETLK(flock) => libc::fcntl(fd, libc::F_OFD_GETLK, flock),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
             F_ADD_SEALS(flag) => libc::fcntl(fd, libc::F_ADD_SEALS, flag.bits()),
-            #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
             F_GET_SEALS => libc::fcntl(fd, libc::F_GET_SEALS),
             #[cfg(any(target_os = "macos", target_os = "ios"))]
             F_FULLFSYNC => libc::fcntl(fd, libc::F_FULLFSYNC),
@@ -455,6 +491,7 @@ pub fn fcntl(fd: RawFd, arg: FcntlArg) -> Result<c_int> {
     Errno::result(res)
 }
 
+// TODO: convert to libc_enum
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 #[non_exhaustive]
 pub enum FlockArg {
@@ -483,10 +520,13 @@ pub fn flock(fd: RawFd, arg: FlockArg) -> Result<()> {
 
     Errno::result(res).map(drop)
 }
+}
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(feature = "zerocopy")]
 libc_bitflags! {
     /// Additional flags to `splice` and friends.
+    #[cfg_attr(docsrs, doc(cfg(feature = "zerocopy")))]
     pub struct SpliceFFlags: c_uint {
         /// Request that pages be moved instead of copied.
         ///
@@ -505,6 +545,9 @@ libc_bitflags! {
     }
 }
 
+feature! {
+#![feature = "zerocopy"]
+
 /// Copy a range of data from one file to another
 ///
 /// The `copy_file_range` system call performs an in-kernel copy between
@@ -577,7 +620,12 @@ pub fn tee(fd_in: RawFd, fd_out: RawFd, len: usize, flags: SpliceFFlags) -> Resu
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
-pub fn vmsplice(fd: RawFd, iov: &[IoVec<&[u8]>], flags: SpliceFFlags) -> Result<usize> {
+pub fn vmsplice(
+    fd: RawFd,
+    iov: &[std::io::IoSlice<'_>],
+    flags: SpliceFFlags
+    ) -> Result<usize>
+{
     let ret = unsafe {
         libc::vmsplice(
             fd,
@@ -588,10 +636,13 @@ pub fn vmsplice(fd: RawFd, iov: &[IoVec<&[u8]>], flags: SpliceFFlags) -> Result<
     };
     Errno::result(ret).map(|r| r as usize)
 }
+}
 
 #[cfg(any(target_os = "linux"))]
+#[cfg(feature = "fs")]
 libc_bitflags!(
     /// Mode argument flags for fallocate determining operation performed on a given range.
+    #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
     pub struct FallocateFlags: c_int {
         /// File size is not changed.
         ///
@@ -620,11 +671,15 @@ libc_bitflags!(
     }
 );
 
+feature! {
+#![feature = "fs"]
+
 /// Manipulates file space.
 ///
 /// Allows the caller to directly manipulate the allocated disk space for the
 /// file referred to by fd.
 #[cfg(any(target_os = "linux"))]
+#[cfg(feature = "fs")]
 pub fn fallocate(
     fd: RawFd,
     mode: FallocateFlags,
@@ -635,12 +690,136 @@ pub fn fallocate(
     Errno::result(res).map(drop)
 }
 
+/// Argument to [`fspacectl`] describing the range to zero.  The first member is
+/// the file offset, and the second is the length of the region.
+#[cfg(any(target_os = "freebsd"))]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct SpacectlRange(pub libc::off_t, pub libc::off_t);
+
+#[cfg(any(target_os = "freebsd"))]
+impl SpacectlRange {
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.1 == 0
+    }
+
+    #[inline]
+    pub fn len(&self) -> libc::off_t {
+        self.1
+    }
+
+    #[inline]
+    pub fn offset(&self) -> libc::off_t {
+        self.0
+    }
+}
+
+/// Punch holes in a file.
+///
+/// `fspacectl` instructs the file system to deallocate a portion of a file.
+/// After a successful operation, this region of the file will return all zeroes
+/// if read.  If the file system supports deallocation, then it may free the
+/// underlying storage, too.
+///
+/// # Arguments
+///
+/// - `fd`      -   File to operate on
+/// - `range.0` -   File offset at which to begin deallocation
+/// - `range.1` -   Length of the region to deallocate
+///
+/// # Returns
+///
+/// The operation may deallocate less than the entire requested region.  On
+/// success, it returns the region that still remains to be deallocated.  The
+/// caller should loop until the returned region is empty.
+///
+/// # Example
+///
+#[cfg_attr(fbsd14, doc = " ```")]
+#[cfg_attr(not(fbsd14), doc = " ```no_run")]
+/// # use std::io::Write;
+/// # use std::os::unix::fs::FileExt;
+/// # use std::os::unix::io::AsRawFd;
+/// # use nix::fcntl::*;
+/// # use tempfile::tempfile;
+/// const INITIAL: &[u8] = b"0123456789abcdef";
+/// let mut f = tempfile().unwrap();
+/// f.write_all(INITIAL).unwrap();
+/// let mut range = SpacectlRange(3, 6);
+/// while (!range.is_empty()) {
+///     range = fspacectl(f.as_raw_fd(), range).unwrap();
+/// }
+/// let mut buf = vec![0; INITIAL.len()];
+/// f.read_exact_at(&mut buf, 0).unwrap();
+/// assert_eq!(buf, b"012\0\0\0\0\0\09abcdef");
+/// ```
+#[cfg(target_os = "freebsd")]
+pub fn fspacectl(fd: RawFd, range: SpacectlRange) -> Result<SpacectlRange> {
+    let mut rqsr = libc::spacectl_range{r_offset: range.0, r_len: range.1};
+    let res = unsafe { libc::fspacectl(
+            fd,
+            libc::SPACECTL_DEALLOC, // Only one command is supported ATM
+            &rqsr,
+            0,                      // No flags are currently supported
+            &mut rqsr
+    )};
+    Errno::result(res).map(|_| SpacectlRange(rqsr.r_offset, rqsr.r_len))
+}
+
+/// Like [`fspacectl`], but will never return incomplete.
+///
+/// # Arguments
+///
+/// - `fd`      -   File to operate on
+/// - `offset`  -   File offset at which to begin deallocation
+/// - `len`     -   Length of the region to deallocate
+///
+/// # Returns
+///
+/// Returns `()` on success.  On failure, the region may or may not be partially
+/// deallocated.
+///
+/// # Example
+///
+#[cfg_attr(fbsd14, doc = " ```")]
+#[cfg_attr(not(fbsd14), doc = " ```no_run")]
+/// # use std::io::Write;
+/// # use std::os::unix::fs::FileExt;
+/// # use std::os::unix::io::AsRawFd;
+/// # use nix::fcntl::*;
+/// # use tempfile::tempfile;
+/// const INITIAL: &[u8] = b"0123456789abcdef";
+/// let mut f = tempfile().unwrap();
+/// f.write_all(INITIAL).unwrap();
+/// fspacectl_all(f.as_raw_fd(), 3, 6).unwrap();
+/// let mut buf = vec![0; INITIAL.len()];
+/// f.read_exact_at(&mut buf, 0).unwrap();
+/// assert_eq!(buf, b"012\0\0\0\0\0\09abcdef");
+/// ```
+#[cfg(target_os = "freebsd")]
+pub fn fspacectl_all(fd: RawFd, offset: libc::off_t, len: libc::off_t)
+    -> Result<()>
+{
+    let mut rqsr = libc::spacectl_range{r_offset: offset, r_len: len};
+    while rqsr.r_len > 0 {
+        let res = unsafe { libc::fspacectl(
+                fd,
+                libc::SPACECTL_DEALLOC, // Only one command is supported ATM
+                &rqsr,
+                0,                      // No flags are currently supported
+                &mut rqsr
+        )};
+        Errno::result(res)?;
+    }
+    Ok(())
+}
+
 #[cfg(any(
     target_os = "linux",
     target_os = "android",
     target_os = "emscripten",
     target_os = "fuchsia",
-    any(target_os = "wasi", target_env = "wasi"),
+    target_os = "wasi",
     target_env = "uclibc",
     target_os = "freebsd"
 ))]
@@ -649,9 +828,11 @@ mod posix_fadvise {
     use std::os::unix::io::RawFd;
     use crate::Result;
 
+    #[cfg(feature = "fs")]
     libc_enum! {
         #[repr(i32)]
         #[non_exhaustive]
+        #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
         pub enum PosixFadviseAdvice {
             POSIX_FADV_NORMAL,
             POSIX_FADV_SEQUENTIAL,
@@ -662,6 +843,8 @@ mod posix_fadvise {
         }
     }
 
+    feature! {
+    #![feature = "fs"]
     pub fn posix_fadvise(
         fd: RawFd,
         offset: libc::off_t,
@@ -676,14 +859,16 @@ mod posix_fadvise {
             Err(Errno::from_i32(res))
         }
     }
+    }
 }
 
 #[cfg(any(
     target_os = "linux",
     target_os = "android",
+    target_os = "dragonfly",
     target_os = "emscripten",
     target_os = "fuchsia",
-    any(target_os = "wasi", target_env = "wasi"),
+    target_os = "wasi",
     target_os = "freebsd"
 ))]
 pub fn posix_fallocate(fd: RawFd, offset: libc::off_t, len: libc::off_t) -> Result<()> {
@@ -694,3 +879,4 @@ pub fn posix_fallocate(fd: RawFd, offset: libc::off_t, len: libc::off_t) -> Resu
         Ok(errno) => Err(Errno::from_i32(errno)),
     }
 }
+}
diff --git a/src/features.rs b/src/features.rs
index ed80fd7..39d1760 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -4,6 +4,8 @@ pub use self::os::*;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod os {
     use crate::sys::utsname::uname;
+    use crate::Result;
+    use std::os::unix::ffi::OsStrExt;
 
     // Features:
     // * atomic cloexec on socket: 2.6.27
@@ -11,10 +13,10 @@ mod os {
     // * accept4: 2.6.28
 
     static VERS_UNKNOWN: usize = 1;
-    static VERS_2_6_18:  usize = 2;
-    static VERS_2_6_27:  usize = 3;
-    static VERS_2_6_28:  usize = 4;
-    static VERS_3:       usize = 5;
+    static VERS_2_6_18: usize = 2;
+    static VERS_2_6_27: usize = 3;
+    static VERS_2_6_28: usize = 4;
+    static VERS_3: usize = 5;
 
     #[inline]
     fn digit(dst: &mut usize, b: u8) {
@@ -22,15 +24,15 @@ mod os {
         *dst += (b - b'0') as usize;
     }
 
-    fn parse_kernel_version() -> usize {
-        let u = uname();
+    fn parse_kernel_version() -> Result<usize> {
+        let u = uname()?;
 
-        let mut curr:  usize = 0;
+        let mut curr: usize = 0;
         let mut major: usize = 0;
         let mut minor: usize = 0;
         let mut patch: usize = 0;
 
-        for b in u.release().bytes() {
+        for &b in u.release().as_bytes() {
             if curr >= 3 {
                 break;
             }
@@ -39,18 +41,16 @@ mod os {
                 b'.' | b'-' => {
                     curr += 1;
                 }
-                b'0'..=b'9' => {
-                    match curr {
-                        0 => digit(&mut major, b),
-                        1 => digit(&mut minor, b),
-                        _ => digit(&mut patch, b),
-                    }
-                }
+                b'0'..=b'9' => match curr {
+                    0 => digit(&mut major, b),
+                    1 => digit(&mut minor, b),
+                    _ => digit(&mut patch, b),
+                },
                 _ => break,
             }
         }
 
-        if major >= 3 {
+        Ok(if major >= 3 {
             VERS_3
         } else if major >= 2 {
             if minor >= 7 {
@@ -68,29 +68,31 @@ mod os {
             }
         } else {
             VERS_UNKNOWN
-        }
+        })
     }
 
-    fn kernel_version() -> usize {
+    fn kernel_version() -> Result<usize> {
         static mut KERNEL_VERS: usize = 0;
 
         unsafe {
             if KERNEL_VERS == 0 {
-                KERNEL_VERS = parse_kernel_version();
+                KERNEL_VERS = parse_kernel_version()?;
             }
 
-            KERNEL_VERS
+            Ok(KERNEL_VERS)
         }
     }
 
     /// Check if the OS supports atomic close-on-exec for sockets
     pub fn socket_atomic_cloexec() -> bool {
-        kernel_version() >= VERS_2_6_27
+        kernel_version()
+            .map(|version| version >= VERS_2_6_27)
+            .unwrap_or(false)
     }
 
     #[test]
     pub fn test_parsing_kernel_version() {
-        assert!(kernel_version() > 0);
+        assert!(kernel_version().unwrap() > 0);
     }
 }
 
@@ -109,10 +111,13 @@ mod os {
     }
 }
 
-#[cfg(any(target_os = "macos",
-          target_os = "ios",
-          target_os = "fuchsia",
-          target_os = "solaris"))]
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "fuchsia",
+    target_os = "haiku",
+    target_os = "solaris"
+))]
 mod os {
     /// Check if the OS supports atomic close-on-exec for sockets
     pub const fn socket_atomic_cloexec() -> bool {
diff --git a/src/ifaddrs.rs b/src/ifaddrs.rs
index ed6328f..70b50b0 100644
--- a/src/ifaddrs.rs
+++ b/src/ifaddrs.rs
@@ -4,14 +4,16 @@
 //! of interfaces and their associated addresses.
 
 use cfg_if::cfg_if;
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+use std::convert::TryFrom;
 use std::ffi;
 use std::iter::Iterator;
 use std::mem;
 use std::option::Option;
 
-use crate::{Result, Errno};
-use crate::sys::socket::SockAddr;
 use crate::net::if_::*;
+use crate::sys::socket::{SockaddrLike, SockaddrStorage};
+use crate::{Errno, Result};
 
 /// Describes a single address for an interface as returned by `getifaddrs`.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -21,13 +23,13 @@ pub struct InterfaceAddress {
     /// Flags as from `SIOCGIFFLAGS` ioctl
     pub flags: InterfaceFlags,
     /// Network address of this interface
-    pub address: Option<SockAddr>,
+    pub address: Option<SockaddrStorage>,
     /// Netmask of this interface
-    pub netmask: Option<SockAddr>,
+    pub netmask: Option<SockaddrStorage>,
     /// Broadcast address of this interface, if applicable
-    pub broadcast: Option<SockAddr>,
+    pub broadcast: Option<SockaddrStorage>,
     /// Point-to-point destination address
-    pub destination: Option<SockAddr>,
+    pub destination: Option<SockaddrStorage>,
 }
 
 cfg_if! {
@@ -42,12 +44,52 @@ cfg_if! {
     }
 }
 
+/// Workaround a bug in XNU where netmasks will always have the wrong size in
+/// the sa_len field due to the kernel ignoring trailing zeroes in the structure
+/// when setting the field. See https://github.com/nix-rust/nix/issues/1709#issuecomment-1199304470
+///
+/// To fix this, we stack-allocate a new sockaddr_storage, zero it out, and
+/// memcpy sa_len of the netmask to that new storage. Finally, we reset the
+/// ss_len field to sizeof(sockaddr_storage). This is supposedly valid as all
+/// members of the sockaddr_storage are "ok" with being zeroed out (there are
+/// no pointers).
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+unsafe fn workaround_xnu_bug(info: &libc::ifaddrs) -> Option<SockaddrStorage> {
+    let src_sock = info.ifa_netmask;
+    if src_sock.is_null() {
+        return None;
+    }
+
+    let mut dst_sock = mem::MaybeUninit::<libc::sockaddr_storage>::zeroed();
+
+    // memcpy only sa_len bytes, assume the rest is zero
+    std::ptr::copy_nonoverlapping(
+        src_sock as *const u8,
+        dst_sock.as_mut_ptr() as *mut u8,
+        (*src_sock).sa_len.into(),
+    );
+
+    // Initialize ss_len to sizeof(libc::sockaddr_storage).
+    (*dst_sock.as_mut_ptr()).ss_len =
+        u8::try_from(mem::size_of::<libc::sockaddr_storage>()).unwrap();
+    let dst_sock = dst_sock.assume_init();
+
+    let dst_sock_ptr =
+        &dst_sock as *const libc::sockaddr_storage as *const libc::sockaddr;
+
+    SockaddrStorage::from_raw(dst_sock_ptr, None)
+}
+
 impl InterfaceAddress {
     /// Create an `InterfaceAddress` from the libc struct.
     fn from_libc_ifaddrs(info: &libc::ifaddrs) -> InterfaceAddress {
         let ifname = unsafe { ffi::CStr::from_ptr(info.ifa_name) };
-        let address = unsafe { SockAddr::from_libc_sockaddr(info.ifa_addr) };
-        let netmask = unsafe { SockAddr::from_libc_sockaddr(info.ifa_netmask) };
+        let address = unsafe { SockaddrStorage::from_raw(info.ifa_addr, None) };
+        #[cfg(any(target_os = "ios", target_os = "macos"))]
+        let netmask = unsafe { workaround_xnu_bug(info) };
+        #[cfg(not(any(target_os = "ios", target_os = "macos")))]
+        let netmask =
+            unsafe { SockaddrStorage::from_raw(info.ifa_netmask, None) };
         let mut addr = InterfaceAddress {
             interface_name: ifname.to_string_lossy().to_string(),
             flags: InterfaceFlags::from_bits_truncate(info.ifa_flags as i32),
@@ -59,9 +101,9 @@ impl InterfaceAddress {
 
         let ifu = get_ifu_from_sockaddr(info);
         if addr.flags.contains(InterfaceFlags::IFF_POINTOPOINT) {
-            addr.destination = unsafe { SockAddr::from_libc_sockaddr(ifu) };
+            addr.destination = unsafe { SockaddrStorage::from_raw(ifu, None) };
         } else if addr.flags.contains(InterfaceFlags::IFF_BROADCAST) {
-            addr.broadcast = unsafe { SockAddr::from_libc_sockaddr(ifu) };
+            addr.broadcast = unsafe { SockaddrStorage::from_raw(ifu, None) };
         }
 
         addr
@@ -103,9 +145,9 @@ impl Iterator for InterfaceAddressIterator {
 /// Note that the underlying implementation differs between OSes. Only the
 /// most common address families are supported by the nix crate (due to
 /// lack of time and complexity of testing). The address family is encoded
-/// in the specific variant of `SockAddr` returned for the fields `address`,
-/// `netmask`, `broadcast`, and `destination`. For any entry not supported,
-/// the returned list will contain a `None` entry.
+/// in the specific variant of `SockaddrStorage` returned for the fields
+/// `address`, `netmask`, `broadcast`, and `destination`. For any entry not
+/// supported, the returned list will contain a `None` entry.
 ///
 /// # Example
 /// ```
@@ -144,4 +186,28 @@ mod tests {
     fn test_getifaddrs() {
         let _ = getifaddrs();
     }
+
+    // Ensures getting the netmask works, and in particular that
+    // `workaround_xnu_bug` works properly.
+    #[test]
+    fn test_getifaddrs_netmask_correct() {
+        let addrs = getifaddrs().unwrap();
+        for iface in addrs {
+            let sock = if let Some(sock) = iface.netmask {
+                sock
+            } else {
+                continue;
+            };
+            if sock.family() == Some(crate::sys::socket::AddressFamily::Inet) {
+                let _ = sock.as_sockaddr_in().unwrap();
+                return;
+            } else if sock.family()
+                == Some(crate::sys::socket::AddressFamily::Inet6)
+            {
+                let _ = sock.as_sockaddr_in6().unwrap();
+                return;
+            }
+        }
+        panic!("No address?");
+    }
 }
diff --git a/src/kmod.rs b/src/kmod.rs
index c42068c..1fa6c17 100644
--- a/src/kmod.rs
+++ b/src/kmod.rs
@@ -79,7 +79,11 @@ libc_bitflags!(
 /// ```
 ///
 /// See [`man init_module(2)`](https://man7.org/linux/man-pages/man2/init_module.2.html) for more information.
-pub fn finit_module<T: AsRawFd>(fd: &T, param_values: &CStr, flags: ModuleInitFlags) -> Result<()> {
+pub fn finit_module<T: AsRawFd>(
+    fd: &T,
+    param_values: &CStr,
+    flags: ModuleInitFlags,
+) -> Result<()> {
     let res = unsafe {
         libc::syscall(
             libc::SYS_finit_module,
@@ -116,7 +120,9 @@ libc_bitflags!(
 ///
 /// See [`man delete_module(2)`](https://man7.org/linux/man-pages/man2/delete_module.2.html) for more information.
 pub fn delete_module(name: &CStr, flags: DeleteModuleFlags) -> Result<()> {
-    let res = unsafe { libc::syscall(libc::SYS_delete_module, name.as_ptr(), flags.bits()) };
+    let res = unsafe {
+        libc::syscall(libc::SYS_delete_module, name.as_ptr(), flags.bits())
+    };
 
     Errno::result(res).map(drop)
 }
diff --git a/src/lib.rs b/src/lib.rs
index 3a2b63a..6b82125 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,88 +2,163 @@
 //!
 //! Modules are structured according to the C header file that they would be
 //! defined in.
+//!
+//! # Features
+//!
+//! Nix uses the following Cargo features to enable optional functionality.
+//! They may be enabled in any combination.
+//! * `acct` - Process accounting
+//! * `aio` - POSIX AIO
+//! * `dir` - Stuff relating to directory iteration
+//! * `env` - Manipulate environment variables
+//! * `event` - Event-driven APIs, like `kqueue` and `epoll`
+//! * `feature` - Query characteristics of the OS at runtime
+//! * `fs` - File system functionality
+//! * `hostname` - Get and set the system's hostname
+//! * `inotify` - Linux's `inotify` file system notification API
+//! * `ioctl` - The `ioctl` syscall, and wrappers for my specific instances
+//! * `kmod` - Load and unload kernel modules
+//! * `mman` - Stuff relating to memory management
+//! * `mount` - Mount and unmount file systems
+//! * `mqueue` - POSIX message queues
+//! * `net` - Networking-related functionality
+//! * `personality` - Set the process execution domain
+//! * `poll` - APIs like `poll` and `select`
+//! * `process` - Stuff relating to running processes
+//! * `pthread` - POSIX threads
+//! * `ptrace` - Process tracing and debugging
+//! * `quota` - File system quotas
+//! * `reboot` - Reboot the system
+//! * `resource` - Process resource limits
+//! * `sched` - Manipulate process's scheduling
+//! * `socket` - Sockets, whether for networking or local use
+//! * `signal` - Send and receive signals to processes
+//! * `term` - Terminal control APIs
+//! * `time` - Query the operating system's clocks
+//! * `ucontext` - User thread context
+//! * `uio` - Vectored I/O
+//! * `user` - Stuff relating to users and groups
+//! * `zerocopy` - APIs like `sendfile` and `copy_file_range`
 #![crate_name = "nix"]
 #![cfg(unix)]
+#![cfg_attr(docsrs, doc(cfg(all())))]
 #![allow(non_camel_case_types)]
 #![cfg_attr(test, deny(warnings))]
 #![recursion_limit = "500"]
 #![deny(unused)]
+#![allow(unused_macros)]
+#![cfg_attr(not(feature = "default"), allow(unused_imports))]
 #![deny(unstable_features)]
 #![deny(missing_copy_implementations)]
 #![deny(missing_debug_implementations)]
 #![warn(missing_docs)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![deny(clippy::cast_ptr_alignment)]
 
 // Re-exported external crates
 pub use libc;
 
 // Private internal modules
-#[macro_use] mod macros;
+#[macro_use]
+mod macros;
 
 // Public crates
 #[cfg(not(target_os = "redox"))]
-#[allow(missing_docs)]
-pub mod dir;
-pub mod env;
+feature! {
+    #![feature = "dir"]
+    pub mod dir;
+}
+feature! {
+    #![feature = "env"]
+    pub mod env;
+}
 #[allow(missing_docs)]
 pub mod errno;
-pub mod features;
+feature! {
+    #![feature = "feature"]
+
+    #[deny(missing_docs)]
+    pub mod features;
+}
 #[allow(missing_docs)]
 pub mod fcntl;
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "illumos",
-          target_os = "openbsd"))]
-pub mod ifaddrs;
-#[cfg(any(target_os = "android",
-          target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod kmod;
-#[cfg(any(target_os = "android",
-          target_os = "freebsd",
-          target_os = "linux"))]
-pub mod mount;
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "fushsia",
-          target_os = "linux",
-          target_os = "netbsd"))]
-#[allow(missing_docs)]
-pub mod mqueue;
-#[cfg(not(target_os = "redox"))]
-pub mod net;
-pub mod poll;
+feature! {
+    #![feature = "net"]
+
+    #[cfg(any(target_os = "android",
+              target_os = "dragonfly",
+              target_os = "freebsd",
+              target_os = "ios",
+              target_os = "linux",
+              target_os = "macos",
+              target_os = "netbsd",
+              target_os = "illumos",
+              target_os = "openbsd"))]
+    #[deny(missing_docs)]
+    pub mod ifaddrs;
+    #[cfg(not(target_os = "redox"))]
+    #[deny(missing_docs)]
+    pub mod net;
+}
+#[cfg(any(target_os = "android", target_os = "linux"))]
+feature! {
+    #![feature = "kmod"]
+    #[allow(missing_docs)]
+    pub mod kmod;
+}
+feature! {
+    #![feature = "mount"]
+    pub mod mount;
+}
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "netbsd"
+))]
+feature! {
+    #![feature = "mqueue"]
+    pub mod mqueue;
+}
+feature! {
+    #![feature = "poll"]
+    pub mod poll;
+}
 #[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-pub mod pty;
-pub mod sched;
+feature! {
+    #![feature = "term"]
+    #[deny(missing_docs)]
+    pub mod pty;
+}
+feature! {
+    #![feature = "sched"]
+    pub mod sched;
+}
 pub mod sys;
-#[allow(missing_docs)]
-pub mod time;
+feature! {
+    #![feature = "time"]
+    #[allow(missing_docs)]
+    pub mod time;
+}
 // This can be implemented for other platforms as soon as libc
 // provides bindings for them.
-#[cfg(all(target_os = "linux",
-          any(target_arch = "x86", target_arch = "x86_64")))]
-#[allow(missing_docs)]
-pub mod ucontext;
+#[cfg(all(
+    target_os = "linux",
+    any(target_arch = "s390x", target_arch = "x86", target_arch = "x86_64")
+))]
+feature! {
+    #![feature = "ucontext"]
+    #[allow(missing_docs)]
+    pub mod ucontext;
+}
 #[allow(missing_docs)]
 pub mod unistd;
 
-/*
- *
- * ===== Result / Error =====
- *
- */
-
-use libc::{c_char, PATH_MAX};
-
-use std::{ptr, result};
-use std::ffi::{CStr, OsStr};
+use std::ffi::{CStr, CString, OsStr};
+use std::mem::MaybeUninit;
 use std::os::unix::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
+use std::{ptr, result, slice};
 
 use errno::Errno;
 
@@ -114,7 +189,8 @@ pub trait NixPath {
     ///
     /// Mostly used internally by Nix.
     fn with_nix_path<T, F>(&self, f: F) -> Result<T>
-        where F: FnOnce(&CStr) -> T;
+    where
+        F: FnOnce(&CStr) -> T;
 }
 
 impl NixPath for str {
@@ -127,9 +203,11 @@ impl NixPath for str {
     }
 
     fn with_nix_path<T, F>(&self, f: F) -> Result<T>
-        where F: FnOnce(&CStr) -> T {
-            OsStr::new(self).with_nix_path(f)
-        }
+    where
+        F: FnOnce(&CStr) -> T,
+    {
+        OsStr::new(self).with_nix_path(f)
+    }
 }
 
 impl NixPath for OsStr {
@@ -142,9 +220,11 @@ impl NixPath for OsStr {
     }
 
     fn with_nix_path<T, F>(&self, f: F) -> Result<T>
-        where F: FnOnce(&CStr) -> T {
-            self.as_bytes().with_nix_path(f)
-        }
+    where
+        F: FnOnce(&CStr) -> T,
+    {
+        self.as_bytes().with_nix_path(f)
+    }
 }
 
 impl NixPath for CStr {
@@ -157,12 +237,9 @@ impl NixPath for CStr {
     }
 
     fn with_nix_path<T, F>(&self, f: F) -> Result<T>
-            where F: FnOnce(&CStr) -> T {
-        // Equivalence with the [u8] impl.
-        if self.len() >= PATH_MAX as usize {
-            return Err(Errno::ENAMETOOLONG)
-        }
-
+    where
+        F: FnOnce(&CStr) -> T,
+    {
         Ok(f(self))
     }
 }
@@ -177,27 +254,50 @@ impl NixPath for [u8] {
     }
 
     fn with_nix_path<T, F>(&self, f: F) -> Result<T>
-            where F: FnOnce(&CStr) -> T {
-        let mut buf = [0u8; PATH_MAX as usize];
-
-        if self.len() >= PATH_MAX as usize {
-            return Err(Errno::ENAMETOOLONG)
+    where
+        F: FnOnce(&CStr) -> T,
+    {
+        // The real PATH_MAX is typically 4096, but it's statistically unlikely to have a path
+        // longer than ~300 bytes. See the the PR description to get stats for your own machine.
+        // https://github.com/nix-rust/nix/pull/1656
+        //
+        // By being smaller than a memory page, we also avoid the compiler inserting a probe frame:
+        // https://docs.rs/compiler_builtins/latest/compiler_builtins/probestack/index.html
+        const MAX_STACK_ALLOCATION: usize = 1024;
+
+        if self.len() >= MAX_STACK_ALLOCATION {
+            return with_nix_path_allocating(self, f);
         }
 
-        match self.iter().position(|b| *b == 0) {
-            Some(_) => Err(Errno::EINVAL),
-            None => {
-                unsafe {
-                    // TODO: Replace with bytes::copy_memory. rust-lang/rust#24028
-                    ptr::copy_nonoverlapping(self.as_ptr(), buf.as_mut_ptr(), self.len());
-                    Ok(f(CStr::from_ptr(buf.as_ptr() as *const c_char)))
-                }
+        let mut buf = MaybeUninit::<[u8; MAX_STACK_ALLOCATION]>::uninit();
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
 
-            }
+        unsafe {
+            ptr::copy_nonoverlapping(self.as_ptr(), buf_ptr, self.len());
+            buf_ptr.add(self.len()).write(0);
+        }
+
+        match CStr::from_bytes_with_nul(unsafe {
+            slice::from_raw_parts(buf_ptr, self.len() + 1)
+        }) {
+            Ok(s) => Ok(f(s)),
+            Err(_) => Err(Errno::EINVAL),
         }
     }
 }
 
+#[cold]
+#[inline(never)]
+fn with_nix_path_allocating<T, F>(from: &[u8], f: F) -> Result<T>
+where
+    F: FnOnce(&CStr) -> T,
+{
+    match CString::new(from) {
+        Ok(s) => Ok(f(&s)),
+        Err(_) => Err(Errno::EINVAL),
+    }
+}
+
 impl NixPath for Path {
     fn is_empty(&self) -> bool {
         NixPath::is_empty(self.as_os_str())
@@ -207,7 +307,10 @@ impl NixPath for Path {
         NixPath::len(self.as_os_str())
     }
 
-    fn with_nix_path<T, F>(&self, f: F) -> Result<T> where F: FnOnce(&CStr) -> T {
+    fn with_nix_path<T, F>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(&CStr) -> T,
+    {
         self.as_os_str().with_nix_path(f)
     }
 }
@@ -221,7 +324,10 @@ impl NixPath for PathBuf {
         NixPath::len(self.as_os_str())
     }
 
-    fn with_nix_path<T, F>(&self, f: F) -> Result<T> where F: FnOnce(&CStr) -> T {
+    fn with_nix_path<T, F>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(&CStr) -> T,
+    {
         self.as_os_str().with_nix_path(f)
     }
 }
diff --git a/src/macros.rs b/src/macros.rs
index 3ccbfdd..99e0de8 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,3 +1,17 @@
+// Thanks to Tokio for this macro
+macro_rules! feature {
+    (
+        #![$meta:meta]
+        $($item:item)*
+    ) => {
+        $(
+            #[cfg($meta)]
+            #[cfg_attr(docsrs, doc(cfg($meta)))]
+            $item
+        )*
+    }
+}
+
 /// The `libc_bitflags!` macro helps with a common use case of defining a public bitflags type
 /// with values from the libc crate. It is used the same way as the `bitflags!` macro, except
 /// that only the name of the flag value has to be given.
@@ -5,7 +19,7 @@
 /// The `libc` crate must be in scope with the name `libc`.
 ///
 /// # Example
-/// ```
+/// ```ignore
 /// libc_bitflags!{
 ///     pub struct ProtFlags: libc::c_int {
 ///         PROT_NONE;
@@ -25,7 +39,7 @@
 /// various flags have different types, so we cast the broken ones to the right
 /// type.
 ///
-/// ```
+/// ```ignore
 /// libc_bitflags!{
 ///     pub struct SaFlags: libc::c_ulong {
 ///         SA_NOCLDSTOP as libc::c_ulong;
@@ -66,7 +80,7 @@ macro_rules! libc_bitflags {
 /// The `libc` crate must be in scope with the name `libc`.
 ///
 /// # Example
-/// ```
+/// ```ignore
 /// libc_enum!{
 ///     pub enum ProtFlags {
 ///         PROT_NONE,
@@ -80,6 +94,9 @@ macro_rules! libc_bitflags {
 ///     }
 /// }
 /// ```
+// Some targets don't use all rules.
+#[allow(unknown_lints)]
+#[allow(unused_macro_rules)]
 macro_rules! libc_enum {
     // Exit rule.
     (@make_enum
diff --git a/src/mount/bsd.rs b/src/mount/bsd.rs
index 627bfa5..d124f1f 100644
--- a/src/mount/bsd.rs
+++ b/src/mount/bsd.rs
@@ -1,48 +1,52 @@
-use crate::{
-    Error,
-    Errno,
-    NixPath,
-    Result,
-    sys::uio::IoVec
-};
-use libc::{c_char, c_int, c_uint, c_void};
+#[cfg(target_os = "freebsd")]
+use crate::Error;
+use crate::{Errno, NixPath, Result};
+use libc::c_int;
+#[cfg(target_os = "freebsd")]
+use libc::{c_char, c_uint, c_void};
+#[cfg(target_os = "freebsd")]
 use std::{
     borrow::Cow,
-    ffi::{CString, CStr},
-    fmt,
-    io,
-    ptr
+    ffi::{CStr, CString},
+    fmt, io,
+    marker::PhantomData,
 };
 
-
 libc_bitflags!(
     /// Used with [`Nmount::nmount`].
     pub struct MntFlags: c_int {
         /// ACL support enabled.
         #[cfg(any(target_os = "netbsd", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_ACLS;
         /// All I/O to the file system should be done asynchronously.
         MNT_ASYNC;
         /// dir should instead be a file system ID encoded as “FSID:val0:val1”.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_BYFSID;
         /// Force a read-write mount even if the file system appears to be
         /// unclean.
         MNT_FORCE;
         /// GEOM journal support enabled.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_GJOURNAL;
         /// MAC support for objects.
         #[cfg(any(target_os = "macos", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_MULTILABEL;
         /// Disable read clustering.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_NOCLUSTERR;
         /// Disable write clustering.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_NOCLUSTERW;
         /// Enable NFS version 4 ACLs.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_NFS4ACLS;
         /// Do not update access times.
         MNT_NOATIME;
@@ -52,6 +56,7 @@ libc_bitflags!(
         MNT_NOSUID;
         /// Do not follow symlinks.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_NOSYMFOLLOW;
         /// Mount read-only.
         MNT_RDONLY;
@@ -62,6 +67,7 @@ libc_bitflags!(
         ///
         /// See [mksnap_ffs(8)](https://www.freebsd.org/cgi/man.cgi?query=mksnap_ffs)
         #[cfg(any(target_os = "macos", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_SNAPSHOT;
         /// Using soft updates.
         #[cfg(any(
@@ -70,10 +76,12 @@ libc_bitflags!(
                 target_os = "netbsd",
                 target_os = "openbsd"
         ))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_SOFTDEP;
         /// Directories with the SUID bit set chown new files to their own
         /// owner.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_SUIDDIR;
         /// All I/O to the file system should be done synchronously.
         MNT_SYNCHRONOUS;
@@ -83,27 +91,30 @@ libc_bitflags!(
                 target_os = "freebsd",
                 target_os = "netbsd"
         ))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_UNION;
         /// Indicates that the mount command is being applied to an already
         /// mounted file system.
         MNT_UPDATE;
         /// Check vnode use counts.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MNT_NONBUSY;
     }
 );
 
-
 /// The Error type of [`Nmount::nmount`].
 ///
 /// It wraps an [`Errno`], but also may contain an additional message returned
 /// by `nmount(2)`.
+#[cfg(target_os = "freebsd")]
 #[derive(Debug)]
 pub struct NmountError {
     errno: Error,
-    errmsg: Option<String>
+    errmsg: Option<String>,
 }
 
+#[cfg(target_os = "freebsd")]
 impl NmountError {
     /// Returns the additional error string sometimes generated by `nmount(2)`.
     pub fn errmsg(&self) -> Option<&str> {
@@ -118,13 +129,15 @@ impl NmountError {
     fn new(error: Error, errmsg: Option<&CStr>) -> Self {
         Self {
             errno: error,
-            errmsg: errmsg.map(CStr::to_string_lossy).map(Cow::into_owned)
+            errmsg: errmsg.map(CStr::to_string_lossy).map(Cow::into_owned),
         }
     }
 }
 
+#[cfg(target_os = "freebsd")]
 impl std::error::Error for NmountError {}
 
+#[cfg(target_os = "freebsd")]
 impl fmt::Display for NmountError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(errmsg) = &self.errmsg {
@@ -135,6 +148,7 @@ impl fmt::Display for NmountError {
     }
 }
 
+#[cfg(target_os = "freebsd")]
 impl From<NmountError> for io::Error {
     fn from(err: NmountError) -> Self {
         err.errno.into()
@@ -142,6 +156,7 @@ impl From<NmountError> for io::Error {
 }
 
 /// Result type of [`Nmount::nmount`].
+#[cfg(target_os = "freebsd")]
 pub type NmountResult = std::result::Result<(), NmountError>;
 
 /// Mount a FreeBSD file system.
@@ -156,8 +171,9 @@ pub type NmountResult = std::result::Result<(), NmountError>;
 /// To mount `target` onto `mountpoint` with `nullfs`:
 /// ```
 /// # use nix::unistd::Uid;
-/// # use ::sysctl::CtlValue;
-/// # if !Uid::current().is_root() && CtlValue::Int(0) == ::sysctl::value("vfs.usermount").unwrap() {
+/// # use ::sysctl::{CtlValue, Sysctl};
+/// # let ctl = ::sysctl::Ctl::new("vfs.usermount").unwrap();
+/// # if !Uid::current().is_root() && CtlValue::Int(0) == ctl.value().unwrap() {
 /// #     return;
 /// # };
 /// use nix::mount::{MntFlags, Nmount, unmount};
@@ -174,7 +190,7 @@ pub type NmountResult = std::result::Result<(), NmountError>;
 ///     .str_opt_owned("fspath", mountpoint.path().to_str().unwrap())
 ///     .str_opt_owned("target", target.path().to_str().unwrap())
 ///     .nmount(MntFlags::empty()).unwrap();
-/// 
+///
 /// unmount(mountpoint.path(), MntFlags::empty()).unwrap();
 /// ```
 ///
@@ -182,14 +198,54 @@ pub type NmountResult = std::result::Result<(), NmountError>;
 /// * [`nmount(2)`](https://www.freebsd.org/cgi/man.cgi?query=nmount)
 /// * [`nullfs(5)`](https://www.freebsd.org/cgi/man.cgi?query=nullfs)
 #[cfg(target_os = "freebsd")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 #[derive(Debug, Default)]
-pub struct Nmount<'a>{
-    iov: Vec<IoVec<&'a [u8]>>,
+pub struct Nmount<'a> {
+    // n.b. notgull: In reality, this is a list that contains
+    //               both mutable and immutable pointers.
+    //               Be careful using this.
+    iov: Vec<libc::iovec>,
     is_owned: Vec<bool>,
+    marker: PhantomData<&'a ()>,
 }
 
 #[cfg(target_os = "freebsd")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 impl<'a> Nmount<'a> {
+    /// Helper function to push a slice onto the `iov` array.
+    fn push_slice(&mut self, val: &'a [u8], is_owned: bool) {
+        self.iov.push(libc::iovec {
+            iov_base: val.as_ptr() as *mut _,
+            iov_len: val.len(),
+        });
+        self.is_owned.push(is_owned);
+    }
+
+    /// Helper function to push a pointer and its length onto the `iov` array.
+    fn push_pointer_and_length(
+        &mut self,
+        val: *const u8,
+        len: usize,
+        is_owned: bool,
+    ) {
+        self.iov.push(libc::iovec {
+            iov_base: val as *mut _,
+            iov_len: len,
+        });
+        self.is_owned.push(is_owned);
+    }
+
+    /// Helper function to push a `nix` path as owned.
+    fn push_nix_path<P: ?Sized + NixPath>(&mut self, val: &P) {
+        val.with_nix_path(|s| {
+            let len = s.to_bytes_with_nul().len();
+            let ptr = s.to_owned().into_raw() as *const u8;
+
+            self.push_pointer_and_length(ptr, len, true);
+        })
+        .unwrap();
+    }
+
     /// Add an opaque mount option.
     ///
     /// Some file systems take binary-valued mount options.  They can be set
@@ -221,13 +277,10 @@ impl<'a> Nmount<'a> {
         &mut self,
         name: &'a CStr,
         val: *mut c_void,
-        len: usize
-    ) -> &mut Self
-    {
-        self.iov.push(IoVec::from_slice(name.to_bytes_with_nul()));
-        self.is_owned.push(false);
-        self.iov.push(IoVec::from_raw_parts(val, len));
-        self.is_owned.push(false);
+        len: usize,
+    ) -> &mut Self {
+        self.push_slice(name.to_bytes_with_nul(), false);
+        self.push_pointer_and_length(val.cast(), len, false);
         self
     }
 
@@ -243,10 +296,8 @@ impl<'a> Nmount<'a> {
     ///     .null_opt(&read_only);
     /// ```
     pub fn null_opt(&mut self, name: &'a CStr) -> &mut Self {
-        self.iov.push(IoVec::from_slice(name.to_bytes_with_nul()));
-        self.is_owned.push(false);
-        self.iov.push(IoVec::from_raw_parts(ptr::null_mut(), 0));
-        self.is_owned.push(false);
+        self.push_slice(name.to_bytes_with_nul(), false);
+        self.push_slice(&[], false);
         self
     }
 
@@ -266,19 +317,12 @@ impl<'a> Nmount<'a> {
     /// let mut nmount: Nmount<'static> = Nmount::new();
     /// nmount.null_opt_owned(read_only);
     /// ```
-    pub fn null_opt_owned<P: ?Sized + NixPath>(&mut self, name: &P) -> &mut Self
-    {
-        name.with_nix_path(|s| {
-            let len = s.to_bytes_with_nul().len();
-            self.iov.push(IoVec::from_raw_parts(
-                // Must free it later
-                s.to_owned().into_raw() as *mut c_void,
-                len
-            ));
-            self.is_owned.push(true);
-        }).unwrap();
-        self.iov.push(IoVec::from_raw_parts(ptr::null_mut(), 0));
-        self.is_owned.push(false);
+    pub fn null_opt_owned<P: ?Sized + NixPath>(
+        &mut self,
+        name: &P,
+    ) -> &mut Self {
+        self.push_nix_path(name);
+        self.push_slice(&[], false);
         self
     }
 
@@ -294,16 +338,9 @@ impl<'a> Nmount<'a> {
     /// Nmount::new()
     ///     .str_opt(&fstype, &nullfs);
     /// ```
-    pub fn str_opt(
-        &mut self,
-        name: &'a CStr,
-        val: &'a CStr
-    ) -> &mut Self
-    {
-        self.iov.push(IoVec::from_slice(name.to_bytes_with_nul()));
-        self.is_owned.push(false);
-        self.iov.push(IoVec::from_slice(val.to_bytes_with_nul()));
-        self.is_owned.push(false);
+    pub fn str_opt(&mut self, name: &'a CStr, val: &'a CStr) -> &mut Self {
+        self.push_slice(name.to_bytes_with_nul(), false);
+        self.push_slice(val.to_bytes_with_nul(), false);
         self
     }
 
@@ -323,27 +360,12 @@ impl<'a> Nmount<'a> {
     ///     .str_opt_owned("fspath", mountpoint.to_str().unwrap());
     /// ```
     pub fn str_opt_owned<P1, P2>(&mut self, name: &P1, val: &P2) -> &mut Self
-        where P1: ?Sized + NixPath,
-              P2: ?Sized + NixPath
+    where
+        P1: ?Sized + NixPath,
+        P2: ?Sized + NixPath,
     {
-        name.with_nix_path(|s| {
-            let len = s.to_bytes_with_nul().len();
-            self.iov.push(IoVec::from_raw_parts(
-                // Must free it later
-                s.to_owned().into_raw() as *mut c_void,
-                len
-            ));
-            self.is_owned.push(true);
-        }).unwrap();
-        val.with_nix_path(|s| {
-            let len = s.to_bytes_with_nul().len();
-            self.iov.push(IoVec::from_raw_parts(
-                // Must free it later
-                s.to_owned().into_raw() as *mut c_void,
-                len
-            ));
-            self.is_owned.push(true);
-        }).unwrap();
+        self.push_nix_path(name);
+        self.push_nix_path(val);
         self
     }
 
@@ -354,24 +376,23 @@ impl<'a> Nmount<'a> {
 
     /// Actually mount the file system.
     pub fn nmount(&mut self, flags: MntFlags) -> NmountResult {
-        // nmount can return extra error information via a "errmsg" return
-        // argument.
         const ERRMSG_NAME: &[u8] = b"errmsg\0";
         let mut errmsg = vec![0u8; 255];
-        self.iov.push(IoVec::from_raw_parts(
-                ERRMSG_NAME.as_ptr() as *mut c_void,
-                ERRMSG_NAME.len()
-        ));
-        self.iov.push(IoVec::from_raw_parts(
-                errmsg.as_mut_ptr() as *mut c_void,
-                errmsg.len()
-        ));
+
+        // nmount can return extra error information via a "errmsg" return
+        // argument.
+        self.push_slice(ERRMSG_NAME, false);
+
+        // SAFETY: we are pushing a mutable iovec here, so we can't use
+        //         the above method
+        self.iov.push(libc::iovec {
+            iov_base: errmsg.as_mut_ptr() as *mut c_void,
+            iov_len: errmsg.len(),
+        });
 
         let niov = self.iov.len() as c_uint;
         let iovp = self.iov.as_mut_ptr() as *mut libc::iovec;
-        let res = unsafe {
-            libc::nmount(iovp, niov, flags.bits)
-        };
+        let res = unsafe { libc::nmount(iovp, niov, flags.bits) };
         match Errno::result(res) {
             Ok(_) => Ok(()),
             Err(error) => {
@@ -397,7 +418,7 @@ impl<'a> Drop for Nmount<'a> {
                 // Free the owned string.  Safe because we recorded ownership,
                 // and Nmount does not implement Clone.
                 unsafe {
-                    drop(CString::from_raw(iov.0.iov_base as *mut c_char));
+                    drop(CString::from_raw(iov.iov_base as *mut c_char));
                 }
             }
         }
@@ -408,18 +429,24 @@ impl<'a> Drop for Nmount<'a> {
 ///
 /// Useful flags include
 /// * `MNT_FORCE` -     Unmount even if still in use.
-/// * `MNT_BYFSID` -    `mountpoint` is not a path, but a file system ID
-///                     encoded as `FSID:val0:val1`, where `val0` and `val1`
-///                     are the contents of the `fsid_t val[]` array in decimal.
-///                     The file system that has the specified file system ID
-///                     will be unmounted.  See
-///                     [`statfs`](crate::sys::statfs::statfs) to determine the
-///                     `fsid`.
+#[cfg_attr(
+    target_os = "freebsd",
+    doc = "
+* `MNT_BYFSID` -    `mountpoint` is not a path, but a file system ID
+                    encoded as `FSID:val0:val1`, where `val0` and `val1`
+                    are the contents of the `fsid_t val[]` array in decimal.
+                    The file system that has the specified file system ID
+                    will be unmounted.  See
+                    [`statfs`](crate::sys::statfs::statfs) to determine the
+                    `fsid`.
+"
+)]
 pub fn unmount<P>(mountpoint: &P, flags: MntFlags) -> Result<()>
-    where P: ?Sized + NixPath
+where
+    P: ?Sized + NixPath,
 {
-    let res = mountpoint.with_nix_path(|cstr| {
-        unsafe { libc::unmount(cstr.as_ptr(), flags.bits) }
+    let res = mountpoint.with_nix_path(|cstr| unsafe {
+        libc::unmount(cstr.as_ptr(), flags.bits)
     })?;
 
     Errno::result(res).map(drop)
diff --git a/src/mount/linux.rs b/src/mount/linux.rs
index 4cb2fa5..cf6a60b 100644
--- a/src/mount/linux.rs
+++ b/src/mount/linux.rs
@@ -1,7 +1,7 @@
 #![allow(missing_docs)]
-use libc::{self, c_ulong, c_int};
-use crate::{Result, NixPath};
 use crate::errno::Errno;
+use crate::{NixPath, Result};
+use libc::{self, c_int, c_ulong};
 
 libc_bitflags!(
     pub struct MsFlags: c_ulong {
@@ -53,39 +53,44 @@ libc_bitflags!(
         MNT_FORCE;
         MNT_DETACH;
         MNT_EXPIRE;
+        UMOUNT_NOFOLLOW;
     }
 );
 
-pub fn mount<P1: ?Sized + NixPath, P2: ?Sized + NixPath, P3: ?Sized + NixPath, P4: ?Sized + NixPath>(
-        source: Option<&P1>,
-        target: &P2,
-        fstype: Option<&P3>,
-        flags: MsFlags,
-        data: Option<&P4>) -> Result<()> {
-
+pub fn mount<
+    P1: ?Sized + NixPath,
+    P2: ?Sized + NixPath,
+    P3: ?Sized + NixPath,
+    P4: ?Sized + NixPath,
+>(
+    source: Option<&P1>,
+    target: &P2,
+    fstype: Option<&P3>,
+    flags: MsFlags,
+    data: Option<&P4>,
+) -> Result<()> {
     fn with_opt_nix_path<P, T, F>(p: Option<&P>, f: F) -> Result<T>
-        where P: ?Sized + NixPath,
-              F: FnOnce(*const libc::c_char) -> T
+    where
+        P: ?Sized + NixPath,
+        F: FnOnce(*const libc::c_char) -> T,
     {
         match p {
             Some(path) => path.with_nix_path(|p_str| f(p_str.as_ptr())),
-            None => Ok(f(std::ptr::null()))
+            None => Ok(f(std::ptr::null())),
         }
     }
 
     let res = with_opt_nix_path(source, |s| {
         target.with_nix_path(|t| {
             with_opt_nix_path(fstype, |ty| {
-                with_opt_nix_path(data, |d| {
-                    unsafe {
-                        libc::mount(
-                            s,
-                            t.as_ptr(),
-                            ty,
-                            flags.bits,
-                            d as *const libc::c_void
-                        )
-                    }
+                with_opt_nix_path(data, |d| unsafe {
+                    libc::mount(
+                        s,
+                        t.as_ptr(),
+                        ty,
+                        flags.bits,
+                        d as *const libc::c_void,
+                    )
                 })
             })
         })
@@ -95,16 +100,15 @@ pub fn mount<P1: ?Sized + NixPath, P2: ?Sized + NixPath, P3: ?Sized + NixPath, P
 }
 
 pub fn umount<P: ?Sized + NixPath>(target: &P) -> Result<()> {
-    let res = target.with_nix_path(|cstr| {
-        unsafe { libc::umount(cstr.as_ptr()) }
-    })?;
+    let res =
+        target.with_nix_path(|cstr| unsafe { libc::umount(cstr.as_ptr()) })?;
 
     Errno::result(res).map(drop)
 }
 
 pub fn umount2<P: ?Sized + NixPath>(target: &P, flags: MntFlags) -> Result<()> {
-    let res = target.with_nix_path(|cstr| {
-        unsafe { libc::umount2(cstr.as_ptr(), flags.bits) }
+    let res = target.with_nix_path(|cstr| unsafe {
+        libc::umount2(cstr.as_ptr(), flags.bits)
     })?;
 
     Errno::result(res).map(drop)
diff --git a/src/mount/mod.rs b/src/mount/mod.rs
index 14bf2a9..e98b49c 100644
--- a/src/mount/mod.rs
+++ b/src/mount/mod.rs
@@ -1,21 +1,26 @@
 //! Mount file systems
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod linux;
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 pub use self::linux::*;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod bsd;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"
-          ))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 pub use self::bsd::*;
diff --git a/src/mqueue.rs b/src/mqueue.rs
index 34fd802..33599bf 100644
--- a/src/mqueue.rs
+++ b/src/mqueue.rs
@@ -1,53 +1,107 @@
 //! Posix Message Queue functions
 //!
+//! # Example
+//!
+// no_run because a kernel module may be required.
+//! ```no_run
+//! # use std::ffi::CString;
+//! # use nix::mqueue::*;
+//! use nix::sys::stat::Mode;
+//!
+//! const MSG_SIZE: mq_attr_member_t = 32;
+//! let mq_name= CString::new("/a_nix_test_queue").unwrap();
+//!
+//! let oflag0 = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
+//! let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
+//! let mqd0 = mq_open(&mq_name, oflag0, mode, None).unwrap();
+//! let msg_to_send = b"msg_1";
+//! mq_send(&mqd0, msg_to_send, 1).unwrap();
+//!
+//! let oflag1 = MQ_OFlag::O_CREAT | MQ_OFlag::O_RDONLY;
+//! let mqd1 = mq_open(&mq_name, oflag1, mode, None).unwrap();
+//! let mut buf = [0u8; 32];
+//! let mut prio = 0u32;
+//! let len = mq_receive(&mqd1, &mut buf, &mut prio).unwrap();
+//! assert_eq!(prio, 1);
+//! assert_eq!(msg_to_send, &buf[0..len]);
+//!
+//! mq_close(mqd1).unwrap();
+//! mq_close(mqd0).unwrap();
+//! ```
 //! [Further reading and details on the C API](https://man7.org/linux/man-pages/man7/mq_overview.7.html)
 
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 
-use libc::{self, c_char, mqd_t, size_t};
-use std::ffi::CString;
 use crate::sys::stat::Mode;
+use libc::{self, c_char, mqd_t, size_t};
+use std::ffi::CStr;
 use std::mem;
 
-libc_bitflags!{
+libc_bitflags! {
+    /// Used with [`mq_open`].
     pub struct MQ_OFlag: libc::c_int {
+        /// Open the message queue for receiving messages.
         O_RDONLY;
+        /// Open the queue for sending messages.
         O_WRONLY;
+        /// Open the queue for both receiving and sending messages
         O_RDWR;
+        /// Create a message queue.
         O_CREAT;
+        /// If set along with `O_CREAT`, `mq_open` will fail if the message
+        /// queue name exists.
         O_EXCL;
+        /// `mq_send` and `mq_receive` should fail with `EAGAIN` rather than
+        /// wait for resources that are not currently available.
         O_NONBLOCK;
+        /// Set the close-on-exec flag for the message queue descriptor.
         O_CLOEXEC;
     }
 }
 
-libc_bitflags!{
-    pub struct FdFlag: libc::c_int {
-        FD_CLOEXEC;
-    }
-}
-
+/// A message-queue attribute, optionally used with [`mq_setattr`] and
+/// [`mq_getattr`] and optionally [`mq_open`],
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct MqAttr {
     mq_attr: libc::mq_attr,
 }
 
+/// Identifies an open POSIX Message Queue
+// A safer wrapper around libc::mqd_t, which is a pointer on some platforms
+// Deliberately is not Clone to prevent use-after-close scenarios
+#[repr(transparent)]
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MqdT(mqd_t);
+
 // x32 compatibility
 // See https://sourceware.org/bugzilla/show_bug.cgi?id=21279
+/// Size of a message queue attribute member
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub type mq_attr_member_t = i64;
+/// Size of a message queue attribute member
 #[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub type mq_attr_member_t = libc::c_long;
 
 impl MqAttr {
-    pub fn new(mq_flags: mq_attr_member_t,
-               mq_maxmsg: mq_attr_member_t,
-               mq_msgsize: mq_attr_member_t,
-               mq_curmsgs: mq_attr_member_t)
-               -> MqAttr
-    {
+    /// Create a new message queue attribute
+    ///
+    /// # Arguments
+    ///
+    /// - `mq_flags`:   Either `0` or `O_NONBLOCK`.
+    /// - `mq_maxmsg`:  Maximum number of messages on the queue.
+    /// - `mq_msgsize`: Maximum message size in bytes.
+    /// - `mq_curmsgs`: Number of messages currently in the queue.
+    pub fn new(
+        mq_flags: mq_attr_member_t,
+        mq_maxmsg: mq_attr_member_t,
+        mq_msgsize: mq_attr_member_t,
+        mq_curmsgs: mq_attr_member_t,
+    ) -> MqAttr {
         let mut attr = mem::MaybeUninit::<libc::mq_attr>::uninit();
         unsafe {
             let p = attr.as_mut_ptr();
@@ -55,42 +109,62 @@ impl MqAttr {
             (*p).mq_maxmsg = mq_maxmsg;
             (*p).mq_msgsize = mq_msgsize;
             (*p).mq_curmsgs = mq_curmsgs;
-            MqAttr { mq_attr: attr.assume_init() }
+            MqAttr {
+                mq_attr: attr.assume_init(),
+            }
         }
     }
 
+    /// The current flags, either `0` or `O_NONBLOCK`.
     pub const fn flags(&self) -> mq_attr_member_t {
         self.mq_attr.mq_flags
     }
-}
 
+    /// The max number of messages that can be held by the queue
+    pub const fn maxmsg(&self) -> mq_attr_member_t {
+        self.mq_attr.mq_maxmsg
+    }
+
+    /// The maximum size of each message (in bytes)
+    pub const fn msgsize(&self) -> mq_attr_member_t {
+        self.mq_attr.mq_msgsize
+    }
+
+    /// The number of messages currently held in the queue
+    pub const fn curmsgs(&self) -> mq_attr_member_t {
+        self.mq_attr.mq_curmsgs
+    }
+}
 
 /// Open a message queue
 ///
 /// See also [`mq_open(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_open.html)
 // The mode.bits cast is only lossless on some OSes
 #[allow(clippy::cast_lossless)]
-pub fn mq_open(name: &CString,
-               oflag: MQ_OFlag,
-               mode: Mode,
-               attr: Option<&MqAttr>)
-               -> Result<mqd_t> {
+pub fn mq_open(
+    name: &CStr,
+    oflag: MQ_OFlag,
+    mode: Mode,
+    attr: Option<&MqAttr>,
+) -> Result<MqdT> {
     let res = match attr {
         Some(mq_attr) => unsafe {
-            libc::mq_open(name.as_ptr(),
-                          oflag.bits(),
-                          mode.bits() as libc::c_int,
-                          &mq_attr.mq_attr as *const libc::mq_attr)
+            libc::mq_open(
+                name.as_ptr(),
+                oflag.bits(),
+                mode.bits() as libc::c_int,
+                &mq_attr.mq_attr as *const libc::mq_attr,
+            )
         },
         None => unsafe { libc::mq_open(name.as_ptr(), oflag.bits()) },
     };
-    Errno::result(res)
+    Errno::result(res).map(MqdT)
 }
 
 /// Remove a message queue
 ///
 /// See also [`mq_unlink(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_unlink.html)
-pub fn mq_unlink(name: &CString) -> Result<()> {
+pub fn mq_unlink(name: &CStr) -> Result<()> {
     let res = unsafe { libc::mq_unlink(name.as_ptr()) };
     Errno::result(res).map(drop)
 }
@@ -98,21 +172,27 @@ pub fn mq_unlink(name: &CString) -> Result<()> {
 /// Close a message queue
 ///
 /// See also [`mq_close(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_close.html)
-pub fn mq_close(mqdes: mqd_t) -> Result<()> {
-    let res = unsafe { libc::mq_close(mqdes) };
+pub fn mq_close(mqdes: MqdT) -> Result<()> {
+    let res = unsafe { libc::mq_close(mqdes.0) };
     Errno::result(res).map(drop)
 }
 
 /// Receive a message from a message queue
 ///
 /// See also [`mq_receive(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_receive.html)
-pub fn mq_receive(mqdes: mqd_t, message: &mut [u8], msg_prio: &mut u32) -> Result<usize> {
+pub fn mq_receive(
+    mqdes: &MqdT,
+    message: &mut [u8],
+    msg_prio: &mut u32,
+) -> Result<usize> {
     let len = message.len() as size_t;
     let res = unsafe {
-        libc::mq_receive(mqdes,
-                         message.as_mut_ptr() as *mut c_char,
-                         len,
-                         msg_prio as *mut u32)
+        libc::mq_receive(
+            mqdes.0,
+            message.as_mut_ptr() as *mut c_char,
+            len,
+            msg_prio as *mut u32,
+        )
     };
     Errno::result(res).map(|r| r as usize)
 }
@@ -120,12 +200,14 @@ pub fn mq_receive(mqdes: mqd_t, message: &mut [u8], msg_prio: &mut u32) -> Resul
 /// Send a message to a message queue
 ///
 /// See also [`mq_send(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_send.html)
-pub fn mq_send(mqdes: mqd_t, message: &[u8], msq_prio: u32) -> Result<()> {
+pub fn mq_send(mqdes: &MqdT, message: &[u8], msq_prio: u32) -> Result<()> {
     let res = unsafe {
-        libc::mq_send(mqdes,
-                      message.as_ptr() as *const c_char,
-                      message.len(),
-                      msq_prio)
+        libc::mq_send(
+            mqdes.0,
+            message.as_ptr() as *const c_char,
+            message.len(),
+            msq_prio,
+        )
     };
     Errno::result(res).map(drop)
 }
@@ -133,10 +215,14 @@ pub fn mq_send(mqdes: mqd_t, message: &[u8], msq_prio: u32) -> Result<()> {
 /// Get message queue attributes
 ///
 /// See also [`mq_getattr(2)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_getattr.html)
-pub fn mq_getattr(mqd: mqd_t) -> Result<MqAttr> {
+pub fn mq_getattr(mqd: &MqdT) -> Result<MqAttr> {
     let mut attr = mem::MaybeUninit::<libc::mq_attr>::uninit();
-    let res = unsafe { libc::mq_getattr(mqd, attr.as_mut_ptr()) };
-    Errno::result(res).map(|_| unsafe{MqAttr { mq_attr: attr.assume_init() }})
+    let res = unsafe { libc::mq_getattr(mqd.0, attr.as_mut_ptr()) };
+    Errno::result(res).map(|_| unsafe {
+        MqAttr {
+            mq_attr: attr.assume_init(),
+        }
+    })
 }
 
 /// Set the attributes of the message queue. Only `O_NONBLOCK` can be set, everything else will be ignored
@@ -144,35 +230,47 @@ pub fn mq_getattr(mqd: mqd_t) -> Result<MqAttr> {
 /// It is recommend to use the `mq_set_nonblock()` and `mq_remove_nonblock()` convenience functions as they are easier to use
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_setattr.html)
-pub fn mq_setattr(mqd: mqd_t, newattr: &MqAttr) -> Result<MqAttr> {
+pub fn mq_setattr(mqd: &MqdT, newattr: &MqAttr) -> Result<MqAttr> {
     let mut attr = mem::MaybeUninit::<libc::mq_attr>::uninit();
     let res = unsafe {
-        libc::mq_setattr(mqd, &newattr.mq_attr as *const libc::mq_attr, attr.as_mut_ptr())
+        libc::mq_setattr(
+            mqd.0,
+            &newattr.mq_attr as *const libc::mq_attr,
+            attr.as_mut_ptr(),
+        )
     };
-    Errno::result(res).map(|_| unsafe{ MqAttr { mq_attr: attr.assume_init() }})
+    Errno::result(res).map(|_| unsafe {
+        MqAttr {
+            mq_attr: attr.assume_init(),
+        }
+    })
 }
 
 /// Convenience function.
 /// Sets the `O_NONBLOCK` attribute for a given message queue descriptor
 /// Returns the old attributes
-#[allow(clippy::useless_conversion)]    // Not useless on all OSes
-pub fn mq_set_nonblock(mqd: mqd_t) -> Result<MqAttr> {
+#[allow(clippy::useless_conversion)] // Not useless on all OSes
+pub fn mq_set_nonblock(mqd: &MqdT) -> Result<MqAttr> {
     let oldattr = mq_getattr(mqd)?;
-    let newattr = MqAttr::new(mq_attr_member_t::from(MQ_OFlag::O_NONBLOCK.bits()),
-                              oldattr.mq_attr.mq_maxmsg,
-                              oldattr.mq_attr.mq_msgsize,
-                              oldattr.mq_attr.mq_curmsgs);
+    let newattr = MqAttr::new(
+        mq_attr_member_t::from(MQ_OFlag::O_NONBLOCK.bits()),
+        oldattr.mq_attr.mq_maxmsg,
+        oldattr.mq_attr.mq_msgsize,
+        oldattr.mq_attr.mq_curmsgs,
+    );
     mq_setattr(mqd, &newattr)
 }
 
 /// Convenience function.
 /// Removes `O_NONBLOCK` attribute for a given message queue descriptor
 /// Returns the old attributes
-pub fn mq_remove_nonblock(mqd: mqd_t) -> Result<MqAttr> {
+pub fn mq_remove_nonblock(mqd: &MqdT) -> Result<MqAttr> {
     let oldattr = mq_getattr(mqd)?;
-    let newattr = MqAttr::new(0,
-                              oldattr.mq_attr.mq_maxmsg,
-                              oldattr.mq_attr.mq_msgsize,
-                              oldattr.mq_attr.mq_curmsgs);
+    let newattr = MqAttr::new(
+        0,
+        oldattr.mq_attr.mq_maxmsg,
+        oldattr.mq_attr.mq_msgsize,
+        oldattr.mq_attr.mq_curmsgs,
+    );
     mq_setattr(mqd, &newattr)
 }
diff --git a/src/net/if_.rs b/src/net/if_.rs
index bc00a43..b2423bc 100644
--- a/src/net/if_.rs
+++ b/src/net/if_.rs
@@ -8,7 +8,8 @@ use libc::c_uint;
 
 /// Resolve an interface into a interface number.
 pub fn if_nametoindex<P: ?Sized + NixPath>(name: &P) -> Result<c_uint> {
-    let if_index = name.with_nix_path(|name| unsafe { libc::if_nametoindex(name.as_ptr()) })?;
+    let if_index = name
+        .with_nix_path(|name| unsafe { libc::if_nametoindex(name.as_ptr()) })?;
 
     if if_index == 0 {
         Err(Error::last())
@@ -28,6 +29,7 @@ libc_bitflags!(
         IFF_BROADCAST;
         /// Internal debugging flag. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
+        #[cfg(not(target_os = "haiku"))]
         IFF_DEBUG;
         /// Interface is a loopback interface. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
@@ -45,9 +47,11 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "illumos",
                   target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NOTRAILERS;
         /// Interface manages own routes.
         #[cfg(any(target_os = "dragonfly"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_SMART;
         /// Resources allocated. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
@@ -62,6 +66,7 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_RUNNING;
         /// No arp protocol, L2 destination address not set. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
@@ -75,6 +80,7 @@ libc_bitflags!(
         /// Master of a load balancing bundle. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_MASTER;
         /// transmission in progress, tx hardware queue is full
         #[cfg(any(target_os = "freebsd",
@@ -82,21 +88,24 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "ios"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_OACTIVE;
         /// Protocol code on board.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_INTELLIGENT;
         /// Slave of a load balancing bundle. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_SLAVE;
         /// Can't hear own transmissions.
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd",
                   target_os = "macos",
                   target_os = "netbsd",
-                  target_os = "openbsd",
-                  target_os = "osx"))]
+                  target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_SIMPLEX;
         /// Supports multicast. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
@@ -108,13 +117,16 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "ios"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_LINK0;
         /// Multicast using broadcast.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_MULTI_BCAST;
         /// Is able to select media type via ifmap. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_PORTSEL;
         /// Per link layer defined bit.
         #[cfg(any(target_os = "dragonfly",
@@ -123,13 +135,16 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "ios"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_LINK1;
         /// Non-unique address.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_UNNUMBERED;
         /// Auto media selection active. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_AUTOMEDIA;
         /// Per link layer defined bit.
         #[cfg(any(target_os = "dragonfly",
@@ -138,132 +153,174 @@ libc_bitflags!(
                   target_os = "netbsd",
                   target_os = "openbsd",
                   target_os = "ios"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_LINK2;
         /// Use alternate physical connection.
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd",
                   target_os = "macos",
                   target_os = "ios"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_ALTPHYS;
         /// DHCP controls interface.
         #[cfg(any(target_os = "solaris", target_os = "illumos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DHCPRUNNING;
         /// The addresses are lost when the interface goes down. (see
         /// [`netdevice(7)`](https://man7.org/linux/man-pages/man7/netdevice.7.html))
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DYNAMIC;
         /// Do not advertise.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_PRIVATE;
         /// Driver signals L1 up. Volatile.
         #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_LOWER_UP;
         /// Interface is in polling mode.
         #[cfg(any(target_os = "dragonfly"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_POLLING_COMPAT;
         /// Unconfigurable using ioctl(2).
         #[cfg(any(target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_CANTCONFIG;
         /// Do not transmit packets.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NOXMIT;
         /// Driver signals dormant. Volatile.
         #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DORMANT;
         /// User-requested promisc mode.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_PPROMISC;
         /// Just on-link subnet.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NOLOCAL;
         /// Echo sent packets. Volatile.
         #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_ECHO;
         /// User-requested monitor mode.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_MONITOR;
         /// Address is deprecated.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DEPRECATED;
         /// Static ARP.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_STATICARP;
         /// Address from stateless addrconf.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_ADDRCONF;
         /// Interface is in polling mode.
         #[cfg(any(target_os = "dragonfly"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NPOLLING;
         /// Router on interface.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_ROUTER;
         /// Interface is in polling mode.
         #[cfg(any(target_os = "dragonfly"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_IDIRECT;
         /// Interface is winding down
         #[cfg(any(target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DYING;
         /// No NUD on interface.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NONUD;
         /// Interface is being renamed
         #[cfg(any(target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_RENAMING;
         /// Anycast address.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_ANYCAST;
         /// Don't exchange routing info.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NORTEXCH;
         /// Do not provide packet information
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NO_PI as libc::c_int;
         /// TUN device (no Ethernet headers)
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_TUN as libc::c_int;
         /// TAP device
         #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_TAP as libc::c_int;
         /// IPv4 interface.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_IPV4;
         /// IPv6 interface.
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_IPV6;
         /// in.mpathd test address
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_NOFAILOVER;
         /// Interface has failed
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_FAILED;
         /// Interface is a hot-spare
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_STANDBY;
         /// Functioning but not used
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_INACTIVE;
         /// Interface is offline
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_OFFLINE;
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_COS_ENABLED;
         /// Prefer as source addr.
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_PREFERRED;
         /// RFC3041
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_TEMPORARY;
         /// MTU set with SIOCSLIFMTU
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_FIXEDMTU;
         /// Cannot send / receive packets
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_VIRTUAL;
         /// Local address in use
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_DUPLICATE;
         /// IPMP IP interface
         #[cfg(target_os = "solaris")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IFF_IPMP;
     }
 );
@@ -278,6 +335,7 @@ libc_bitflags!(
     target_os = "netbsd",
     target_os = "openbsd",
 ))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod if_nameindex {
     use super::*;
 
diff --git a/src/poll.rs b/src/poll.rs
index 8556c1b..6f227fe 100644
--- a/src/poll.rs
+++ b/src/poll.rs
@@ -1,12 +1,8 @@
 //! Wait for events to trigger on specific file descriptors
-#[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd", target_os = "linux"))]
-use crate::sys::time::TimeSpec;
-#[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd", target_os = "linux"))]
-use crate::sys::signal::SigSet;
 use std::os::unix::io::{AsRawFd, RawFd};
 
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 
 /// This is a wrapper around `libc::pollfd`.
 ///
@@ -14,7 +10,7 @@ use crate::errno::Errno;
 /// [`ppoll`](fn.ppoll.html) functions to specify the events of interest
 /// for a specific file descriptor.
 ///
-/// After a call to `poll` or `ppoll`, the events that occured can be
+/// After a call to `poll` or `ppoll`, the events that occurred can be
 /// retrieved by calling [`revents()`](#method.revents) on the `PollFd`.
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
@@ -35,12 +31,32 @@ impl PollFd {
         }
     }
 
-    /// Returns the events that occured in the last call to `poll` or `ppoll`.  Will only return
+    /// Returns the events that occurred in the last call to `poll` or `ppoll`.  Will only return
     /// `None` if the kernel provides status flags that Nix does not know about.
     pub fn revents(self) -> Option<PollFlags> {
         PollFlags::from_bits(self.pollfd.revents)
     }
 
+    /// Returns if any of the events of interest occured in the last call to `poll` or `ppoll`. Will
+    /// only return `None` if the kernel provides status flags that Nix does not know about.
+    ///
+    /// Equivalent to `x.revents()? != PollFlags::empty()`.
+    ///
+    /// This is marginally more efficient than [`PollFd::all`].
+    pub fn any(self) -> Option<bool> {
+        Some(self.revents()? != PollFlags::empty())
+    }
+
+    /// Returns if all the events of interest occured in the last call to `poll` or `ppoll`. Will
+    /// only return `None` if the kernel provides status flags that Nix does not know about.
+    ///
+    /// Equivalent to `x.revents()? & x.events() == x.events()`.
+    ///
+    /// This is marginally less efficient than [`PollFd::any`].
+    pub fn all(self) -> Option<bool> {
+        Some(self.revents()? & self.events() == self.events())
+    }
+
     /// The events of interest for this `PollFd`.
     pub fn events(self) -> PollFlags {
         PollFlags::from_bits(self.pollfd.events).unwrap()
@@ -81,15 +97,19 @@ libc_bitflags! {
         POLLOUT;
         /// Equivalent to [`POLLIN`](constant.POLLIN.html)
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         POLLRDNORM;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// Equivalent to [`POLLOUT`](constant.POLLOUT.html)
         POLLWRNORM;
         /// Priority band data can be read (generally unused on Linux).
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         POLLRDBAND;
         /// Priority data may be written.
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         POLLWRBAND;
         /// Error condition (only returned in
         /// [`PollFd::revents`](struct.PollFd.html#method.revents);
@@ -134,14 +154,18 @@ libc_bitflags! {
 /// ready.
 pub fn poll(fds: &mut [PollFd], timeout: libc::c_int) -> Result<libc::c_int> {
     let res = unsafe {
-        libc::poll(fds.as_mut_ptr() as *mut libc::pollfd,
-                   fds.len() as libc::nfds_t,
-                   timeout)
+        libc::poll(
+            fds.as_mut_ptr() as *mut libc::pollfd,
+            fds.len() as libc::nfds_t,
+            timeout,
+        )
     };
 
     Errno::result(res)
 }
 
+feature! {
+#![feature = "signal"]
 /// `ppoll()` allows an application to safely wait until either a file
 /// descriptor becomes ready or until a signal is caught.
 /// ([`poll(2)`](https://man7.org/linux/man-pages/man2/poll.2.html))
@@ -149,15 +173,25 @@ pub fn poll(fds: &mut [PollFd], timeout: libc::c_int) -> Result<libc::c_int> {
 /// `ppoll` behaves like `poll`, but let you specify what signals may interrupt it
 /// with the `sigmask` argument. If you want `ppoll` to block indefinitely,
 /// specify `None` as `timeout` (it is like `timeout = -1` for `poll`).
+/// If `sigmask` is `None`, then no signal mask manipulation is performed,
+/// so in that case `ppoll` differs from `poll` only in the precision of the
+/// timeout argument.
 ///
 #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd", target_os = "linux"))]
-pub fn ppoll(fds: &mut [PollFd], timeout: Option<TimeSpec>, sigmask: SigSet) -> Result<libc::c_int> {
+pub fn ppoll(
+    fds: &mut [PollFd],
+    timeout: Option<crate::sys::time::TimeSpec>,
+    sigmask: Option<crate::sys::signal::SigSet>
+    ) -> Result<libc::c_int>
+{
     let timeout = timeout.as_ref().map_or(core::ptr::null(), |r| r.as_ref());
+    let sigmask = sigmask.as_ref().map_or(core::ptr::null(), |r| r.as_ref());
     let res = unsafe {
         libc::ppoll(fds.as_mut_ptr() as *mut libc::pollfd,
                     fds.len() as libc::nfds_t,
                     timeout,
-                    sigmask.as_ref())
+                    sigmask)
     };
     Errno::result(res)
 }
+}
diff --git a/src/pty.rs b/src/pty.rs
index facc9aa..28ae5e9 100644
--- a/src/pty.rs
+++ b/src/pty.rs
@@ -8,10 +8,11 @@ use std::io;
 use std::mem;
 use std::os::unix::prelude::*;
 
-use crate::sys::termios::Termios;
-use crate::unistd::{self, ForkResult, Pid};
-use crate::{Result, fcntl};
 use crate::errno::Errno;
+use crate::sys::termios::Termios;
+#[cfg(feature = "process")]
+use crate::unistd::{ForkResult, Pid};
+use crate::{fcntl, unistd, Result};
 
 /// Representation of a master/slave pty pair
 ///
@@ -25,6 +26,8 @@ pub struct OpenptyResult {
     pub slave: RawFd,
 }
 
+feature! {
+#![feature = "process"]
 /// Representation of a master with a forked pty
 ///
 /// This is returned by `forkpty`. Note that this type does *not* implement `Drop`, so the user
@@ -36,7 +39,7 @@ pub struct ForkptyResult {
     /// Metadata about forked process
     pub fork_result: ForkResult,
 }
-
+}
 
 /// Representation of the Master device in a master/slave pty pair
 ///
@@ -91,6 +94,21 @@ impl io::Write for PtyMaster {
     }
 }
 
+impl io::Read for &PtyMaster {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        unistd::read(self.0, buf).map_err(io::Error::from)
+    }
+}
+
+impl io::Write for &PtyMaster {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        unistd::write(self.0, buf).map_err(io::Error::from)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
 /// Grant access to a slave pseudoterminal (see
 /// [`grantpt(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/grantpt.html))
 ///
@@ -108,7 +126,7 @@ pub fn grantpt(fd: &PtyMaster) -> Result<()> {
 /// Open a pseudoterminal device (see
 /// [`posix_openpt(3)`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_openpt.html))
 ///
-/// `posix_openpt()` returns a file descriptor to an existing unused pseuterminal master device.
+/// `posix_openpt()` returns a file descriptor to an existing unused pseudoterminal master device.
 ///
 /// # Examples
 ///
@@ -140,9 +158,7 @@ pub fn grantpt(fd: &PtyMaster) -> Result<()> {
 /// ```
 #[inline]
 pub fn posix_openpt(flags: fcntl::OFlag) -> Result<PtyMaster> {
-    let fd = unsafe {
-        libc::posix_openpt(flags.bits())
-    };
+    let fd = unsafe { libc::posix_openpt(flags.bits()) };
 
     if fd < 0 {
         return Err(Errno::last());
@@ -188,6 +204,7 @@ pub unsafe fn ptsname(fd: &PtyMaster) -> Result<String> {
 /// This value is useful for opening the slave ptty once the master has already been opened with
 /// `posix_openpt()`.
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 #[inline]
 pub fn ptsname_r(fd: &PtyMaster) -> Result<String> {
     let mut name_buf = Vec::<libc::c_char>::with_capacity(64);
@@ -209,7 +226,7 @@ pub fn ptsname_r(fd: &PtyMaster) -> Result<String> {
 ///
 /// `unlockpt()` unlocks the slave pseudoterminal device corresponding to the master pseudoterminal
 /// referred to by `fd`. This must be called before trying to open the slave side of a
-/// pseuoterminal.
+/// pseudoterminal.
 #[inline]
 pub fn unlockpt(fd: &PtyMaster) -> Result<()> {
     if unsafe { libc::unlockpt(fd.as_raw_fd()) } < 0 {
@@ -219,7 +236,6 @@ pub fn unlockpt(fd: &PtyMaster) -> Result<()> {
     Ok(())
 }
 
-
 /// Create a new pseudoterminal, returning the slave and master file descriptors
 /// in `OpenptyResult`
 /// (see [`openpty`](https://man7.org/linux/man-pages/man3/openpty.3.html)).
@@ -228,7 +244,15 @@ pub fn unlockpt(fd: &PtyMaster) -> Result<()> {
 /// the values in `winsize`. If `termios` is not `None`, the pseudoterminal's
 /// terminal settings of the slave will be set to the values in `termios`.
 #[inline]
-pub fn openpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b Termios>>>(winsize: T, termios: U) -> Result<OpenptyResult> {
+pub fn openpty<
+    'a,
+    'b,
+    T: Into<Option<&'a Winsize>>,
+    U: Into<Option<&'b Termios>>,
+>(
+    winsize: T,
+    termios: U,
+) -> Result<OpenptyResult> {
     use std::ptr;
 
     let mut slave = mem::MaybeUninit::<libc::c_int>::uninit();
@@ -247,17 +271,15 @@ pub fn openpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b Termios>
                     )
                 }
             }
-            (None, Some(winsize)) => {
-                unsafe {
-                    libc::openpty(
-                        master.as_mut_ptr(),
-                        slave.as_mut_ptr(),
-                        ptr::null_mut(),
-                        ptr::null_mut(),
-                        winsize as *const Winsize as *mut _,
-                    )
-                }
-            }
+            (None, Some(winsize)) => unsafe {
+                libc::openpty(
+                    master.as_mut_ptr(),
+                    slave.as_mut_ptr(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    winsize as *const Winsize as *mut _,
+                )
+            },
             (Some(termios), None) => {
                 let inner_termios = termios.get_libc_termios();
                 unsafe {
@@ -270,17 +292,15 @@ pub fn openpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b Termios>
                     )
                 }
             }
-            (None, None) => {
-                unsafe {
-                    libc::openpty(
-                        master.as_mut_ptr(),
-                        slave.as_mut_ptr(),
-                        ptr::null_mut(),
-                        ptr::null_mut(),
-                        ptr::null_mut(),
-                    )
-                }
-            }
+            (None, None) => unsafe {
+                libc::openpty(
+                    master.as_mut_ptr(),
+                    slave.as_mut_ptr(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                    ptr::null_mut(),
+                )
+            },
         }
     };
 
@@ -294,6 +314,8 @@ pub fn openpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b Termios>
     }
 }
 
+feature! {
+#![feature = "process"]
 /// Create a new pseudoterminal, returning the master file descriptor and forked pid.
 /// in `ForkptyResult`
 /// (see [`forkpty`](https://man7.org/linux/man-pages/man3/forkpty.3.html)).
@@ -346,3 +368,4 @@ pub unsafe fn forkpty<'a, 'b, T: Into<Option<&'a Winsize>>, U: Into<Option<&'b T
         fork_result,
     })
 }
+}
diff --git a/src/sched.rs b/src/sched.rs
index c2dd7b8..d5b1233 100644
--- a/src/sched.rs
+++ b/src/sched.rs
@@ -8,14 +8,15 @@ use crate::{Errno, Result};
 pub use self::sched_linux_like::*;
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod sched_linux_like {
     use crate::errno::Errno;
+    use crate::unistd::Pid;
+    use crate::Result;
     use libc::{self, c_int, c_void};
     use std::mem;
     use std::option::Option;
     use std::os::unix::io::RawFd;
-    use crate::unistd::Pid;
-    use crate::Result;
 
     // For some functions taking with a parameter of type CloneFlags,
     // only a subset of these flags have an effect.
@@ -86,15 +87,94 @@ mod sched_linux_like {
     /// Type for the function executed by [`clone`].
     pub type CloneCb<'a> = Box<dyn FnMut() -> isize + 'a>;
 
+    /// `clone` create a child process
+    /// ([`clone(2)`](https://man7.org/linux/man-pages/man2/clone.2.html))
+    ///
+    /// `stack` is a reference to an array which will hold the stack of the new
+    /// process.  Unlike when calling `clone(2)` from C, the provided stack
+    /// address need not be the highest address of the region.  Nix will take
+    /// care of that requirement.  The user only needs to provide a reference to
+    /// a normally allocated buffer.
+    pub fn clone(
+        mut cb: CloneCb,
+        stack: &mut [u8],
+        flags: CloneFlags,
+        signal: Option<c_int>,
+    ) -> Result<Pid> {
+        extern "C" fn callback(data: *mut CloneCb) -> c_int {
+            let cb: &mut CloneCb = unsafe { &mut *data };
+            (*cb)() as c_int
+        }
+
+        let res = unsafe {
+            let combined = flags.bits() | signal.unwrap_or(0);
+            let ptr = stack.as_mut_ptr().add(stack.len());
+            let ptr_aligned = ptr.sub(ptr as usize % 16);
+            libc::clone(
+                mem::transmute(
+                    callback
+                        as extern "C" fn(*mut Box<dyn FnMut() -> isize>) -> i32,
+                ),
+                ptr_aligned as *mut c_void,
+                combined,
+                &mut cb as *mut _ as *mut c_void,
+            )
+        };
+
+        Errno::result(res).map(Pid::from_raw)
+    }
+
+    /// disassociate parts of the process execution context
+    ///
+    /// See also [unshare(2)](https://man7.org/linux/man-pages/man2/unshare.2.html)
+    pub fn unshare(flags: CloneFlags) -> Result<()> {
+        let res = unsafe { libc::unshare(flags.bits()) };
+
+        Errno::result(res).map(drop)
+    }
+
+    /// reassociate thread with a namespace
+    ///
+    /// See also [setns(2)](https://man7.org/linux/man-pages/man2/setns.2.html)
+    pub fn setns(fd: RawFd, nstype: CloneFlags) -> Result<()> {
+        let res = unsafe { libc::setns(fd, nstype.bits()) };
+
+        Errno::result(res).map(drop)
+    }
+}
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux"
+))]
+pub use self::sched_affinity::*;
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux"
+))]
+mod sched_affinity {
+    use crate::errno::Errno;
+    use crate::unistd::Pid;
+    use crate::Result;
+    use std::mem;
+
     /// CpuSet represent a bit-mask of CPUs.
     /// CpuSets are used by sched_setaffinity and
     /// sched_getaffinity for example.
     ///
     /// This is a wrapper around `libc::cpu_set_t`.
-    #[repr(C)]
+    #[repr(transparent)]
     #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
     pub struct CpuSet {
+        #[cfg(not(target_os = "freebsd"))]
         cpu_set: libc::cpu_set_t,
+        #[cfg(target_os = "freebsd")]
+        cpu_set: libc::cpuset_t,
     }
 
     impl CpuSet {
@@ -121,7 +201,9 @@ mod sched_linux_like {
             if field >= CpuSet::count() {
                 Err(Errno::EINVAL)
             } else {
-                unsafe { libc::CPU_SET(field, &mut self.cpu_set); }
+                unsafe {
+                    libc::CPU_SET(field, &mut self.cpu_set);
+                }
                 Ok(())
             }
         }
@@ -132,14 +214,21 @@ mod sched_linux_like {
             if field >= CpuSet::count() {
                 Err(Errno::EINVAL)
             } else {
-                unsafe { libc::CPU_CLR(field, &mut self.cpu_set);}
+                unsafe {
+                    libc::CPU_CLR(field, &mut self.cpu_set);
+                }
                 Ok(())
             }
         }
 
         /// Return the maximum number of CPU in CpuSet
         pub const fn count() -> usize {
-            8 * mem::size_of::<libc::cpu_set_t>()
+            #[cfg(not(target_os = "freebsd"))]
+            let bytes = mem::size_of::<libc::cpu_set_t>();
+            #[cfg(target_os = "freebsd")]
+            let bytes = mem::size_of::<libc::cpuset_t>();
+
+            8 * bytes
         }
     }
 
@@ -167,8 +256,8 @@ mod sched_linux_like {
     /// use nix::unistd::Pid;
     ///
     /// let mut cpu_set = CpuSet::new();
-    /// cpu_set.set(0);
-    /// sched_setaffinity(Pid::from_raw(0), &cpu_set);
+    /// cpu_set.set(0).unwrap();
+    /// sched_setaffinity(Pid::from_raw(0), &cpu_set).unwrap();
     /// ```
     pub fn sched_setaffinity(pid: Pid, cpuset: &CpuSet) -> Result<()> {
         let res = unsafe {
@@ -217,58 +306,11 @@ mod sched_linux_like {
         Errno::result(res).and(Ok(cpuset))
     }
 
-    /// `clone` create a child process
-    /// ([`clone(2)`](https://man7.org/linux/man-pages/man2/clone.2.html))
-    ///
-    /// `stack` is a reference to an array which will hold the stack of the new
-    /// process.  Unlike when calling `clone(2)` from C, the provided stack
-    /// address need not be the highest address of the region.  Nix will take
-    /// care of that requirement.  The user only needs to provide a reference to
-    /// a normally allocated buffer.
-    pub fn clone(
-        mut cb: CloneCb,
-        stack: &mut [u8],
-        flags: CloneFlags,
-        signal: Option<c_int>,
-    ) -> Result<Pid> {
-        extern "C" fn callback(data: *mut CloneCb) -> c_int {
-            let cb: &mut CloneCb = unsafe { &mut *data };
-            (*cb)() as c_int
-        }
+    /// Determines the CPU on which the calling thread is running.
+    pub fn sched_getcpu() -> Result<usize> {
+        let res = unsafe { libc::sched_getcpu() };
 
-        let res = unsafe {
-            let combined = flags.bits() | signal.unwrap_or(0);
-            let ptr = stack.as_mut_ptr().add(stack.len());
-            let ptr_aligned = ptr.sub(ptr as usize % 16);
-            libc::clone(
-                mem::transmute(
-                    callback as extern "C" fn(*mut Box<dyn FnMut() -> isize>) -> i32,
-                ),
-                ptr_aligned as *mut c_void,
-                combined,
-                &mut cb as *mut _ as *mut c_void,
-            )
-        };
-
-        Errno::result(res).map(Pid::from_raw)
-    }
-
-    /// disassociate parts of the process execution context
-    ///
-    /// See also [unshare(2)](https://man7.org/linux/man-pages/man2/unshare.2.html)
-    pub fn unshare(flags: CloneFlags) -> Result<()> {
-        let res = unsafe { libc::unshare(flags.bits()) };
-
-        Errno::result(res).map(drop)
-    }
-
-    /// reassociate thread with a namespace
-    ///
-    /// See also [setns(2)](https://man7.org/linux/man-pages/man2/setns.2.html)
-    pub fn setns(fd: RawFd, nstype: CloneFlags) -> Result<()> {
-        let res = unsafe { libc::setns(fd, nstype.bits()) };
-
-        Errno::result(res).map(drop)
+        Errno::result(res).map(|int| int as usize)
     }
 }
 
diff --git a/src/sys/aio.rs b/src/sys/aio.rs
index e64a2a8..e2ce19b 100644
--- a/src/sys/aio.rs
+++ b/src/sys/aio.rs
@@ -2,9 +2,12 @@
 //! POSIX Asynchronous I/O
 //!
 //! The POSIX AIO interface is used for asynchronous I/O on files and disk-like
-//! devices.  It supports [`read`](struct.AioCb.html#method.read),
-//! [`write`](struct.AioCb.html#method.write), and
-//! [`fsync`](struct.AioCb.html#method.fsync) operations.  Completion
+//! devices.  It supports [`read`](struct.AioRead.html#method.new),
+//! [`write`](struct.AioWrite.html#method.new),
+//! [`fsync`](struct.AioFsync.html#method.new),
+//! [`readv`](struct.AioReadv.html#method.new), and
+//! [`writev`](struct.AioWritev.html#method.new), operations, subject to
+//! platform support.  Completion
 //! notifications can optionally be delivered via
 //! [signals](../signal/enum.SigevNotify.html#variant.SigevSignal), via the
 //! [`aio_suspend`](fn.aio_suspend.html) function, or via polling.  Some
@@ -17,23 +20,29 @@
 //! that they will be executed atomically.
 //!
 //! Outstanding operations may be cancelled with
-//! [`cancel`](struct.AioCb.html#method.cancel) or
+//! [`cancel`](trait.Aio.html#method.cancel) or
 //! [`aio_cancel_all`](fn.aio_cancel_all.html), though the operating system may
 //! not support this for all filesystems and devices.
+#[cfg(target_os = "freebsd")]
+use std::io::{IoSlice, IoSliceMut};
+use std::{
+    convert::TryFrom,
+    fmt::{self, Debug},
+    marker::{PhantomData, PhantomPinned},
+    mem,
+    os::unix::io::RawFd,
+    pin::Pin,
+    ptr, thread,
+};
 
-use crate::Result;
-use crate::errno::Errno;
-use std::os::unix::io::RawFd;
-use libc::{c_void, off_t, size_t};
-use std::fmt;
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::mem;
-use std::pin::Pin;
-use std::ptr::{null, null_mut};
-use crate::sys::signal::*;
-use std::thread;
-use crate::sys::time::TimeSpec;
+use libc::{c_void, off_t};
+use pin_utils::unsafe_pinned;
+
+use crate::{
+    errno::Errno,
+    sys::{signal::*, time::TimeSpec},
+    Result,
+};
 
 libc_enum! {
     /// Mode for `AioCb::fsync`.  Controls whether only data or both data and
@@ -49,24 +58,10 @@ libc_enum! {
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         O_DSYNC
     }
-}
-
-libc_enum! {
-    /// When used with [`lio_listio`](fn.lio_listio.html), determines whether a
-    /// given `aiocb` should be used for a read operation, a write operation, or
-    /// ignored.  Has no effect for any other aio functions.
-    #[repr(i32)]
-    #[non_exhaustive]
-    pub enum LioOpcode {
-        /// No operation
-        LIO_NOP,
-        /// Write data as if by a call to [`AioCb::write`]
-        LIO_WRITE,
-        /// Write data as if by a call to [`AioCb::read`]
-        LIO_READ,
-    }
+    impl TryFrom<i32>
 }
 
 libc_enum! {
@@ -102,354 +97,133 @@ struct LibcAiocb(libc::aiocb);
 unsafe impl Send for LibcAiocb {}
 unsafe impl Sync for LibcAiocb {}
 
-/// AIO Control Block.
-///
-/// The basic structure used by all aio functions.  Each `AioCb` represents one
-/// I/O request.
-pub struct AioCb<'a> {
+/// Base class for all AIO operations.  Should only be used directly when
+/// checking for completion.
+// We could create some kind of AsPinnedMut trait, and implement it for all aio
+// ops, allowing the crate's users to get pinned references to `AioCb`.  That
+// could save some code for things like polling methods.  But IMHO it would
+// provide polymorphism at the wrong level.  Instead, the best place for
+// polymorphism is at the level of `Futures`.
+#[repr(C)]
+struct AioCb {
     aiocb: LibcAiocb,
-    /// Tracks whether the buffer pointed to by `libc::aiocb.aio_buf` is mutable
-    mutable: bool,
     /// Could this `AioCb` potentially have any in-kernel state?
+    // It would be really nice to perform the in-progress check entirely at
+    // compile time.  But I can't figure out how, because:
+    // * Future::poll takes a `Pin<&mut self>` rather than `self`, and
+    // * Rust's lack of an equivalent of C++'s Guaranteed Copy Elision means
+    //   that there's no way to write an AioCb constructor that neither boxes
+    //   the object itself, nor moves it during return.
     in_progress: bool,
-    _buffer: std::marker::PhantomData<&'a [u8]>,
-    _pin: std::marker::PhantomPinned
 }
 
-impl<'a> AioCb<'a> {
-    /// Returns the underlying file descriptor associated with the `AioCb`
-    pub fn fd(&self) -> RawFd {
-        self.aiocb.0.aio_fildes
-    }
+impl AioCb {
+    pin_utils::unsafe_unpinned!(aiocb: LibcAiocb);
 
-    /// Constructs a new `AioCb` with no associated buffer.
-    ///
-    /// The resulting `AioCb` structure is suitable for use with `AioCb::fsync`.
-    ///
-    /// # Parameters
-    ///
-    /// * `fd`:           File descriptor.  Required for all aio functions.
-    /// * `prio`:         If POSIX Prioritized IO is supported, then the
-    ///                   operation will be prioritized at the process's
-    ///                   priority level minus `prio`.
-    /// * `sigev_notify`: Determines how you will be notified of event
-    ///                    completion.
-    ///
-    /// # Examples
-    ///
-    /// Create an `AioCb` from a raw file descriptor and use it for an
-    /// [`fsync`](#method.fsync) operation.
-    ///
-    /// ```
-    /// # use nix::errno::Errno;
-    /// # use nix::Error;
-    /// # use nix::sys::aio::*;
-    /// # use nix::sys::signal::SigevNotify::SigevNone;
-    /// # use std::{thread, time};
-    /// # use std::os::unix::io::AsRawFd;
-    /// # use tempfile::tempfile;
-    /// let f = tempfile().unwrap();
-    /// let mut aiocb = AioCb::from_fd( f.as_raw_fd(), 0, SigevNone);
-    /// aiocb.fsync(AioFsyncMode::O_SYNC).expect("aio_fsync failed early");
-    /// while (aiocb.error() == Err(Errno::EINPROGRESS)) {
-    ///     thread::sleep(time::Duration::from_millis(10));
-    /// }
-    /// aiocb.aio_return().expect("aio_fsync failed late");
-    /// ```
-    pub fn from_fd(fd: RawFd, prio: libc::c_int,
-                    sigev_notify: SigevNotify) -> Pin<Box<AioCb<'a>>> {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = 0;
-        a.0.aio_nbytes = 0;
-        a.0.aio_buf = null_mut();
-
-        Box::pin(AioCb {
-            aiocb: a,
-            mutable: false,
-            in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned
-        })
+    fn aio_return(mut self: Pin<&mut Self>) -> Result<usize> {
+        self.in_progress = false;
+        unsafe {
+            let p: *mut libc::aiocb = &mut self.aiocb.0;
+            Errno::result(libc::aio_return(p))
+        }
+        .map(|r| r as usize)
     }
 
-    // Private helper
-    #[cfg(not(any(target_os = "ios", target_os = "macos")))]
-    fn from_mut_slice_unpinned(fd: RawFd, offs: off_t, buf: &'a mut [u8],
-                          prio: libc::c_int, sigev_notify: SigevNotify,
-                          opcode: LioOpcode) -> AioCb<'a>
-    {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = offs;
-        a.0.aio_nbytes = buf.len() as size_t;
-        a.0.aio_buf = buf.as_ptr() as *mut c_void;
-        a.0.aio_lio_opcode = opcode as libc::c_int;
+    fn cancel(mut self: Pin<&mut Self>) -> Result<AioCancelStat> {
+        let r = unsafe {
+            libc::aio_cancel(self.aiocb.0.aio_fildes, &mut self.aiocb.0)
+        };
+        match r {
+            libc::AIO_CANCELED => Ok(AioCancelStat::AioCanceled),
+            libc::AIO_NOTCANCELED => Ok(AioCancelStat::AioNotCanceled),
+            libc::AIO_ALLDONE => Ok(AioCancelStat::AioAllDone),
+            -1 => Err(Errno::last()),
+            _ => panic!("unknown aio_cancel return value"),
+        }
+    }
 
+    fn common_init(fd: RawFd, prio: i32, sigev_notify: SigevNotify) -> Self {
+        // Use mem::zeroed instead of explicitly zeroing each field, because the
+        // number and name of reserved fields is OS-dependent.  On some OSes,
+        // some reserved fields are used the kernel for state, and must be
+        // explicitly zeroed when allocated.
+        let mut a = unsafe { mem::zeroed::<libc::aiocb>() };
+        a.aio_fildes = fd;
+        a.aio_reqprio = prio;
+        a.aio_sigevent = SigEvent::new(sigev_notify).sigevent();
         AioCb {
-            aiocb: a,
-            mutable: true,
+            aiocb: LibcAiocb(a),
             in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned
         }
     }
 
-    /// Constructs a new `AioCb` from a mutable slice.
-    ///
-    /// The resulting `AioCb` will be suitable for both read and write
-    /// operations, but only if the borrow checker can guarantee that the slice
-    /// will outlive the `AioCb`.  That will usually be the case if the `AioCb`
-    /// is stack-allocated.
-    ///
-    /// # Parameters
-    ///
-    /// * `fd`:           File descriptor.  Required for all aio functions.
-    /// * `offs`:         File offset
-    /// * `buf`:          A memory buffer
-    /// * `prio`:         If POSIX Prioritized IO is supported, then the
-    ///                   operation will be prioritized at the process's
-    ///                   priority level minus `prio`
-    /// * `sigev_notify`: Determines how you will be notified of event
-    ///                   completion.
-    /// * `opcode`:       This field is only used for `lio_listio`.  It
-    ///                   determines which operation to use for this individual
-    ///                   aiocb
-    ///
-    /// # Examples
-    ///
-    /// Create an `AioCb` from a mutable slice and read into it.
-    ///
-    /// ```
-    /// # use nix::errno::Errno;
-    /// # use nix::Error;
-    /// # use nix::sys::aio::*;
-    /// # use nix::sys::signal::SigevNotify;
-    /// # use std::{thread, time};
-    /// # use std::io::Write;
-    /// # use std::os::unix::io::AsRawFd;
-    /// # use tempfile::tempfile;
-    /// const INITIAL: &[u8] = b"abcdef123456";
-    /// const LEN: usize = 4;
-    /// let mut rbuf = vec![0; LEN];
-    /// let mut f = tempfile().unwrap();
-    /// f.write_all(INITIAL).unwrap();
-    /// {
-    ///     let mut aiocb = AioCb::from_mut_slice( f.as_raw_fd(),
-    ///         2,   //offset
-    ///         &mut rbuf,
-    ///         0,   //priority
-    ///         SigevNotify::SigevNone,
-    ///         LioOpcode::LIO_NOP);
-    ///     aiocb.read().unwrap();
-    ///     while (aiocb.error() == Err(Errno::EINPROGRESS)) {
-    ///         thread::sleep(time::Duration::from_millis(10));
-    ///     }
-    ///     assert_eq!(aiocb.aio_return().unwrap() as usize, LEN);
-    /// }
-    /// assert_eq!(rbuf, b"cdef");
-    /// ```
-    pub fn from_mut_slice(fd: RawFd, offs: off_t, buf: &'a mut [u8],
-                          prio: libc::c_int, sigev_notify: SigevNotify,
-                          opcode: LioOpcode) -> Pin<Box<AioCb<'a>>> {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = offs;
-        a.0.aio_nbytes = buf.len() as size_t;
-        a.0.aio_buf = buf.as_ptr() as *mut c_void;
-        a.0.aio_lio_opcode = opcode as libc::c_int;
-
-        Box::pin(AioCb {
-            aiocb: a,
-            mutable: true,
-            in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned
-        })
+    fn error(self: Pin<&mut Self>) -> Result<()> {
+        let r = unsafe { libc::aio_error(&self.aiocb().0) };
+        match r {
+            0 => Ok(()),
+            num if num > 0 => Err(Errno::from_i32(num)),
+            -1 => Err(Errno::last()),
+            num => panic!("unknown aio_error return value {:?}", num),
+        }
     }
 
-    /// Constructs a new `AioCb` from a mutable raw pointer
-    ///
-    /// Unlike `from_mut_slice`, this method returns a structure suitable for
-    /// placement on the heap.  It may be used for both reads and writes.  Due
-    /// to its unsafety, this method is not recommended.  It is most useful when
-    /// heap allocation is required.
-    ///
-    /// # Parameters
-    ///
-    /// * `fd`:           File descriptor.  Required for all aio functions.
-    /// * `offs`:         File offset
-    /// * `buf`:          Pointer to the memory buffer
-    /// * `len`:          Length of the buffer pointed to by `buf`
-    /// * `prio`:         If POSIX Prioritized IO is supported, then the
-    ///                   operation will be prioritized at the process's
-    ///                   priority level minus `prio`
-    /// * `sigev_notify`: Determines how you will be notified of event
-    ///                   completion.
-    /// * `opcode`:       This field is only used for `lio_listio`.  It
-    ///                   determines which operation to use for this individual
-    ///                   aiocb
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the storage pointed to by `buf` outlives the
-    /// `AioCb`.  The lifetime checker can't help here.
-    pub unsafe fn from_mut_ptr(fd: RawFd, offs: off_t,
-                           buf: *mut c_void, len: usize,
-                           prio: libc::c_int, sigev_notify: SigevNotify,
-                           opcode: LioOpcode) -> Pin<Box<AioCb<'a>>> {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = offs;
-        a.0.aio_nbytes = len;
-        a.0.aio_buf = buf;
-        a.0.aio_lio_opcode = opcode as libc::c_int;
-
-        Box::pin(AioCb {
-            aiocb: a,
-            mutable: true,
-            in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned,
-        })
+    fn in_progress(&self) -> bool {
+        self.in_progress
     }
 
-    /// Constructs a new `AioCb` from a raw pointer.
-    ///
-    /// Unlike `from_slice`, this method returns a structure suitable for
-    /// placement on the heap.  Due to its unsafety, this method is not
-    /// recommended.  It is most useful when heap allocation is required.
-    ///
-    /// # Parameters
-    ///
-    /// * `fd`:           File descriptor.  Required for all aio functions.
-    /// * `offs`:         File offset
-    /// * `buf`:          Pointer to the memory buffer
-    /// * `len`:          Length of the buffer pointed to by `buf`
-    /// * `prio`:         If POSIX Prioritized IO is supported, then the
-    ///                   operation will be prioritized at the process's
-    ///                   priority level minus `prio`
-    /// * `sigev_notify`: Determines how you will be notified of event
-    ///                   completion.
-    /// * `opcode`:       This field is only used for `lio_listio`.  It
-    ///                   determines which operation to use for this individual
-    ///                   aiocb
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the storage pointed to by `buf` outlives the
-    /// `AioCb`.  The lifetime checker can't help here.
-    pub unsafe fn from_ptr(fd: RawFd, offs: off_t,
-                           buf: *const c_void, len: usize,
-                           prio: libc::c_int, sigev_notify: SigevNotify,
-                           opcode: LioOpcode) -> Pin<Box<AioCb<'a>>> {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = offs;
-        a.0.aio_nbytes = len;
-        // casting a const ptr to a mutable ptr here is ok, because we set the
-        // AioCb's mutable field to false
-        a.0.aio_buf = buf as *mut c_void;
-        a.0.aio_lio_opcode = opcode as libc::c_int;
-
-        Box::pin(AioCb {
-            aiocb: a,
-            mutable: false,
-            in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned
-        })
+    fn set_in_progress(mut self: Pin<&mut Self>) {
+        self.as_mut().in_progress = true;
     }
 
-    // Private helper
-    fn from_slice_unpinned(fd: RawFd, offs: off_t, buf: &'a [u8],
-                           prio: libc::c_int, sigev_notify: SigevNotify,
-                           opcode: LioOpcode) -> AioCb
-    {
-        let mut a = AioCb::common_init(fd, prio, sigev_notify);
-        a.0.aio_offset = offs;
-        a.0.aio_nbytes = buf.len() as size_t;
-        // casting an immutable buffer to a mutable pointer looks unsafe,
-        // but technically its only unsafe to dereference it, not to create
-        // it.
-        a.0.aio_buf = buf.as_ptr() as *mut c_void;
-        assert!(opcode != LioOpcode::LIO_READ, "Can't read into an immutable buffer");
-        a.0.aio_lio_opcode = opcode as libc::c_int;
-
-        AioCb {
-            aiocb: a,
-            mutable: false,
-            in_progress: false,
-            _buffer: PhantomData,
-            _pin: std::marker::PhantomPinned
-        }
+    /// Update the notification settings for an existing AIO operation that has
+    /// not yet been submitted.
+    // Takes a normal reference rather than a pinned one because this method is
+    // normally called before the object needs to be pinned, that is, before
+    // it's been submitted to the kernel.
+    fn set_sigev_notify(&mut self, sigev_notify: SigevNotify) {
+        assert!(
+            !self.in_progress,
+            "Can't change notification settings for an in-progress operation"
+        );
+        self.aiocb.0.aio_sigevent = SigEvent::new(sigev_notify).sigevent();
     }
+}
 
-    /// Like [`AioCb::from_mut_slice`], but works on constant slices rather than
-    /// mutable slices.
-    ///
-    /// An `AioCb` created this way cannot be used with `read`, and its
-    /// `LioOpcode` cannot be set to `LIO_READ`.  This method is useful when
-    /// writing a const buffer with `AioCb::write`, since `from_mut_slice` can't
-    /// work with const buffers.
-    ///
-    /// # Examples
-    ///
-    /// Construct an `AioCb` from a slice and use it for writing.
-    ///
-    /// ```
-    /// # use nix::errno::Errno;
-    /// # use nix::Error;
-    /// # use nix::sys::aio::*;
-    /// # use nix::sys::signal::SigevNotify;
-    /// # use std::{thread, time};
-    /// # use std::os::unix::io::AsRawFd;
-    /// # use tempfile::tempfile;
-    /// const WBUF: &[u8] = b"abcdef123456";
-    /// let mut f = tempfile().unwrap();
-    /// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-    ///     2,   //offset
-    ///     WBUF,
-    ///     0,   //priority
-    ///     SigevNotify::SigevNone,
-    ///     LioOpcode::LIO_NOP);
-    /// aiocb.write().unwrap();
-    /// while (aiocb.error() == Err(Errno::EINPROGRESS)) {
-    ///     thread::sleep(time::Duration::from_millis(10));
-    /// }
-    /// assert_eq!(aiocb.aio_return().unwrap() as usize, WBUF.len());
-    /// ```
-    // Note: another solution to the problem of writing const buffers would be
-    // to genericize AioCb for both &mut [u8] and &[u8] buffers.  AioCb::read
-    // could take the former and AioCb::write could take the latter.  However,
-    // then lio_listio wouldn't work, because that function needs a slice of
-    // AioCb, and they must all be of the same type.
-    pub fn from_slice(fd: RawFd, offs: off_t, buf: &'a [u8],
-                      prio: libc::c_int, sigev_notify: SigevNotify,
-                      opcode: LioOpcode) -> Pin<Box<AioCb>>
-    {
-        Box::pin(AioCb::from_slice_unpinned(fd, offs, buf, prio, sigev_notify,
-                                            opcode))
+impl Debug for AioCb {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AioCb")
+            .field("aiocb", &self.aiocb.0)
+            .field("in_progress", &self.in_progress)
+            .finish()
     }
+}
 
-    fn common_init(fd: RawFd, prio: libc::c_int,
-                   sigev_notify: SigevNotify) -> LibcAiocb {
-        // Use mem::zeroed instead of explicitly zeroing each field, because the
-        // number and name of reserved fields is OS-dependent.  On some OSes,
-        // some reserved fields are used the kernel for state, and must be
-        // explicitly zeroed when allocated.
-        let mut a = unsafe { mem::zeroed::<libc::aiocb>()};
-        a.aio_fildes = fd;
-        a.aio_reqprio = prio;
-        a.aio_sigevent = SigEvent::new(sigev_notify).sigevent();
-        LibcAiocb(a)
+impl Drop for AioCb {
+    /// If the `AioCb` has no remaining state in the kernel, just drop it.
+    /// Otherwise, dropping constitutes a resource leak, which is an error
+    fn drop(&mut self) {
+        assert!(
+            thread::panicking() || !self.in_progress,
+            "Dropped an in-progress AioCb"
+        );
     }
+}
 
-    /// Update the notification settings for an existing `aiocb`
-    pub fn set_sigev_notify(self: &mut Pin<Box<Self>>,
-                            sigev_notify: SigevNotify)
-    {
-        // Safe because we don't move any of the data
-        let selfp = unsafe {
-            self.as_mut().get_unchecked_mut()
-        };
-        selfp.aiocb.0.aio_sigevent = SigEvent::new(sigev_notify).sigevent();
-    }
+/// Methods common to all AIO operations
+pub trait Aio {
+    /// The return type of [`Aio::aio_return`].
+    type Output;
+
+    /// Retrieve return status of an asynchronous operation.
+    ///
+    /// Should only be called once for each operation, after [`Aio::error`]
+    /// indicates that it has completed.  The result is the same as for the
+    /// synchronous `read(2)`, `write(2)`, of `fsync(2)` functions.
+    ///
+    /// # References
+    ///
+    /// [aio_return](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_return.html)
+    fn aio_return(self: Pin<&mut Self>) -> Result<Self::Output>;
 
     /// Cancels an outstanding AIO request.
     ///
@@ -476,51 +250,26 @@ impl<'a> AioCb<'a> {
     /// # use tempfile::tempfile;
     /// let wbuf = b"CDEF";
     /// let mut f = tempfile().unwrap();
-    /// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
+    /// let mut aiocb = Box::pin(AioWrite::new(f.as_raw_fd(),
     ///     2,   //offset
     ///     &wbuf[..],
     ///     0,   //priority
-    ///     SigevNotify::SigevNone,
-    ///     LioOpcode::LIO_NOP);
-    /// aiocb.write().unwrap();
-    /// let cs = aiocb.cancel().unwrap();
+    ///     SigevNotify::SigevNone));
+    /// aiocb.as_mut().submit().unwrap();
+    /// let cs = aiocb.as_mut().cancel().unwrap();
     /// if cs == AioCancelStat::AioNotCanceled {
-    ///     while (aiocb.error() == Err(Errno::EINPROGRESS)) {
+    ///     while (aiocb.as_mut().error() == Err(Errno::EINPROGRESS)) {
     ///         thread::sleep(time::Duration::from_millis(10));
     ///     }
     /// }
     /// // Must call `aio_return`, but ignore the result
-    /// let _ = aiocb.aio_return();
+    /// let _ = aiocb.as_mut().aio_return();
     /// ```
     ///
     /// # References
     ///
     /// [aio_cancel](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_cancel.html)
-    pub fn cancel(self: &mut Pin<Box<Self>>) -> Result<AioCancelStat> {
-        let r = unsafe {
-            let selfp = self.as_mut().get_unchecked_mut();
-            libc::aio_cancel(selfp.aiocb.0.aio_fildes, &mut selfp.aiocb.0)
-        };
-        match r {
-            libc::AIO_CANCELED => Ok(AioCancelStat::AioCanceled),
-            libc::AIO_NOTCANCELED => Ok(AioCancelStat::AioNotCanceled),
-            libc::AIO_ALLDONE => Ok(AioCancelStat::AioAllDone),
-            -1 => Err(Errno::last()),
-            _ => panic!("unknown aio_cancel return value")
-        }
-    }
-
-    fn error_unpinned(&mut self) -> Result<()> {
-        let r = unsafe {
-            libc::aio_error(&mut self.aiocb.0 as *mut libc::aiocb)
-        };
-        match r {
-            0 => Ok(()),
-            num if num > 0 => Err(Errno::from_i32(num)),
-            -1 => Err(Errno::last()),
-            num => panic!("unknown aio_error return value {:?}", num)
-        }
-    }
+    fn cancel(self: Pin<&mut Self>) -> Result<AioCancelStat>;
 
     /// Retrieve error status of an asynchronous operation.
     ///
@@ -542,60 +291,265 @@ impl<'a> AioCb<'a> {
     /// # use tempfile::tempfile;
     /// const WBUF: &[u8] = b"abcdef123456";
     /// let mut f = tempfile().unwrap();
-    /// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
+    /// let mut aiocb = Box::pin(AioWrite::new(f.as_raw_fd(),
     ///     2,   //offset
     ///     WBUF,
     ///     0,   //priority
-    ///     SigevNotify::SigevNone,
-    ///     LioOpcode::LIO_NOP);
-    /// aiocb.write().unwrap();
-    /// while (aiocb.error() == Err(Errno::EINPROGRESS)) {
+    ///     SigevNotify::SigevNone));
+    /// aiocb.as_mut().submit().unwrap();
+    /// while (aiocb.as_mut().error() == Err(Errno::EINPROGRESS)) {
     ///     thread::sleep(time::Duration::from_millis(10));
     /// }
-    /// assert_eq!(aiocb.aio_return().unwrap() as usize, WBUF.len());
+    /// assert_eq!(aiocb.as_mut().aio_return().unwrap(), WBUF.len());
     /// ```
     ///
     /// # References
     ///
     /// [aio_error](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_error.html)
-    pub fn error(self: &mut Pin<Box<Self>>) -> Result<()> {
-        // Safe because error_unpinned doesn't move the data
-        let selfp = unsafe {
-            self.as_mut().get_unchecked_mut()
-        };
-        selfp.error_unpinned()
-    }
+    fn error(self: Pin<&mut Self>) -> Result<()>;
+
+    /// Returns the underlying file descriptor associated with the operation.
+    fn fd(&self) -> RawFd;
 
-    /// An asynchronous version of `fsync(2)`.
+    /// Does this operation currently have any in-kernel state?
     ///
-    /// # References
+    /// Dropping an operation that does have in-kernel state constitutes a
+    /// resource leak.
     ///
-    /// [aio_fsync](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_fsync.html)
-    pub fn fsync(self: &mut Pin<Box<Self>>, mode: AioFsyncMode) -> Result<()> {
-        // Safe because we don't move the libc::aiocb
-        unsafe {
-            let selfp = self.as_mut().get_unchecked_mut();
-            Errno::result({
-                let p: *mut libc::aiocb = &mut selfp.aiocb.0;
-                libc::aio_fsync(mode as libc::c_int, p)
-            }).map(|_| {
-                selfp.in_progress = true;
+    /// # Examples
+    ///
+    /// ```
+    /// # use nix::errno::Errno;
+    /// # use nix::Error;
+    /// # use nix::sys::aio::*;
+    /// # use nix::sys::signal::SigevNotify::SigevNone;
+    /// # use std::{thread, time};
+    /// # use std::os::unix::io::AsRawFd;
+    /// # use tempfile::tempfile;
+    /// let f = tempfile().unwrap();
+    /// let mut aiof = Box::pin(AioFsync::new(f.as_raw_fd(), AioFsyncMode::O_SYNC,
+    ///     0, SigevNone));
+    /// assert!(!aiof.as_mut().in_progress());
+    /// aiof.as_mut().submit().expect("aio_fsync failed early");
+    /// assert!(aiof.as_mut().in_progress());
+    /// while (aiof.as_mut().error() == Err(Errno::EINPROGRESS)) {
+    ///     thread::sleep(time::Duration::from_millis(10));
+    /// }
+    /// aiof.as_mut().aio_return().expect("aio_fsync failed late");
+    /// assert!(!aiof.as_mut().in_progress());
+    /// ```
+    fn in_progress(&self) -> bool;
+
+    /// Returns the priority of the `AioCb`
+    fn priority(&self) -> i32;
+
+    /// Update the notification settings for an existing AIO operation that has
+    /// not yet been submitted.
+    fn set_sigev_notify(&mut self, sev: SigevNotify);
+
+    /// Returns the `SigEvent` that will be used for notification.
+    fn sigevent(&self) -> SigEvent;
+
+    /// Actually start the I/O operation.
+    ///
+    /// After calling this method and until [`Aio::aio_return`] returns `Ok`,
+    /// the structure may not be moved in memory.
+    fn submit(self: Pin<&mut Self>) -> Result<()>;
+}
+
+macro_rules! aio_methods {
+    () => {
+        fn cancel(self: Pin<&mut Self>) -> Result<AioCancelStat> {
+            self.aiocb().cancel()
+        }
+
+        fn error(self: Pin<&mut Self>) -> Result<()> {
+            self.aiocb().error()
+        }
+
+        fn fd(&self) -> RawFd {
+            self.aiocb.aiocb.0.aio_fildes
+        }
+
+        fn in_progress(&self) -> bool {
+            self.aiocb.in_progress()
+        }
+
+        fn priority(&self) -> i32 {
+            self.aiocb.aiocb.0.aio_reqprio
+        }
+
+        fn set_sigev_notify(&mut self, sev: SigevNotify) {
+            self.aiocb.set_sigev_notify(sev)
+        }
+
+        fn sigevent(&self) -> SigEvent {
+            SigEvent::from(&self.aiocb.aiocb.0.aio_sigevent)
+        }
+    };
+    ($func:ident) => {
+        aio_methods!();
+
+        fn aio_return(self: Pin<&mut Self>) -> Result<<Self as Aio>::Output> {
+            self.aiocb().aio_return()
+        }
+
+        fn submit(mut self: Pin<&mut Self>) -> Result<()> {
+            let p: *mut libc::aiocb = &mut self.as_mut().aiocb().aiocb.0;
+            Errno::result({ unsafe { libc::$func(p) } }).map(|_| {
+                self.aiocb().set_in_progress();
             })
         }
+    };
+}
+
+/// An asynchronous version of `fsync(2)`.
+///
+/// # References
+///
+/// [aio_fsync](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_fsync.html)
+/// # Examples
+///
+/// ```
+/// # use nix::errno::Errno;
+/// # use nix::Error;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify::SigevNone;
+/// # use std::{thread, time};
+/// # use std::os::unix::io::AsRawFd;
+/// # use tempfile::tempfile;
+/// let f = tempfile().unwrap();
+/// let mut aiof = Box::pin(AioFsync::new(f.as_raw_fd(), AioFsyncMode::O_SYNC,
+///     0, SigevNone));
+/// aiof.as_mut().submit().expect("aio_fsync failed early");
+/// while (aiof.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///     thread::sleep(time::Duration::from_millis(10));
+/// }
+/// aiof.as_mut().aio_return().expect("aio_fsync failed late");
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AioFsync {
+    aiocb: AioCb,
+    _pin: PhantomPinned,
+}
+
+impl AioFsync {
+    unsafe_pinned!(aiocb: AioCb);
+
+    /// Returns the operation's fsync mode: data and metadata or data only?
+    pub fn mode(&self) -> AioFsyncMode {
+        AioFsyncMode::try_from(self.aiocb.aiocb.0.aio_lio_opcode).unwrap()
     }
 
-    /// Returns the `aiocb`'s `LioOpcode` field
+    /// Create a new `AioFsync`.
     ///
-    /// If the value cannot be represented as an `LioOpcode`, returns `None`
-    /// instead.
-    pub fn lio_opcode(&self) -> Option<LioOpcode> {
-        match self.aiocb.0.aio_lio_opcode {
-            libc::LIO_READ => Some(LioOpcode::LIO_READ),
-            libc::LIO_WRITE => Some(LioOpcode::LIO_WRITE),
-            libc::LIO_NOP => Some(LioOpcode::LIO_NOP),
-            _ => None
+    /// # Arguments
+    ///
+    /// * `fd`:           File descriptor to sync.
+    /// * `mode`:         Whether to sync file metadata too, or just data.
+    /// * `prio`:         If POSIX Prioritized IO is supported, then the
+    ///                   operation will be prioritized at the process's
+    ///                   priority level minus `prio`.
+    /// * `sigev_notify`: Determines how you will be notified of event
+    ///                   completion.
+    pub fn new(
+        fd: RawFd,
+        mode: AioFsyncMode,
+        prio: i32,
+        sigev_notify: SigevNotify,
+    ) -> Self {
+        let mut aiocb = AioCb::common_init(fd, prio, sigev_notify);
+        // To save some memory, store mode in an unused field of the AioCb.
+        // True it isn't very much memory, but downstream creates will likely
+        // create an enum containing this and other AioCb variants and pack
+        // those enums into data structures like Vec, so it adds up.
+        aiocb.aiocb.0.aio_lio_opcode = mode as libc::c_int;
+        AioFsync {
+            aiocb,
+            _pin: PhantomPinned,
         }
     }
+}
+
+impl Aio for AioFsync {
+    type Output = ();
+
+    aio_methods!();
+
+    fn aio_return(self: Pin<&mut Self>) -> Result<()> {
+        self.aiocb().aio_return().map(drop)
+    }
+
+    fn submit(mut self: Pin<&mut Self>) -> Result<()> {
+        let aiocb = &mut self.as_mut().aiocb().aiocb.0;
+        let mode = mem::replace(&mut aiocb.aio_lio_opcode, 0);
+        let p: *mut libc::aiocb = aiocb;
+        Errno::result(unsafe { libc::aio_fsync(mode, p) }).map(|_| {
+            self.aiocb().set_in_progress();
+        })
+    }
+}
+
+// AioFsync does not need AsMut, since it can't be used with lio_listio
+
+impl AsRef<libc::aiocb> for AioFsync {
+    fn as_ref(&self) -> &libc::aiocb {
+        &self.aiocb.aiocb.0
+    }
+}
+
+/// Asynchronously reads from a file descriptor into a buffer
+///
+/// # References
+///
+/// [aio_read](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_read.html)
+///
+/// # Examples
+///
+///
+/// ```
+/// # use nix::errno::Errno;
+/// # use nix::Error;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use std::{thread, time};
+/// # use std::io::Write;
+/// # use std::os::unix::io::AsRawFd;
+/// # use tempfile::tempfile;
+/// const INITIAL: &[u8] = b"abcdef123456";
+/// const LEN: usize = 4;
+/// let mut rbuf = vec![0; LEN];
+/// let mut f = tempfile().unwrap();
+/// f.write_all(INITIAL).unwrap();
+/// {
+///     let mut aior = Box::pin(
+///         AioRead::new(
+///             f.as_raw_fd(),
+///             2,   //offset
+///             &mut rbuf,
+///             0,   //priority
+///             SigevNotify::SigevNone
+///         )
+///     );
+///     aior.as_mut().submit().unwrap();
+///     while (aior.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///         thread::sleep(time::Duration::from_millis(10));
+///     }
+///     assert_eq!(aior.as_mut().aio_return().unwrap(), LEN);
+/// }
+/// assert_eq!(rbuf, b"cdef");
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AioRead<'a> {
+    aiocb: AioCb,
+    _data: PhantomData<&'a [u8]>,
+    _pin: PhantomPinned,
+}
+
+impl<'a> AioRead<'a> {
+    unsafe_pinned!(aiocb: AioCb);
 
     /// Returns the requested length of the aio operation in bytes
     ///
@@ -603,85 +557,418 @@ impl<'a> AioCb<'a> {
     /// number of bytes actually read or written by a completed operation, use
     /// `aio_return` instead.
     pub fn nbytes(&self) -> usize {
-        self.aiocb.0.aio_nbytes
+        self.aiocb.aiocb.0.aio_nbytes
     }
 
-    /// Returns the file offset stored in the `AioCb`
+    /// Create a new `AioRead`, placing the data in a mutable slice.
+    ///
+    /// # Arguments
+    ///
+    /// * `fd`:           File descriptor to read from
+    /// * `offs`:         File offset
+    /// * `buf`:          A memory buffer.  It must outlive the `AioRead`.
+    /// * `prio`:         If POSIX Prioritized IO is supported, then the
+    ///                   operation will be prioritized at the process's
+    ///                   priority level minus `prio`
+    /// * `sigev_notify`: Determines how you will be notified of event
+    ///                   completion.
+    pub fn new(
+        fd: RawFd,
+        offs: off_t,
+        buf: &'a mut [u8],
+        prio: i32,
+        sigev_notify: SigevNotify,
+    ) -> Self {
+        let mut aiocb = AioCb::common_init(fd, prio, sigev_notify);
+        aiocb.aiocb.0.aio_nbytes = buf.len();
+        aiocb.aiocb.0.aio_buf = buf.as_mut_ptr() as *mut c_void;
+        aiocb.aiocb.0.aio_lio_opcode = libc::LIO_READ;
+        aiocb.aiocb.0.aio_offset = offs;
+        AioRead {
+            aiocb,
+            _data: PhantomData,
+            _pin: PhantomPinned,
+        }
+    }
+
+    /// Returns the file offset of the operation.
     pub fn offset(&self) -> off_t {
-        self.aiocb.0.aio_offset
+        self.aiocb.aiocb.0.aio_offset
+    }
+}
+
+impl<'a> Aio for AioRead<'a> {
+    type Output = usize;
+
+    aio_methods!(aio_read);
+}
+
+impl<'a> AsMut<libc::aiocb> for AioRead<'a> {
+    fn as_mut(&mut self) -> &mut libc::aiocb {
+        &mut self.aiocb.aiocb.0
     }
+}
 
-    /// Returns the priority of the `AioCb`
-    pub fn priority(&self) -> libc::c_int {
-        self.aiocb.0.aio_reqprio
+impl<'a> AsRef<libc::aiocb> for AioRead<'a> {
+    fn as_ref(&self) -> &libc::aiocb {
+        &self.aiocb.aiocb.0
     }
+}
 
-    /// Asynchronously reads from a file descriptor into a buffer
+/// Asynchronously reads from a file descriptor into a scatter/gather list of buffers.
+///
+/// # References
+///
+/// [aio_readv](https://www.freebsd.org/cgi/man.cgi?query=aio_readv)
+///
+/// # Examples
+///
+///
+#[cfg_attr(fbsd14, doc = " ```")]
+#[cfg_attr(not(fbsd14), doc = " ```no_run")]
+/// # use nix::errno::Errno;
+/// # use nix::Error;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use std::{thread, time};
+/// # use std::io::{IoSliceMut, Write};
+/// # use std::os::unix::io::AsRawFd;
+/// # use tempfile::tempfile;
+/// const INITIAL: &[u8] = b"abcdef123456";
+/// let mut rbuf0 = vec![0; 4];
+/// let mut rbuf1 = vec![0; 2];
+/// let expected_len = rbuf0.len() + rbuf1.len();
+/// let mut rbufs = [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+/// let mut f = tempfile().unwrap();
+/// f.write_all(INITIAL).unwrap();
+/// {
+///     let mut aior = Box::pin(
+///         AioReadv::new(
+///             f.as_raw_fd(),
+///             2,   //offset
+///             &mut rbufs,
+///             0,   //priority
+///             SigevNotify::SigevNone
+///         )
+///     );
+///     aior.as_mut().submit().unwrap();
+///     while (aior.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///         thread::sleep(time::Duration::from_millis(10));
+///     }
+///     assert_eq!(aior.as_mut().aio_return().unwrap(), expected_len);
+/// }
+/// assert_eq!(rbuf0, b"cdef");
+/// assert_eq!(rbuf1, b"12");
+/// ```
+#[cfg(target_os = "freebsd")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AioReadv<'a> {
+    aiocb: AioCb,
+    _data: PhantomData<&'a [&'a [u8]]>,
+    _pin: PhantomPinned,
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AioReadv<'a> {
+    unsafe_pinned!(aiocb: AioCb);
+
+    /// Returns the number of buffers the operation will read into.
+    pub fn iovlen(&self) -> usize {
+        self.aiocb.aiocb.0.aio_nbytes
+    }
+
+    /// Create a new `AioReadv`, placing the data in a list of mutable slices.
     ///
-    /// # References
+    /// # Arguments
     ///
-    /// [aio_read](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_read.html)
-    pub fn read(self: &mut Pin<Box<Self>>) -> Result<()> {
-        assert!(self.mutable, "Can't read into an immutable buffer");
-        // Safe because we don't move anything
-        let selfp = unsafe {
-            self.as_mut().get_unchecked_mut()
-        };
-        Errno::result({
-            let p: *mut libc::aiocb = &mut selfp.aiocb.0;
-            unsafe { libc::aio_read(p) }
-        }).map(|_| {
-            selfp.in_progress = true;
-        })
+    /// * `fd`:           File descriptor to read from
+    /// * `offs`:         File offset
+    /// * `bufs`:         A scatter/gather list of memory buffers.  They must
+    ///                   outlive the `AioReadv`.
+    /// * `prio`:         If POSIX Prioritized IO is supported, then the
+    ///                   operation will be prioritized at the process's
+    ///                   priority level minus `prio`
+    /// * `sigev_notify`: Determines how you will be notified of event
+    ///                   completion.
+    pub fn new(
+        fd: RawFd,
+        offs: off_t,
+        bufs: &mut [IoSliceMut<'a>],
+        prio: i32,
+        sigev_notify: SigevNotify,
+    ) -> Self {
+        let mut aiocb = AioCb::common_init(fd, prio, sigev_notify);
+        // In vectored mode, aio_nbytes stores the length of the iovec array,
+        // not the byte count.
+        aiocb.aiocb.0.aio_nbytes = bufs.len();
+        aiocb.aiocb.0.aio_buf = bufs.as_mut_ptr() as *mut c_void;
+        aiocb.aiocb.0.aio_lio_opcode = libc::LIO_READV;
+        aiocb.aiocb.0.aio_offset = offs;
+        AioReadv {
+            aiocb,
+            _data: PhantomData,
+            _pin: PhantomPinned,
+        }
     }
 
-    /// Returns the `SigEvent` stored in the `AioCb`
-    pub fn sigevent(&self) -> SigEvent {
-        SigEvent::from(&self.aiocb.0.aio_sigevent)
+    /// Returns the file offset of the operation.
+    pub fn offset(&self) -> off_t {
+        self.aiocb.aiocb.0.aio_offset
     }
+}
 
-    fn aio_return_unpinned(&mut self) -> Result<isize> {
-        unsafe {
-            let p: *mut libc::aiocb = &mut self.aiocb.0;
-            self.in_progress = false;
-            Errno::result(libc::aio_return(p))
-        }
+#[cfg(target_os = "freebsd")]
+impl<'a> Aio for AioReadv<'a> {
+    type Output = usize;
+
+    aio_methods!(aio_readv);
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AsMut<libc::aiocb> for AioReadv<'a> {
+    fn as_mut(&mut self) -> &mut libc::aiocb {
+        &mut self.aiocb.aiocb.0
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AsRef<libc::aiocb> for AioReadv<'a> {
+    fn as_ref(&self) -> &libc::aiocb {
+        &self.aiocb.aiocb.0
     }
+}
 
-    /// Retrieve return status of an asynchronous operation.
+/// Asynchronously writes from a buffer to a file descriptor
+///
+/// # References
+///
+/// [aio_write](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_write.html)
+///
+/// # Examples
+///
+/// ```
+/// # use nix::errno::Errno;
+/// # use nix::Error;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use std::{thread, time};
+/// # use std::os::unix::io::AsRawFd;
+/// # use tempfile::tempfile;
+/// const WBUF: &[u8] = b"abcdef123456";
+/// let mut f = tempfile().unwrap();
+/// let mut aiow = Box::pin(
+///     AioWrite::new(
+///         f.as_raw_fd(),
+///         2,   //offset
+///         WBUF,
+///         0,   //priority
+///         SigevNotify::SigevNone
+///     )
+/// );
+/// aiow.as_mut().submit().unwrap();
+/// while (aiow.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///     thread::sleep(time::Duration::from_millis(10));
+/// }
+/// assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AioWrite<'a> {
+    aiocb: AioCb,
+    _data: PhantomData<&'a [u8]>,
+    _pin: PhantomPinned,
+}
+
+impl<'a> AioWrite<'a> {
+    unsafe_pinned!(aiocb: AioCb);
+
+    /// Returns the requested length of the aio operation in bytes
     ///
-    /// Should only be called once for each `AioCb`, after `AioCb::error`
-    /// indicates that it has completed.  The result is the same as for the
-    /// synchronous `read(2)`, `write(2)`, of `fsync(2)` functions.
+    /// This method returns the *requested* length of the operation.  To get the
+    /// number of bytes actually read or written by a completed operation, use
+    /// `aio_return` instead.
+    pub fn nbytes(&self) -> usize {
+        self.aiocb.aiocb.0.aio_nbytes
+    }
+
+    /// Construct a new `AioWrite`.
     ///
-    /// # References
+    /// # Arguments
     ///
-    /// [aio_return](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_return.html)
-    // Note: this should be just `return`, but that's a reserved word
-    pub fn aio_return(self: &mut Pin<Box<Self>>) -> Result<isize> {
-        // Safe because aio_return_unpinned does not move the data
-        let selfp = unsafe {
-            self.as_mut().get_unchecked_mut()
-        };
-        selfp.aio_return_unpinned()
+    /// * `fd`:           File descriptor to write to
+    /// * `offs`:         File offset
+    /// * `buf`:          A memory buffer.  It must outlive the `AioWrite`.
+    /// * `prio`:         If POSIX Prioritized IO is supported, then the
+    ///                   operation will be prioritized at the process's
+    ///                   priority level minus `prio`
+    /// * `sigev_notify`: Determines how you will be notified of event
+    ///                   completion.
+    pub fn new(
+        fd: RawFd,
+        offs: off_t,
+        buf: &'a [u8],
+        prio: i32,
+        sigev_notify: SigevNotify,
+    ) -> Self {
+        let mut aiocb = AioCb::common_init(fd, prio, sigev_notify);
+        aiocb.aiocb.0.aio_nbytes = buf.len();
+        // casting an immutable buffer to a mutable pointer looks unsafe,
+        // but technically its only unsafe to dereference it, not to create
+        // it.  Type Safety guarantees that we'll never pass aiocb to
+        // aio_read or aio_readv.
+        aiocb.aiocb.0.aio_buf = buf.as_ptr() as *mut c_void;
+        aiocb.aiocb.0.aio_lio_opcode = libc::LIO_WRITE;
+        aiocb.aiocb.0.aio_offset = offs;
+        AioWrite {
+            aiocb,
+            _data: PhantomData,
+            _pin: PhantomPinned,
+        }
+    }
+
+    /// Returns the file offset of the operation.
+    pub fn offset(&self) -> off_t {
+        self.aiocb.aiocb.0.aio_offset
+    }
+}
+
+impl<'a> Aio for AioWrite<'a> {
+    type Output = usize;
+
+    aio_methods!(aio_write);
+}
+
+impl<'a> AsMut<libc::aiocb> for AioWrite<'a> {
+    fn as_mut(&mut self) -> &mut libc::aiocb {
+        &mut self.aiocb.aiocb.0
+    }
+}
+
+impl<'a> AsRef<libc::aiocb> for AioWrite<'a> {
+    fn as_ref(&self) -> &libc::aiocb {
+        &self.aiocb.aiocb.0
+    }
+}
+
+/// Asynchronously writes from a scatter/gather list of buffers to a file descriptor.
+///
+/// # References
+///
+/// [aio_writev](https://www.freebsd.org/cgi/man.cgi?query=aio_writev)
+///
+/// # Examples
+///
+#[cfg_attr(fbsd14, doc = " ```")]
+#[cfg_attr(not(fbsd14), doc = " ```no_run")]
+/// # use nix::errno::Errno;
+/// # use nix::Error;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use std::{thread, time};
+/// # use std::io::IoSlice;
+/// # use std::os::unix::io::AsRawFd;
+/// # use tempfile::tempfile;
+/// const wbuf0: &[u8] = b"abcdef";
+/// const wbuf1: &[u8] = b"123456";
+/// let len = wbuf0.len() + wbuf1.len();
+/// let wbufs = [IoSlice::new(wbuf0), IoSlice::new(wbuf1)];
+/// let mut f = tempfile().unwrap();
+/// let mut aiow = Box::pin(
+///     AioWritev::new(
+///         f.as_raw_fd(),
+///         2,   //offset
+///         &wbufs,
+///         0,   //priority
+///         SigevNotify::SigevNone
+///     )
+/// );
+/// aiow.as_mut().submit().unwrap();
+/// while (aiow.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///     thread::sleep(time::Duration::from_millis(10));
+/// }
+/// assert_eq!(aiow.as_mut().aio_return().unwrap(), len);
+/// ```
+#[cfg(target_os = "freebsd")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AioWritev<'a> {
+    aiocb: AioCb,
+    _data: PhantomData<&'a [&'a [u8]]>,
+    _pin: PhantomPinned,
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AioWritev<'a> {
+    unsafe_pinned!(aiocb: AioCb);
+
+    /// Returns the number of buffers the operation will read into.
+    pub fn iovlen(&self) -> usize {
+        self.aiocb.aiocb.0.aio_nbytes
     }
 
-    /// Asynchronously writes from a buffer to a file descriptor
+    /// Construct a new `AioWritev`.
     ///
-    /// # References
+    /// # Arguments
     ///
-    /// [aio_write](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_write.html)
-    pub fn write(self: &mut Pin<Box<Self>>) -> Result<()> {
-        // Safe because we don't move anything
-        let selfp = unsafe {
-            self.as_mut().get_unchecked_mut()
-        };
-        Errno::result({
-            let p: *mut libc::aiocb = &mut selfp.aiocb.0;
-            unsafe{ libc::aio_write(p) }
-        }).map(|_| {
-            selfp.in_progress = true;
-        })
+    /// * `fd`:           File descriptor to write to
+    /// * `offs`:         File offset
+    /// * `bufs`:         A scatter/gather list of memory buffers.  They must
+    ///                   outlive the `AioWritev`.
+    /// * `prio`:         If POSIX Prioritized IO is supported, then the
+    ///                   operation will be prioritized at the process's
+    ///                   priority level minus `prio`
+    /// * `sigev_notify`: Determines how you will be notified of event
+    ///                   completion.
+    pub fn new(
+        fd: RawFd,
+        offs: off_t,
+        bufs: &[IoSlice<'a>],
+        prio: i32,
+        sigev_notify: SigevNotify,
+    ) -> Self {
+        let mut aiocb = AioCb::common_init(fd, prio, sigev_notify);
+        // In vectored mode, aio_nbytes stores the length of the iovec array,
+        // not the byte count.
+        aiocb.aiocb.0.aio_nbytes = bufs.len();
+        // casting an immutable buffer to a mutable pointer looks unsafe,
+        // but technically its only unsafe to dereference it, not to create
+        // it.  Type Safety guarantees that we'll never pass aiocb to
+        // aio_read or aio_readv.
+        aiocb.aiocb.0.aio_buf = bufs.as_ptr() as *mut c_void;
+        aiocb.aiocb.0.aio_lio_opcode = libc::LIO_WRITEV;
+        aiocb.aiocb.0.aio_offset = offs;
+        AioWritev {
+            aiocb,
+            _data: PhantomData,
+            _pin: PhantomPinned,
+        }
+    }
+
+    /// Returns the file offset of the operation.
+    pub fn offset(&self) -> off_t {
+        self.aiocb.aiocb.0.aio_offset
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> Aio for AioWritev<'a> {
+    type Output = usize;
+
+    aio_methods!(aio_writev);
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AsMut<libc::aiocb> for AioWritev<'a> {
+    fn as_mut(&mut self) -> &mut libc::aiocb {
+        &mut self.aiocb.aiocb.0
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+impl<'a> AsRef<libc::aiocb> for AioWritev<'a> {
+    fn as_ref(&self) -> &libc::aiocb {
+        &self.aiocb.aiocb.0
     }
 }
 
@@ -703,38 +990,37 @@ impl<'a> AioCb<'a> {
 /// # use tempfile::tempfile;
 /// let wbuf = b"CDEF";
 /// let mut f = tempfile().unwrap();
-/// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
+/// let mut aiocb = Box::pin(AioWrite::new(f.as_raw_fd(),
 ///     2,   //offset
 ///     &wbuf[..],
 ///     0,   //priority
-///     SigevNotify::SigevNone,
-///     LioOpcode::LIO_NOP);
-/// aiocb.write().unwrap();
+///     SigevNotify::SigevNone));
+/// aiocb.as_mut().submit().unwrap();
 /// let cs = aio_cancel_all(f.as_raw_fd()).unwrap();
 /// if cs == AioCancelStat::AioNotCanceled {
-///     while (aiocb.error() == Err(Errno::EINPROGRESS)) {
+///     while (aiocb.as_mut().error() == Err(Errno::EINPROGRESS)) {
 ///         thread::sleep(time::Duration::from_millis(10));
 ///     }
 /// }
 /// // Must call `aio_return`, but ignore the result
-/// let _ = aiocb.aio_return();
+/// let _ = aiocb.as_mut().aio_return();
 /// ```
 ///
 /// # References
 ///
 /// [`aio_cancel`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_cancel.html)
 pub fn aio_cancel_all(fd: RawFd) -> Result<AioCancelStat> {
-    match unsafe { libc::aio_cancel(fd, null_mut()) } {
+    match unsafe { libc::aio_cancel(fd, ptr::null_mut()) } {
         libc::AIO_CANCELED => Ok(AioCancelStat::AioCanceled),
         libc::AIO_NOTCANCELED => Ok(AioCancelStat::AioNotCanceled),
         libc::AIO_ALLDONE => Ok(AioCancelStat::AioAllDone),
         -1 => Err(Errno::last()),
-        _ => panic!("unknown aio_cancel return value")
+        _ => panic!("unknown aio_cancel return value"),
     }
 }
 
-/// Suspends the calling process until at least one of the specified `AioCb`s
-/// has completed, a signal is delivered, or the timeout has passed.
+/// Suspends the calling process until at least one of the specified operations
+/// have completed, a signal is delivered, or the timeout has passed.
 ///
 /// If `timeout` is `None`, `aio_suspend` will block indefinitely.
 ///
@@ -749,374 +1035,207 @@ pub fn aio_cancel_all(fd: RawFd) -> Result<AioCancelStat> {
 /// # use tempfile::tempfile;
 /// const WBUF: &[u8] = b"abcdef123456";
 /// let mut f = tempfile().unwrap();
-/// let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
+/// let mut aiocb = Box::pin(AioWrite::new(f.as_raw_fd(),
 ///     2,   //offset
 ///     WBUF,
 ///     0,   //priority
-///     SigevNotify::SigevNone,
-///     LioOpcode::LIO_NOP);
-/// aiocb.write().unwrap();
-/// aio_suspend(&[aiocb.as_ref()], None).expect("aio_suspend failed");
-/// assert_eq!(aiocb.aio_return().unwrap() as usize, WBUF.len());
+///     SigevNotify::SigevNone));
+/// aiocb.as_mut().submit().unwrap();
+/// aio_suspend(&[&*aiocb], None).expect("aio_suspend failed");
+/// assert_eq!(aiocb.as_mut().aio_return().unwrap() as usize, WBUF.len());
 /// ```
 /// # References
 ///
 /// [`aio_suspend`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/aio_suspend.html)
-pub fn aio_suspend(list: &[Pin<&AioCb>], timeout: Option<TimeSpec>) -> Result<()> {
-    let plist = list as *const [Pin<&AioCb>] as *const [*const libc::aiocb];
-    let p = plist as *const *const libc::aiocb;
+pub fn aio_suspend(
+    list: &[&dyn AsRef<libc::aiocb>],
+    timeout: Option<TimeSpec>,
+) -> Result<()> {
+    let p = list as *const [&dyn AsRef<libc::aiocb>]
+        as *const [*const libc::aiocb] as *const *const libc::aiocb;
     let timep = match timeout {
-        None    => null::<libc::timespec>(),
-        Some(x) => x.as_ref() as *const libc::timespec
+        None => ptr::null::<libc::timespec>(),
+        Some(x) => x.as_ref() as *const libc::timespec,
     };
-    Errno::result(unsafe {
-        libc::aio_suspend(p, list.len() as i32, timep)
-    }).map(drop)
-}
-
-impl<'a> Debug for AioCb<'a> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("AioCb")
-            .field("aiocb", &self.aiocb.0)
-            .field("mutable", &self.mutable)
-            .field("in_progress", &self.in_progress)
-            .finish()
-    }
+    Errno::result(unsafe { libc::aio_suspend(p, list.len() as i32, timep) })
+        .map(drop)
 }
 
-impl<'a> Drop for AioCb<'a> {
-    /// If the `AioCb` has no remaining state in the kernel, just drop it.
-    /// Otherwise, dropping constitutes a resource leak, which is an error
-    fn drop(&mut self) {
-        assert!(thread::panicking() || !self.in_progress,
-                "Dropped an in-progress AioCb");
-    }
-}
-
-/// LIO Control Block.
+/// Submits multiple asynchronous I/O requests with a single system call.
 ///
-/// The basic structure used to issue multiple AIO operations simultaneously.
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-pub struct LioCb<'a> {
-    /// A collection of [`AioCb`]s.  All of these will be issued simultaneously
-    /// by the [`listio`] method.
-    ///
-    /// [`AioCb`]: struct.AioCb.html
-    /// [`listio`]: #method.listio
-    // Their locations in memory must be fixed once they are passed to the
-    // kernel.  So this field must be non-public so the user can't swap.
-    aiocbs: Box<[AioCb<'a>]>,
-
-    /// The actual list passed to `libc::lio_listio`.
-    ///
-    /// It must live for as long as any of the operations are still being
-    /// processesed, because the aio subsystem uses its address as a unique
-    /// identifier.
-    list: Vec<*mut libc::aiocb>,
-
-    /// A partial set of results.  This field will get populated by
-    /// `listio_resubmit` when an `LioCb` is resubmitted after an error
-    results: Vec<Option<Result<isize>>>
-}
-
-/// LioCb can't automatically impl Send and Sync just because of the raw
-/// pointers in list.  But that's stupid.  There's no reason that raw pointers
-/// should automatically be non-Send
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-unsafe impl<'a> Send for LioCb<'a> {}
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-unsafe impl<'a> Sync for LioCb<'a> {}
-
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-impl<'a> LioCb<'a> {
-    /// Are no [`AioCb`]s contained?
-    pub fn is_empty(&self) -> bool {
-        self.aiocbs.is_empty()
-    }
-
-    /// Return the number of individual [`AioCb`]s contained.
-    pub fn len(&self) -> usize {
-        self.aiocbs.len()
-    }
-
-    /// Submits multiple asynchronous I/O requests with a single system call.
-    ///
-    /// They are not guaranteed to complete atomically, and the order in which
-    /// the requests are carried out is not specified.  Reads, writes, and
-    /// fsyncs may be freely mixed.
-    ///
-    /// This function is useful for reducing the context-switch overhead of
-    /// submitting many AIO operations.  It can also be used with
-    /// `LioMode::LIO_WAIT` to block on the result of several independent
-    /// operations.  Used that way, it is often useful in programs that
-    /// otherwise make little use of AIO.
-    ///
-    /// # Examples
-    ///
-    /// Use `listio` to submit an aio operation and wait for its completion.  In
-    /// this case, there is no need to use [`aio_suspend`] to wait or
-    /// [`AioCb::error`] to poll.
-    ///
-    /// ```
-    /// # use nix::sys::aio::*;
-    /// # use nix::sys::signal::SigevNotify;
-    /// # use std::os::unix::io::AsRawFd;
-    /// # use tempfile::tempfile;
-    /// const WBUF: &[u8] = b"abcdef123456";
-    /// let mut f = tempfile().unwrap();
-    /// let mut liocb = LioCbBuilder::with_capacity(1)
-    ///     .emplace_slice(
-    ///         f.as_raw_fd(),
-    ///         2,   //offset
-    ///         WBUF,
-    ///         0,   //priority
-    ///         SigevNotify::SigevNone,
-    ///         LioOpcode::LIO_WRITE
-    ///     ).finish();
-    /// liocb.listio(LioMode::LIO_WAIT,
-    ///              SigevNotify::SigevNone).unwrap();
-    /// assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());
-    /// ```
-    ///
-    /// # References
-    ///
-    /// [`lio_listio`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lio_listio.html)
-    ///
-    /// [`aio_suspend`]: fn.aio_suspend.html
-    /// [`AioCb::error`]: struct.AioCb.html#method.error
-    pub fn listio(&mut self, mode: LioMode,
-                  sigev_notify: SigevNotify) -> Result<()> {
-        let sigev = SigEvent::new(sigev_notify);
-        let sigevp = &mut sigev.sigevent() as *mut libc::sigevent;
-        self.list.clear();
-        for a in &mut self.aiocbs.iter_mut() {
-            a.in_progress = true;
-            self.list.push(a as *mut AioCb<'a>
-                             as *mut libc::aiocb);
-        }
-        let p = self.list.as_ptr();
-        Errno::result(unsafe {
-            libc::lio_listio(mode as i32, p, self.list.len() as i32, sigevp)
-        }).map(drop)
-    }
-
-    /// Resubmits any incomplete operations with [`lio_listio`].
-    ///
-    /// Sometimes, due to system resource limitations, an `lio_listio` call will
-    /// return `EIO`, or `EAGAIN`.  Or, if a signal is received, it may return
-    /// `EINTR`.  In any of these cases, only a subset of its constituent
-    /// operations will actually have been initiated.  `listio_resubmit` will
-    /// resubmit any operations that are still uninitiated.
-    ///
-    /// After calling `listio_resubmit`, results should be collected by
-    /// [`LioCb::aio_return`].
-    ///
-    /// # Examples
-    /// ```no_run
-    /// # use nix::Error;
-    /// # use nix::errno::Errno;
-    /// # use nix::sys::aio::*;
-    /// # use nix::sys::signal::SigevNotify;
-    /// # use std::os::unix::io::AsRawFd;
-    /// # use std::{thread, time};
-    /// # use tempfile::tempfile;
-    /// const WBUF: &[u8] = b"abcdef123456";
-    /// let mut f = tempfile().unwrap();
-    /// let mut liocb = LioCbBuilder::with_capacity(1)
-    ///     .emplace_slice(
-    ///         f.as_raw_fd(),
-    ///         2,   //offset
-    ///         WBUF,
-    ///         0,   //priority
-    ///         SigevNotify::SigevNone,
-    ///         LioOpcode::LIO_WRITE
-    ///     ).finish();
-    /// let mut err = liocb.listio(LioMode::LIO_WAIT, SigevNotify::SigevNone);
-    /// while err == Err(Errno::EIO) ||
-    ///       err == Err(Errno::EAGAIN) {
-    ///     thread::sleep(time::Duration::from_millis(10));
-    ///     err = liocb.listio_resubmit(LioMode::LIO_WAIT, SigevNotify::SigevNone);
-    /// }
-    /// assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());
-    /// ```
-    ///
-    /// # References
-    ///
-    /// [`lio_listio`](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lio_listio.html)
-    ///
-    /// [`lio_listio`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/lio_listio.html
-    /// [`LioCb::aio_return`]: struct.LioCb.html#method.aio_return
-    // Note: the addresses of any EINPROGRESS or EOK aiocbs _must_ not be
-    // changed by this method, because the kernel relies on their addresses
-    // being stable.
-    // Note: aiocbs that are Ok(()) must be finalized by aio_return, or else the
-    // sigev_notify will immediately refire.
-    pub fn listio_resubmit(&mut self, mode:LioMode,
-                           sigev_notify: SigevNotify) -> Result<()> {
-        let sigev = SigEvent::new(sigev_notify);
-        let sigevp = &mut sigev.sigevent() as *mut libc::sigevent;
-        self.list.clear();
-
-        while self.results.len() < self.aiocbs.len() {
-            self.results.push(None);
-        }
-
-        for (i, a) in self.aiocbs.iter_mut().enumerate() {
-            if self.results[i].is_some() {
-                // Already collected final status for this operation
-                continue;
-            }
-            match a.error_unpinned() {
-                Ok(()) => {
-                    // aiocb is complete; collect its status and don't resubmit
-                    self.results[i] = Some(a.aio_return_unpinned());
-                },
-                Err(Errno::EAGAIN) => {
-                    self.list.push(a as *mut AioCb<'a> as *mut libc::aiocb);
-                },
-                Err(Errno::EINPROGRESS) => {
-                    // aiocb is was successfully queued; no need to do anything
-                },
-                Err(Errno::EINVAL) => panic!(
-                    "AioCb was never submitted, or already finalized"),
-                _ => unreachable!()
-            }
-        }
-        let p = self.list.as_ptr();
-        Errno::result(unsafe {
-            libc::lio_listio(mode as i32, p, self.list.len() as i32, sigevp)
-        }).map(drop)
-    }
-
-    /// Collect final status for an individual `AioCb` submitted as part of an
-    /// `LioCb`.
-    ///
-    /// This is just like [`AioCb::aio_return`], except it takes into account
-    /// operations that were restarted by [`LioCb::listio_resubmit`]
-    ///
-    /// [`AioCb::aio_return`]: struct.AioCb.html#method.aio_return
-    /// [`LioCb::listio_resubmit`]: #method.listio_resubmit
-    pub fn aio_return(&mut self, i: usize) -> Result<isize> {
-        if i >= self.results.len() || self.results[i].is_none() {
-            self.aiocbs[i].aio_return_unpinned()
-        } else {
-            self.results[i].unwrap()
-        }
-    }
-
-    /// Retrieve error status of an individual `AioCb` submitted as part of an
-    /// `LioCb`.
-    ///
-    /// This is just like [`AioCb::error`], except it takes into account
-    /// operations that were restarted by [`LioCb::listio_resubmit`]
-    ///
-    /// [`AioCb::error`]: struct.AioCb.html#method.error
-    /// [`LioCb::listio_resubmit`]: #method.listio_resubmit
-    pub fn error(&mut self, i: usize) -> Result<()> {
-        if i >= self.results.len() || self.results[i].is_none() {
-            self.aiocbs[i].error_unpinned()
-        } else {
-            Ok(())
-        }
-    }
-}
-
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-impl<'a> Debug for LioCb<'a> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("LioCb")
-            .field("aiocbs", &self.aiocbs)
-            .finish()
-    }
-}
-
-/// Used to construct `LioCb`
-// This must be a separate class from LioCb due to pinning constraints.  LioCb
-// must use a boxed slice of AioCbs so they will have stable storage, but
-// LioCbBuilder must use a Vec to make construction possible when the final size
-// is unknown.
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[derive(Debug)]
-pub struct LioCbBuilder<'a> {
-    /// A collection of [`AioCb`]s.
-    ///
-    /// [`AioCb`]: struct.AioCb.html
-    pub aiocbs: Vec<AioCb<'a>>,
+/// They are not guaranteed to complete atomically, and the order in which the
+/// requests are carried out is not specified. Reads, and writes may be freely
+/// mixed.
+///
+/// # Examples
+///
+/// Use `lio_listio` to submit an aio operation and wait for its completion. In
+/// this case, there is no need to use aio_suspend to wait or `error` to poll.
+/// This mode is useful for otherwise-synchronous programs that want to execute
+/// a handful of I/O operations in parallel.
+/// ```
+/// # use std::os::unix::io::AsRawFd;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use tempfile::tempfile;
+/// const WBUF: &[u8] = b"abcdef123456";
+/// let mut f = tempfile().unwrap();
+/// let mut aiow = Box::pin(AioWrite::new(
+///     f.as_raw_fd(),
+///     2,      // offset
+///     WBUF,
+///     0,      // priority
+///     SigevNotify::SigevNone
+/// ));
+/// lio_listio(LioMode::LIO_WAIT, &mut[aiow.as_mut()], SigevNotify::SigevNone)
+///     .unwrap();
+/// // At this point, we are guaranteed that aiow is complete.
+/// assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+/// ```
+///
+/// Use `lio_listio` to submit multiple asynchronous operations with a single
+/// syscall, but receive notification individually.  This is an efficient
+/// technique for reducing overall context-switch overhead, especially when
+/// combined with kqueue.
+/// ```
+/// # use std::os::unix::io::AsRawFd;
+/// # use std::thread;
+/// # use std::time;
+/// # use nix::errno::Errno;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::SigevNotify;
+/// # use tempfile::tempfile;
+/// const WBUF: &[u8] = b"abcdef123456";
+/// let mut f = tempfile().unwrap();
+/// let mut aiow = Box::pin(AioWrite::new(
+///     f.as_raw_fd(),
+///     2,      // offset
+///     WBUF,
+///     0,      // priority
+///     SigevNotify::SigevNone
+/// ));
+/// lio_listio(LioMode::LIO_NOWAIT, &mut[aiow.as_mut()], SigevNotify::SigevNone)
+///     .unwrap();
+/// // We must wait for the completion of each individual operation
+/// while (aiow.as_mut().error() == Err(Errno::EINPROGRESS)) {
+///     thread::sleep(time::Duration::from_millis(10));
+/// }
+/// assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+/// ```
+///
+/// Use `lio_listio` to submit multiple operations, and receive notification
+/// only when all of them are complete.  This can be useful when there is some
+/// logical relationship between the operations.  But beware!  Errors or system
+/// resource limitations may cause `lio_listio` to return `EIO`, `EAGAIN`, or
+/// `EINTR`, in which case some but not all operations may have been submitted.
+/// In that case, you must check the status of each individual operation, and
+/// possibly resubmit some.
+/// ```
+/// # use libc::c_int;
+/// # use std::os::unix::io::AsRawFd;
+/// # use std::sync::atomic::{AtomicBool, Ordering};
+/// # use std::thread;
+/// # use std::time;
+/// # use lazy_static::lazy_static;
+/// # use nix::errno::Errno;
+/// # use nix::sys::aio::*;
+/// # use nix::sys::signal::*;
+/// # use tempfile::tempfile;
+/// lazy_static! {
+///     pub static ref SIGNALED: AtomicBool = AtomicBool::new(false);
+/// }
+///
+/// extern fn sigfunc(_: c_int) {
+///     SIGNALED.store(true, Ordering::Relaxed);
+/// }
+/// let sa = SigAction::new(SigHandler::Handler(sigfunc),
+///                         SaFlags::SA_RESETHAND,
+///                         SigSet::empty());
+/// SIGNALED.store(false, Ordering::Relaxed);
+/// unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();
+///
+/// const WBUF: &[u8] = b"abcdef123456";
+/// let mut f = tempfile().unwrap();
+/// let mut aiow = Box::pin(AioWrite::new(
+///     f.as_raw_fd(),
+///     2,      // offset
+///     WBUF,
+///     0,      // priority
+///     SigevNotify::SigevNone
+/// ));
+/// let sev = SigevNotify::SigevSignal { signal: Signal::SIGUSR2, si_value: 0 };
+/// lio_listio(LioMode::LIO_NOWAIT, &mut[aiow.as_mut()], sev).unwrap();
+/// while !SIGNALED.load(Ordering::Relaxed) {
+///     thread::sleep(time::Duration::from_millis(10));
+/// }
+/// // At this point, since `lio_listio` returned success and delivered its
+/// // notification, we know that all operations are complete.
+/// assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+/// ```
+pub fn lio_listio(
+    mode: LioMode,
+    list: &mut [Pin<&mut dyn AsMut<libc::aiocb>>],
+    sigev_notify: SigevNotify,
+) -> Result<()> {
+    let p = list as *mut [Pin<&mut dyn AsMut<libc::aiocb>>]
+        as *mut [*mut libc::aiocb] as *mut *mut libc::aiocb;
+    let sigev = SigEvent::new(sigev_notify);
+    let sigevp = &mut sigev.sigevent() as *mut libc::sigevent;
+    Errno::result(unsafe {
+        libc::lio_listio(mode as i32, p, list.len() as i32, sigevp)
+    })
+    .map(drop)
 }
 
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-impl<'a> LioCbBuilder<'a> {
-    /// Initialize an empty `LioCb`
-    pub fn with_capacity(capacity: usize) -> LioCbBuilder<'a> {
-        LioCbBuilder {
-            aiocbs: Vec::with_capacity(capacity),
-        }
-    }
+#[cfg(test)]
+mod t {
+    use super::*;
 
-    /// Add a new operation on an immutable slice to the [`LioCb`] under
-    /// construction.
-    ///
-    /// Arguments are the same as for [`AioCb::from_slice`]
-    ///
-    /// [`LioCb`]: struct.LioCb.html
-    /// [`AioCb::from_slice`]: struct.AioCb.html#method.from_slice
-    pub fn emplace_slice(mut self, fd: RawFd, offs: off_t, buf: &'a [u8],
-                         prio: libc::c_int, sigev_notify: SigevNotify,
-                         opcode: LioOpcode) -> Self
-    {
-        self.aiocbs.push(AioCb::from_slice_unpinned(fd, offs, buf, prio,
-                                                    sigev_notify, opcode));
-        self
-    }
+    /// aio_suspend relies on casting Rust Aio* struct pointers to libc::aiocb
+    /// pointers.  This test ensures that such casts are valid.
+    #[test]
+    fn casting() {
+        let sev = SigevNotify::SigevNone;
+        let aiof = AioFsync::new(666, AioFsyncMode::O_SYNC, 0, sev);
+        assert_eq!(
+            aiof.as_ref() as *const libc::aiocb,
+            &aiof as *const AioFsync as *const libc::aiocb
+        );
 
-    /// Add a new operation on a mutable slice to the [`LioCb`] under
-    /// construction.
-    ///
-    /// Arguments are the same as for [`AioCb::from_mut_slice`]
-    ///
-    /// [`LioCb`]: struct.LioCb.html
-    /// [`AioCb::from_mut_slice`]: struct.AioCb.html#method.from_mut_slice
-    pub fn emplace_mut_slice(mut self, fd: RawFd, offs: off_t,
-                             buf: &'a mut [u8], prio: libc::c_int,
-                             sigev_notify: SigevNotify, opcode: LioOpcode)
-        -> Self
-    {
-        self.aiocbs.push(AioCb::from_mut_slice_unpinned(fd, offs, buf, prio,
-                                                        sigev_notify, opcode));
-        self
-    }
+        let mut rbuf = [];
+        let aior = AioRead::new(666, 0, &mut rbuf, 0, sev);
+        assert_eq!(
+            aior.as_ref() as *const libc::aiocb,
+            &aior as *const AioRead as *const libc::aiocb
+        );
 
-    /// Finalize this [`LioCb`].
-    ///
-    /// Afterwards it will be possible to issue the operations with
-    /// [`LioCb::listio`].  Conversely, it will no longer be possible to add new
-    /// operations with [`LioCbBuilder::emplace_slice`] or
-    /// [`LioCbBuilder::emplace_mut_slice`].
-    ///
-    /// [`LioCb::listio`]: struct.LioCb.html#method.listio
-    /// [`LioCb::from_mut_slice`]: struct.LioCb.html#method.from_mut_slice
-    /// [`LioCb::from_slice`]: struct.LioCb.html#method.from_slice
-    pub fn finish(self) -> LioCb<'a> {
-        let len = self.aiocbs.len();
-        LioCb {
-            aiocbs: self.aiocbs.into(),
-            list: Vec::with_capacity(len),
-            results: Vec::with_capacity(len)
-        }
+        let wbuf = [];
+        let aiow = AioWrite::new(666, 0, &wbuf, 0, sev);
+        assert_eq!(
+            aiow.as_ref() as *const libc::aiocb,
+            &aiow as *const AioWrite as *const libc::aiocb
+        );
     }
-}
 
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[cfg(test)]
-mod t {
-    use super::*;
-
-    // It's important that `LioCb` be `UnPin`.  The tokio-file crate relies on
-    // it.
+    #[cfg(target_os = "freebsd")]
     #[test]
-    fn liocb_is_unpin() {
-        use assert_impl::assert_impl;
+    fn casting_vectored() {
+        let sev = SigevNotify::SigevNone;
+
+        let mut rbuf = [];
+        let mut rbufs = [IoSliceMut::new(&mut rbuf)];
+        let aiorv = AioReadv::new(666, 0, &mut rbufs[..], 0, sev);
+        assert_eq!(
+            aiorv.as_ref() as *const libc::aiocb,
+            &aiorv as *const AioReadv as *const libc::aiocb
+        );
 
-        assert_impl!(Unpin: LioCb);
+        let wbuf = [];
+        let wbufs = [IoSlice::new(&wbuf)];
+        let aiowv = AioWritev::new(666, 0, &wbufs, 0, sev);
+        assert_eq!(
+            aiowv.as_ref() as *const libc::aiocb,
+            &aiowv as *const AioWritev as *const libc::aiocb
+        );
     }
 }
diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs
index 6bc2a25..58def2e 100644
--- a/src/sys/epoll.rs
+++ b/src/sys/epoll.rs
@@ -1,9 +1,9 @@
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 use libc::{self, c_int};
+use std::mem;
 use std::os::unix::io::RawFd;
 use std::ptr;
-use std::mem;
 
 libc_bitflags!(
     pub struct EpollFlags: c_int {
@@ -18,7 +18,6 @@ libc_bitflags!(
         EPOLLERR;
         EPOLLHUP;
         EPOLLRDHUP;
-        #[cfg(target_os = "linux")]  // Added in 4.5; not in Android.
         EPOLLEXCLUSIVE;
         #[cfg(not(target_arch = "mips"))]
         EPOLLWAKEUP;
@@ -36,7 +35,7 @@ pub enum EpollOp {
     EpollCtlMod = libc::EPOLL_CTL_MOD,
 }
 
-libc_bitflags!{
+libc_bitflags! {
     pub struct EpollCreateFlags: c_int {
         EPOLL_CLOEXEC;
     }
@@ -50,7 +49,12 @@ pub struct EpollEvent {
 
 impl EpollEvent {
     pub fn new(events: EpollFlags, data: u64) -> Self {
-        EpollEvent { event: libc::epoll_event { events: events.bits() as u32, u64: data } }
+        EpollEvent {
+            event: libc::epoll_event {
+                events: events.bits() as u32,
+                u64: data,
+            },
+        }
     }
 
     pub fn empty() -> Self {
@@ -81,8 +85,14 @@ pub fn epoll_create1(flags: EpollCreateFlags) -> Result<RawFd> {
 }
 
 #[inline]
-pub fn epoll_ctl<'a, T>(epfd: RawFd, op: EpollOp, fd: RawFd, event: T) -> Result<()>
-    where T: Into<Option<&'a mut EpollEvent>>
+pub fn epoll_ctl<'a, T>(
+    epfd: RawFd,
+    op: EpollOp,
+    fd: RawFd,
+    event: T,
+) -> Result<()>
+where
+    T: Into<Option<&'a mut EpollEvent>>,
 {
     let mut event: Option<&mut EpollEvent> = event.into();
     if event.is_none() && op != EpollOp::EpollCtlDel {
@@ -100,9 +110,18 @@ pub fn epoll_ctl<'a, T>(epfd: RawFd, op: EpollOp, fd: RawFd, event: T) -> Result
 }
 
 #[inline]
-pub fn epoll_wait(epfd: RawFd, events: &mut [EpollEvent], timeout_ms: isize) -> Result<usize> {
+pub fn epoll_wait(
+    epfd: RawFd,
+    events: &mut [EpollEvent],
+    timeout_ms: isize,
+) -> Result<usize> {
     let res = unsafe {
-        libc::epoll_wait(epfd, events.as_mut_ptr() as *mut libc::epoll_event, events.len() as c_int, timeout_ms as c_int)
+        libc::epoll_wait(
+            epfd,
+            events.as_mut_ptr() as *mut libc::epoll_event,
+            events.len() as c_int,
+            timeout_ms as c_int,
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
diff --git a/src/sys/event.rs b/src/sys/event.rs
index c648f5e..d8ad628 100644
--- a/src/sys/event.rs
+++ b/src/sys/event.rs
@@ -3,10 +3,11 @@
 
 use crate::{Errno, Result};
 #[cfg(not(target_os = "netbsd"))]
-use libc::{timespec, time_t, c_int, c_long, intptr_t, uintptr_t};
+use libc::{c_int, c_long, intptr_t, time_t, timespec, uintptr_t};
 #[cfg(target_os = "netbsd")]
-use libc::{timespec, time_t, c_long, intptr_t, uintptr_t, size_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::ptr;
 
@@ -17,17 +18,16 @@ pub struct KEvent {
     kevent: libc::kevent,
 }
 
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd",
-          target_os = "ios", target_os = "macos",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "openbsd"
+))]
 type type_of_udata = *mut libc::c_void;
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd",
-          target_os = "ios", target_os = "macos"))]
-type type_of_data = intptr_t;
 #[cfg(any(target_os = "netbsd"))]
 type type_of_udata = intptr_t;
-#[cfg(any(target_os = "netbsd", target_os = "openbsd"))]
-type type_of_data = i64;
 
 #[cfg(target_os = "netbsd")]
 type type_of_event_filter = u32;
@@ -79,13 +79,17 @@ libc_enum! {
     impl TryFrom<type_of_event_filter>
 }
 
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd",
-          target_os = "ios", target_os = "macos",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "openbsd"
+))]
 pub type type_of_event_flag = u16;
 #[cfg(any(target_os = "netbsd"))]
 pub type type_of_event_flag = u32;
-libc_bitflags!{
+libc_bitflags! {
     pub struct EventFlag: type_of_event_flag {
         EV_ADD;
         EV_CLEAR;
@@ -114,7 +118,6 @@ libc_bitflags!{
                   target_os = "ios", target_os = "macos",
                   target_os = "netbsd", target_os = "openbsd"))]
         EV_RECEIPT;
-        EV_SYSFLAGS;
     }
 }
 
@@ -210,24 +213,33 @@ pub fn kqueue() -> Result<RawFd> {
     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.
-unsafe impl Send for KEvent {
-}
+unsafe impl Send for KEvent {}
 
 impl KEvent {
-    pub fn new(ident: uintptr_t, filter: EventFilter, flags: EventFlag,
-               fflags:FilterFlag, data: intptr_t, udata: intptr_t) -> KEvent {
-        KEvent { kevent: libc::kevent {
-            ident,
-            filter: filter as type_of_event_filter,
-            flags: flags.bits(),
-            fflags: fflags.bits(),
-            data: data as type_of_data,
-            udata: udata as type_of_udata
-        } }
+    #[allow(clippy::needless_update)] // Not needless on all platforms.
+    pub fn new(
+        ident: uintptr_t,
+        filter: EventFilter,
+        flags: EventFlag,
+        fflags: FilterFlag,
+        data: intptr_t,
+        udata: intptr_t,
+    ) -> KEvent {
+        KEvent {
+            kevent: libc::kevent {
+                ident,
+                filter: filter as type_of_event_filter,
+                flags: flags.bits(),
+                fflags: fflags.bits(),
+                // data can be either i64 or intptr_t, depending on platform
+                data: data as _,
+                udata: udata as type_of_udata,
+                ..unsafe { mem::zeroed() }
+            },
+        }
     }
 
     pub fn ident(&self) -> uintptr_t {
@@ -255,34 +267,38 @@ impl KEvent {
     }
 }
 
-pub fn kevent(kq: RawFd,
-              changelist: &[KEvent],
-              eventlist: &mut [KEvent],
-              timeout_ms: usize) -> Result<usize> {
-
+pub fn kevent(
+    kq: RawFd,
+    changelist: &[KEvent],
+    eventlist: &mut [KEvent],
+    timeout_ms: usize,
+) -> Result<usize> {
     // 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
+        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",
-          target_os = "dragonfly",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "openbsd"
+))]
 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<timespec>) -> Result<usize> {
-
+pub fn kevent_ts(
+    kq: RawFd,
+    changelist: &[KEvent],
+    eventlist: &mut [KEvent],
+    timeout_opt: Option<timespec>,
+) -> Result<usize> {
     let res = unsafe {
         libc::kevent(
             kq,
@@ -290,59 +306,69 @@ 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()})
+            if let Some(ref timeout) = timeout_opt {
+                timeout as *const timespec
+            } else {
+                ptr::null()
+            },
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
 }
 
 #[inline]
-pub fn ev_set(ev: &mut KEvent,
-              ident: usize,
-              filter: EventFilter,
-              flags: EventFlag,
-              fflags: FilterFlag,
-              udata: intptr_t) {
-
-    ev.kevent.ident  = ident as uintptr_t;
+pub fn ev_set(
+    ev: &mut KEvent,
+    ident: usize,
+    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.flags = flags.bits();
     ev.kevent.fflags = fflags.bits();
-    ev.kevent.data   = 0;
-    ev.kevent.udata  = udata as type_of_udata;
+    ev.kevent.data = 0;
+    ev.kevent.udata = udata as type_of_udata;
 }
 
 #[test]
 fn test_struct_kevent() {
     use std::mem;
 
-    let udata : intptr_t = 12345;
+    let udata: intptr_t = 12345;
 
-    let actual = KEvent::new(0xdead_beef,
-                             EventFilter::EVFILT_READ,
-                             EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
-                             FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
-                             0x1337,
-                             udata);
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        0x1337,
+        udata,
+    );
     assert_eq!(0xdead_beef, actual.ident());
     let filter = actual.kevent.filter;
     assert_eq!(libc::EVFILT_READ, filter);
     assert_eq!(libc::EV_ONESHOT | libc::EV_ADD, actual.flags().bits());
     assert_eq!(libc::NOTE_CHILD | libc::NOTE_EXIT, actual.fflags().bits());
-    assert_eq!(0x1337, actual.data() as type_of_data);
+    assert_eq!(0x1337, actual.data());
     assert_eq!(udata as type_of_udata, actual.udata() as type_of_udata);
     assert_eq!(mem::size_of::<libc::kevent>(), mem::size_of::<KEvent>());
 }
 
 #[test]
 fn test_kevent_filter() {
-    let udata : intptr_t = 12345;
+    let udata: intptr_t = 12345;
 
-    let actual = KEvent::new(0xdead_beef,
-                             EventFilter::EVFILT_READ,
-                             EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
-                             FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
-                             0x1337,
-                             udata);
+    let actual = KEvent::new(
+        0xdead_beef,
+        EventFilter::EVFILT_READ,
+        EventFlag::EV_ONESHOT | EventFlag::EV_ADD,
+        FilterFlag::NOTE_CHILD | FilterFlag::NOTE_EXIT,
+        0x1337,
+        udata,
+    );
     assert_eq!(EventFilter::EVFILT_READ, actual.filter().unwrap());
 }
diff --git a/src/sys/eventfd.rs b/src/sys/eventfd.rs
index c54f952..cd90672 100644
--- a/src/sys/eventfd.rs
+++ b/src/sys/eventfd.rs
@@ -1,6 +1,6 @@
-use std::os::unix::io::RawFd;
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
+use std::os::unix::io::RawFd;
 
 libc_bitflags! {
     pub struct EfdFlags: libc::c_int {
diff --git a/src/sys/inotify.rs b/src/sys/inotify.rs
index 3f5ae22..84356ec 100644
--- a/src/sys/inotify.rs
+++ b/src/sys/inotify.rs
@@ -23,48 +23,68 @@
 //! }
 //! ```
 
-use libc::{
-    c_char,
-    c_int,
-};
-use std::ffi::{OsString,OsStr,CStr};
-use std::os::unix::ffi::OsStrExt;
-use std::mem::{MaybeUninit, size_of};
-use std::os::unix::io::{RawFd,AsRawFd,FromRawFd};
-use std::ptr;
+use crate::errno::Errno;
 use crate::unistd::read;
-use crate::Result;
 use crate::NixPath;
-use crate::errno::Errno;
+use crate::Result;
+use cfg_if::cfg_if;
+use libc::{c_char, c_int};
+use std::ffi::{CStr, OsStr, OsString};
+use std::mem::{size_of, MaybeUninit};
+use std::os::unix::ffi::OsStrExt;
+use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
+use std::ptr;
 
 libc_bitflags! {
     /// Configuration options for [`inotify_add_watch`](fn.inotify_add_watch.html).
     pub struct AddWatchFlags: u32 {
+        /// File was accessed.
         IN_ACCESS;
+        /// File was modified.
         IN_MODIFY;
+        /// Metadata changed.
         IN_ATTRIB;
+        /// Writable file was closed.
         IN_CLOSE_WRITE;
+        /// Nonwritable file was closed.
         IN_CLOSE_NOWRITE;
+        /// File was opened.
         IN_OPEN;
+        /// File was moved from X.
         IN_MOVED_FROM;
+        /// File was moved to Y.
         IN_MOVED_TO;
+        /// Subfile was created.
         IN_CREATE;
+        /// Subfile was deleted.
         IN_DELETE;
+        /// Self was deleted.
         IN_DELETE_SELF;
+        /// Self was moved.
         IN_MOVE_SELF;
 
+        /// Backing filesystem was unmounted.
         IN_UNMOUNT;
+        /// Event queue overflowed.
         IN_Q_OVERFLOW;
+        /// File was ignored.
         IN_IGNORED;
 
+        /// Combination of `IN_CLOSE_WRITE` and `IN_CLOSE_NOWRITE`.
         IN_CLOSE;
+        /// Combination of `IN_MOVED_FROM` and `IN_MOVED_TO`.
         IN_MOVE;
 
+        /// Only watch the path if it is a directory.
         IN_ONLYDIR;
+        /// Don't follow symlinks.
         IN_DONT_FOLLOW;
 
+        /// Event occurred against directory.
         IN_ISDIR;
+        /// Only send event once.
         IN_ONESHOT;
+        /// All of the events.
         IN_ALL_EVENTS;
     }
 }
@@ -72,7 +92,9 @@ libc_bitflags! {
 libc_bitflags! {
     /// Configuration options for [`inotify_init1`](fn.inotify_init1.html).
     pub struct InitFlags: c_int {
+        /// Set the `FD_CLOEXEC` flag on the file descriptor.
         IN_CLOEXEC;
+        /// Set the `O_NONBLOCK` flag on the open file description referred to by the new file descriptor.
         IN_NONBLOCK;
     }
 }
@@ -81,7 +103,7 @@ libc_bitflags! {
 /// other interfaces consuming file descriptors, epoll for example.
 #[derive(Debug, Clone, Copy)]
 pub struct Inotify {
-    fd: RawFd
+    fd: RawFd,
 }
 
 /// This object is returned when you create a new watch on an inotify instance.
@@ -89,7 +111,7 @@ pub struct Inotify {
 /// know which watch triggered which event.
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub struct WatchDescriptor {
-    wd: i32
+    wd: i32,
 }
 
 /// A single inotify event.
@@ -109,7 +131,7 @@ pub struct InotifyEvent {
     pub cookie: u32,
     /// Filename. This field exists only if the event was triggered for a file
     /// inside the watched directory.
-    pub name: Option<OsString>
+    pub name: Option<OsString>,
 }
 
 impl Inotify {
@@ -119,9 +141,7 @@ impl Inotify {
     ///
     /// For more information see, [inotify_init(2)](https://man7.org/linux/man-pages/man2/inotify_init.2.html).
     pub fn init(flags: InitFlags) -> Result<Inotify> {
-        let res = Errno::result(unsafe {
-            libc::inotify_init1(flags.bits())
-        });
+        let res = Errno::result(unsafe { libc::inotify_init1(flags.bits()) });
 
         res.map(|fd| Inotify { fd })
     }
@@ -131,15 +151,13 @@ impl Inotify {
     /// Returns a watch descriptor. This is not a File Descriptor!
     ///
     /// For more information see, [inotify_add_watch(2)](https://man7.org/linux/man-pages/man2/inotify_add_watch.2.html).
-    pub fn add_watch<P: ?Sized + NixPath>(self,
-                                          path: &P,
-                                          mask: AddWatchFlags)
-                                            -> Result<WatchDescriptor>
-    {
-        let res = path.with_nix_path(|cstr| {
-            unsafe {
-                libc::inotify_add_watch(self.fd, cstr.as_ptr(), mask.bits())
-            }
+    pub fn add_watch<P: ?Sized + NixPath>(
+        self,
+        path: &P,
+        mask: AddWatchFlags,
+    ) -> Result<WatchDescriptor> {
+        let res = path.with_nix_path(|cstr| unsafe {
+            libc::inotify_add_watch(self.fd, cstr.as_ptr(), mask.bits())
         })?;
 
         Errno::result(res).map(|wd| WatchDescriptor { wd })
@@ -151,16 +169,15 @@ impl Inotify {
     /// Returns an EINVAL error if the watch descriptor is invalid.
     ///
     /// For more information see, [inotify_rm_watch(2)](https://man7.org/linux/man-pages/man2/inotify_rm_watch.2.html).
-    #[cfg(target_os = "linux")]
-    pub fn rm_watch(self, wd: WatchDescriptor) -> Result<()> {
-        let res = unsafe { libc::inotify_rm_watch(self.fd, wd.wd) };
-
-        Errno::result(res).map(drop)
-    }
-
-    #[cfg(target_os = "android")]
     pub fn rm_watch(self, wd: WatchDescriptor) -> Result<()> {
-        let res = unsafe { libc::inotify_rm_watch(self.fd, wd.wd as u32) };
+        cfg_if! {
+            if #[cfg(target_os = "linux")] {
+                let arg = wd.wd;
+            } else if #[cfg(target_os = "android")] {
+                let arg = wd.wd as u32;
+            }
+        }
+        let res = unsafe { libc::inotify_rm_watch(self.fd, arg) };
 
         Errno::result(res).map(drop)
     }
@@ -186,7 +203,7 @@ impl Inotify {
                 ptr::copy_nonoverlapping(
                     buffer.as_ptr().add(offset),
                     event.as_mut_ptr() as *mut u8,
-                    (BUFSIZ - offset).min(header_size)
+                    (BUFSIZ - offset).min(header_size),
                 );
                 event.assume_init()
             };
@@ -195,9 +212,7 @@ impl Inotify {
                 0 => None,
                 _ => {
                     let ptr = unsafe {
-                        buffer
-                            .as_ptr()
-                            .add(offset + header_size)
+                        buffer.as_ptr().add(offset + header_size)
                             as *const c_char
                     };
                     let cstr = unsafe { CStr::from_ptr(ptr) };
@@ -210,7 +225,7 @@ impl Inotify {
                 wd: WatchDescriptor { wd: event.wd },
                 mask: AddWatchFlags::from_bits_truncate(event.mask),
                 cookie: event.cookie,
-                name
+                name,
             });
 
             offset += header_size + event.len as usize;
diff --git a/src/sys/ioctl/bsd.rs b/src/sys/ioctl/bsd.rs
index 4ce4d33..307994c 100644
--- a/src/sys/ioctl/bsd.rs
+++ b/src/sys/ioctl/bsd.rs
@@ -21,7 +21,7 @@ mod consts {
     #[allow(overflowing_literals)]
     pub const IN: ioctl_num_type = 0x8000_0000;
     #[doc(hidden)]
-    pub const INOUT: ioctl_num_type = IN|OUT;
+    pub const INOUT: ioctl_num_type = IN | OUT;
     #[doc(hidden)]
     pub const IOCPARM_MASK: ioctl_num_type = 0x1fff;
 }
@@ -31,9 +31,14 @@ pub use self::consts::*;
 #[macro_export]
 #[doc(hidden)]
 macro_rules! ioc {
-    ($inout:expr, $group:expr, $num:expr, $len:expr) => (
-        $inout | (($len as $crate::sys::ioctl::ioctl_num_type & $crate::sys::ioctl::IOCPARM_MASK) << 16) | (($group as $crate::sys::ioctl::ioctl_num_type) << 8) | ($num as $crate::sys::ioctl::ioctl_num_type)
-    )
+    ($inout:expr, $group:expr, $num:expr, $len:expr) => {
+        $inout
+            | (($len as $crate::sys::ioctl::ioctl_num_type
+                & $crate::sys::ioctl::IOCPARM_MASK)
+                << 16)
+            | (($group as $crate::sys::ioctl::ioctl_num_type) << 8)
+            | ($num as $crate::sys::ioctl::ioctl_num_type)
+    };
 }
 
 /// Generate an ioctl request code for a command that passes no data.
@@ -53,7 +58,9 @@ macro_rules! ioc {
 /// ```
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_none {
-    ($g:expr, $n:expr) => (ioc!($crate::sys::ioctl::VOID, $g, $n, 0))
+    ($g:expr, $n:expr) => {
+        ioc!($crate::sys::ioctl::VOID, $g, $n, 0)
+    };
 }
 
 /// Generate an ioctl request code for a command that passes an integer
@@ -64,7 +71,14 @@ macro_rules! request_code_none {
 /// with is "bad" and you cannot use `ioctl_write_int!()` directly.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_write_int {
-    ($g:expr, $n:expr) => (ioc!($crate::sys::ioctl::VOID, $g, $n, ::std::mem::size_of::<$crate::libc::c_int>()))
+    ($g:expr, $n:expr) => {
+        ioc!(
+            $crate::sys::ioctl::VOID,
+            $g,
+            $n,
+            ::std::mem::size_of::<$crate::libc::c_int>()
+        )
+    };
 }
 
 /// Generate an ioctl request code for a command that reads.
@@ -79,7 +93,9 @@ macro_rules! request_code_write_int {
 /// writing.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_read {
-    ($g:expr, $n:expr, $len:expr) => (ioc!($crate::sys::ioctl::OUT, $g, $n, $len))
+    ($g:expr, $n:expr, $len:expr) => {
+        ioc!($crate::sys::ioctl::OUT, $g, $n, $len)
+    };
 }
 
 /// Generate an ioctl request code for a command that writes.
@@ -94,7 +110,9 @@ macro_rules! request_code_read {
 /// reading.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_write {
-    ($g:expr, $n:expr, $len:expr) => (ioc!($crate::sys::ioctl::IN, $g, $n, $len))
+    ($g:expr, $n:expr, $len:expr) => {
+        ioc!($crate::sys::ioctl::IN, $g, $n, $len)
+    };
 }
 
 /// Generate an ioctl request code for a command that reads and writes.
@@ -105,5 +123,7 @@ macro_rules! request_code_write {
 /// with is "bad" and you cannot use `ioctl_readwrite!()` directly.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_readwrite {
-    ($g:expr, $n:expr, $len:expr) => (ioc!($crate::sys::ioctl::INOUT, $g, $n, $len))
+    ($g:expr, $n:expr, $len:expr) => {
+        ioc!($crate::sys::ioctl::INOUT, $g, $n, $len)
+    };
 }
diff --git a/src/sys/ioctl/linux.rs b/src/sys/ioctl/linux.rs
index 68ebaba..0c0a209 100644
--- a/src/sys/ioctl/linux.rs
+++ b/src/sys/ioctl/linux.rs
@@ -14,7 +14,13 @@ pub const NRBITS: ioctl_num_type = 8;
 #[doc(hidden)]
 pub const TYPEBITS: ioctl_num_type = 8;
 
-#[cfg(any(target_arch = "mips", target_arch = "mips64", target_arch = "powerpc", target_arch = "powerpc64", target_arch = "sparc64"))]
+#[cfg(any(
+    target_arch = "mips",
+    target_arch = "mips64",
+    target_arch = "powerpc",
+    target_arch = "powerpc64",
+    target_arch = "sparc64"
+))]
 mod consts {
     #[doc(hidden)]
     pub const NONE: u8 = 1;
@@ -29,12 +35,15 @@ mod consts {
 }
 
 // "Generic" ioctl protocol
-#[cfg(any(target_arch = "x86",
-          target_arch = "arm",
-          target_arch = "s390x",
-          target_arch = "x86_64",
-          target_arch = "aarch64",
-          target_arch = "riscv64"))]
+#[cfg(any(
+    target_arch = "x86",
+    target_arch = "arm",
+    target_arch = "s390x",
+    target_arch = "x86_64",
+    target_arch = "aarch64",
+    target_arch = "riscv32",
+    target_arch = "riscv64"
+))]
 mod consts {
     #[doc(hidden)]
     pub const NONE: u8 = 0;
@@ -72,11 +81,20 @@ pub const DIRMASK: ioctl_num_type = (1 << DIRBITS) - 1;
 #[macro_export]
 #[doc(hidden)]
 macro_rules! ioc {
-    ($dir:expr, $ty:expr, $nr:expr, $sz:expr) => (
-        (($dir as $crate::sys::ioctl::ioctl_num_type & $crate::sys::ioctl::DIRMASK) << $crate::sys::ioctl::DIRSHIFT) |
-        (($ty as $crate::sys::ioctl::ioctl_num_type & $crate::sys::ioctl::TYPEMASK) << $crate::sys::ioctl::TYPESHIFT) |
-        (($nr as $crate::sys::ioctl::ioctl_num_type & $crate::sys::ioctl::NRMASK) << $crate::sys::ioctl::NRSHIFT) |
-        (($sz as $crate::sys::ioctl::ioctl_num_type & $crate::sys::ioctl::SIZEMASK) << $crate::sys::ioctl::SIZESHIFT))
+    ($dir:expr, $ty:expr, $nr:expr, $sz:expr) => {
+        (($dir as $crate::sys::ioctl::ioctl_num_type
+            & $crate::sys::ioctl::DIRMASK)
+            << $crate::sys::ioctl::DIRSHIFT)
+            | (($ty as $crate::sys::ioctl::ioctl_num_type
+                & $crate::sys::ioctl::TYPEMASK)
+                << $crate::sys::ioctl::TYPESHIFT)
+            | (($nr as $crate::sys::ioctl::ioctl_num_type
+                & $crate::sys::ioctl::NRMASK)
+                << $crate::sys::ioctl::NRSHIFT)
+            | (($sz as $crate::sys::ioctl::ioctl_num_type
+                & $crate::sys::ioctl::SIZEMASK)
+                << $crate::sys::ioctl::SIZESHIFT)
+    };
 }
 
 /// Generate an ioctl request code for a command that passes no data.
@@ -96,7 +114,9 @@ macro_rules! ioc {
 /// ```
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_none {
-    ($ty:expr, $nr:expr) => (ioc!($crate::sys::ioctl::NONE, $ty, $nr, 0))
+    ($ty:expr, $nr:expr) => {
+        ioc!($crate::sys::ioctl::NONE, $ty, $nr, 0)
+    };
 }
 
 /// Generate an ioctl request code for a command that reads.
@@ -111,7 +131,9 @@ macro_rules! request_code_none {
 /// writing.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_read {
-    ($ty:expr, $nr:expr, $sz:expr) => (ioc!($crate::sys::ioctl::READ, $ty, $nr, $sz))
+    ($ty:expr, $nr:expr, $sz:expr) => {
+        ioc!($crate::sys::ioctl::READ, $ty, $nr, $sz)
+    };
 }
 
 /// Generate an ioctl request code for a command that writes.
@@ -126,7 +148,9 @@ macro_rules! request_code_read {
 /// reading.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_write {
-    ($ty:expr, $nr:expr, $sz:expr) => (ioc!($crate::sys::ioctl::WRITE, $ty, $nr, $sz))
+    ($ty:expr, $nr:expr, $sz:expr) => {
+        ioc!($crate::sys::ioctl::WRITE, $ty, $nr, $sz)
+    };
 }
 
 /// Generate an ioctl request code for a command that reads and writes.
@@ -137,5 +161,12 @@ macro_rules! request_code_write {
 /// with is "bad" and you cannot use `ioctl_readwrite!()` directly.
 #[macro_export(local_inner_macros)]
 macro_rules! request_code_readwrite {
-    ($ty:expr, $nr:expr, $sz:expr) => (ioc!($crate::sys::ioctl::READ | $crate::sys::ioctl::WRITE, $ty, $nr, $sz))
+    ($ty:expr, $nr:expr, $sz:expr) => {
+        ioc!(
+            $crate::sys::ioctl::READ | $crate::sys::ioctl::WRITE,
+            $ty,
+            $nr,
+            $sz
+        )
+    };
 }
diff --git a/src/sys/ioctl/mod.rs b/src/sys/ioctl/mod.rs
index 203b7d0..98d6b5c 100644
--- a/src/sys/ioctl/mod.rs
+++ b/src/sys/ioctl/mod.rs
@@ -227,37 +227,45 @@ use cfg_if::cfg_if;
 #[macro_use]
 mod linux;
 
-#[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "linux",
+    target_os = "redox"
+))]
 pub use self::linux::*;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "illumos",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "haiku",
+    target_os = "openbsd"
+))]
 #[macro_use]
 mod bsd;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "illumos",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "haiku",
+    target_os = "openbsd"
+))]
 pub use self::bsd::*;
 
 /// Convert raw ioctl return value to a Nix result
 #[macro_export]
 #[doc(hidden)]
 macro_rules! convert_ioctl_res {
-    ($w:expr) => (
-        {
-            $crate::errno::Errno::result($w)
-        }
-    );
+    ($w:expr) => {{
+        $crate::errno::Errno::result($w)
+    }};
 }
 
 /// Generates a wrapper function for an ioctl that passes no data to the kernel.
@@ -489,7 +497,7 @@ macro_rules! ioctl_write_ptr_bad {
     )
 }
 
-cfg_if!{
+cfg_if! {
     if #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))] {
         /// Generates a wrapper function for a ioctl that writes an integer to the kernel.
         ///
diff --git a/src/sys/memfd.rs b/src/sys/memfd.rs
index 642676b..e43e1e5 100644
--- a/src/sys/memfd.rs
+++ b/src/sys/memfd.rs
@@ -1,8 +1,10 @@
 //! Interfaces for managing memory-backed files.
 
+use cfg_if::cfg_if;
 use std::os::unix::io::RawFd;
-use crate::Result;
+
 use crate::errno::Errno;
+use crate::Result;
 use std::ffi::CStr;
 
 libc_bitflags!(
@@ -40,7 +42,24 @@ libc_bitflags!(
 /// [`memfd_create(2)`]: https://man7.org/linux/man-pages/man2/memfd_create.2.html
 pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result<RawFd> {
     let res = unsafe {
-        libc::syscall(libc::SYS_memfd_create, name.as_ptr(), flags.bits())
+        cfg_if! {
+            if #[cfg(all(
+                // Android does not have a memfd_create symbol
+                not(target_os = "android"),
+                any(
+                    target_os = "freebsd",
+                    // If the OS is Linux, gnu and musl expose a memfd_create symbol but not uclibc
+                    //
+                    // ANDROID: Our glibc is too old to have memfd_create.
+                    // target_env = "gnu",
+                    target_env = "musl",
+                )))]
+            {
+                libc::memfd_create(name.as_ptr(), flags.bits())
+            } else {
+                libc::syscall(libc::SYS_memfd_create, name.as_ptr(), flags.bits())
+            }
+        }
     };
 
     Errno::result(res).map(|r| r as RawFd)
diff --git a/src/sys/mman.rs b/src/sys/mman.rs
index 0ef1ca8..2bee091 100644
--- a/src/sys/mman.rs
+++ b/src/sys/mman.rs
@@ -1,17 +1,16 @@
 //! Memory management declarations.
 
-use crate::Result;
-#[cfg(not(target_os = "android"))]
-use crate::NixPath;
 use crate::errno::Errno;
 #[cfg(not(target_os = "android"))]
-use crate::fcntl::OFlag;
-use libc::{self, c_int, c_void, size_t, off_t};
+use crate::NixPath;
+use crate::Result;
 #[cfg(not(target_os = "android"))]
-use crate::sys::stat::Mode;
-use std::os::unix::io::RawFd;
+#[cfg(feature = "fs")]
+use crate::{fcntl::OFlag, sys::stat::Mode};
+use libc::{self, c_int, c_void, off_t, size_t};
+use std::{os::unix::io::RawFd, num::NonZeroUsize};
 
-libc_bitflags!{
+libc_bitflags! {
     /// Desired memory protection of a memory mapping.
     pub struct ProtFlags: c_int {
         /// Pages cannot be accessed.
@@ -24,14 +23,16 @@ libc_bitflags!{
         PROT_EXEC;
         /// Apply protection up to the end of a mapping that grows upwards.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PROT_GROWSDOWN;
         /// Apply protection down to the beginning of a mapping that grows downwards.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PROT_GROWSUP;
     }
 }
 
-libc_bitflags!{
+libc_bitflags! {
     /// Additional parameters for [`mmap`].
     pub struct MapFlags: c_int {
         /// Compatibility flag. Ignored.
@@ -42,9 +43,14 @@ libc_bitflags!{
         MAP_PRIVATE;
         /// Place the mapping at exactly the address specified in `addr`.
         MAP_FIXED;
+        /// Place the mapping at exactly the address specified in `addr`, but never clobber an existing range.
+        #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        MAP_FIXED_NOREPLACE;
         /// To be used with `MAP_FIXED`, to forbid the system
         /// to select a different address than the one specified.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_EXCL;
         /// Synonym for `MAP_ANONYMOUS`.
         MAP_ANON;
@@ -55,122 +61,156 @@ libc_bitflags!{
                       any(target_arch = "x86", target_arch = "x86_64")),
                   all(target_os = "linux", target_env = "musl", any(target_arch = "x86", target_arch = "x86_64")),
                   all(target_os = "freebsd", target_pointer_width = "64")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_32BIT;
         /// Used for stacks; indicates to the kernel that the mapping should extend downward in memory.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_GROWSDOWN;
         /// Compatibility flag. Ignored.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_DENYWRITE;
         /// Compatibility flag. Ignored.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_EXECUTABLE;
         /// Mark the mmaped region to be locked in the same way as `mlock(2)`.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_LOCKED;
         /// Do not reserve swap space for this mapping.
         ///
         /// This was removed in FreeBSD 11 and is unused in DragonFlyBSD.
         #[cfg(not(any(target_os = "dragonfly", target_os = "freebsd")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_NORESERVE;
         /// Populate page tables for a mapping.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_POPULATE;
         /// Only meaningful when used with `MAP_POPULATE`. Don't perform read-ahead.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_NONBLOCK;
         /// Allocate the mapping using "huge pages."
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGETLB;
         /// Make use of 64KB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_64KB;
         /// Make use of 512KB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_512KB;
         /// Make use of 1MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_1MB;
         /// Make use of 2MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_2MB;
         /// Make use of 8MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_8MB;
         /// Make use of 16MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_16MB;
         /// Make use of 32MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_32MB;
         /// Make use of 256MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_256MB;
         /// Make use of 512MB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_512MB;
         /// Make use of 1GB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_1GB;
         /// Make use of 2GB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_2GB;
         /// Make use of 16GB huge page (must be supported by the system)
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HUGE_16GB;
 
         /// Lock the mapped region into memory as with `mlock(2)`.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_WIRED;
         /// Causes dirtied data in the specified range to be flushed to disk only when necessary.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_NOSYNC;
         /// Rename private pages to a file.
         ///
         /// This was removed in FreeBSD 11 and is unused in DragonFlyBSD.
         #[cfg(any(target_os = "netbsd", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_RENAME;
         /// Region may contain semaphores.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_HASSEMAPHORE;
         /// Region grows down, like a stack.
         #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd", target_os = "linux", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_STACK;
         /// Pages in this mapping are not retained in the kernel's memory cache.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_NOCACHE;
         /// Allows the W/X bit on the page, it's necessary on aarch64 architecture.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_JIT;
         /// Allows to use large pages, underlying alignment based on size.
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_ALIGNED_SUPER;
         /// Pages will be discarded in the core dumps.
         #[cfg(target_os = "openbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_CONCEAL;
     }
 }
 
 #[cfg(any(target_os = "linux", target_os = "netbsd"))]
-libc_bitflags!{
+libc_bitflags! {
     /// Options for [`mremap`].
     pub struct MRemapFlags: c_int {
         /// Permit the kernel to relocate the mapping to a new virtual address, if necessary.
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MREMAP_MAYMOVE;
         /// Place the mapping at exactly the address specified in `new_address`.
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MREMAP_FIXED;
-        /// Permits to use the old and new address as hints to relocate the mapping.
+        /// Place the mapping at exactly the address specified in `new_address`.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_FIXED;
         /// Allows to duplicate the mapping to be able to apply different flags on the copy.
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MAP_REMAPDUP;
     }
 }
 
-libc_enum!{
+libc_enum! {
     /// Usage information for a range of memory to allow for performance optimizations by the kernel.
     ///
     /// Used by [`madvise`].
@@ -189,23 +229,29 @@ libc_enum!{
         MADV_DONTNEED,
         /// Free up a given range of pages and its associated backing store.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_REMOVE,
         /// Do not make pages in this range available to the child after a `fork(2)`.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_DONTFORK,
         /// Undo the effect of `MADV_DONTFORK`.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_DOFORK,
         /// Poison the given pages.
         ///
         /// Subsequent references to those pages are treated like hardware memory corruption.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_HWPOISON,
         /// Enable Kernel Samepage Merging (KSM) for the given pages.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_MERGEABLE,
         /// Undo the effect of `MADV_MERGEABLE`
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_UNMERGEABLE,
         /// Preserve the memory of each page but offline the original page.
         #[cfg(any(target_os = "android",
@@ -221,51 +267,71 @@ libc_enum!{
         MADV_SOFT_OFFLINE,
         /// Enable Transparent Huge Pages (THP) for pages in the given range.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_HUGEPAGE,
         /// Undo the effect of `MADV_HUGEPAGE`.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_NOHUGEPAGE,
         /// Exclude the given range from a core dump.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_DONTDUMP,
         /// Undo the effect of an earlier `MADV_DONTDUMP`.
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_DODUMP,
         /// Specify that the application no longer needs the pages in the given range.
         MADV_FREE,
         /// Request that the system not flush the current range to disk unless it needs to.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_NOSYNC,
         /// Undoes the effects of `MADV_NOSYNC` for any future pages dirtied within the given range.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_AUTOSYNC,
         /// Region is not included in a core file.
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_NOCORE,
         /// Include region in a core file
         #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_CORE,
+        /// This process should not be killed when swap space is exhausted.
         #[cfg(any(target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_PROTECT,
         /// Invalidate the hardware page table for the given region.
         #[cfg(target_os = "dragonfly")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_INVAL,
         /// Set the offset of the page directory page to `value` for the virtual page table.
         #[cfg(target_os = "dragonfly")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_SETMAP,
         /// Indicates that the application will not need the data in the given range.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_ZERO_WIRED_PAGES,
+        /// Pages can be reused (by anyone).
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_FREE_REUSABLE,
+        /// Caller wants to reuse those pages.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MADV_FREE_REUSE,
+        // Darwin doesn't document this flag's behavior.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        #[allow(missing_docs)]
         MADV_CAN_REUSE,
     }
 }
 
-libc_bitflags!{
+libc_bitflags! {
     /// Configuration flags for [`msync`].
     pub struct MsFlags: c_int {
         /// Schedule an update but return immediately.
@@ -274,16 +340,19 @@ libc_bitflags!{
         MS_INVALIDATE;
         /// Invalidate pages, but leave them mapped.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MS_KILLPAGES;
         /// Deactivate pages, but leave them mapped.
         #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MS_DEACTIVATE;
         /// Perform an update and wait for it to complete.
         MS_SYNC;
     }
 }
 
-libc_bitflags!{
+#[cfg(not(target_os = "haiku"))]
+libc_bitflags! {
     /// Flags for [`mlockall`].
     pub struct MlockAllFlags: c_int {
         /// Lock pages that are currently mapped into the address space of the process.
@@ -325,6 +394,7 @@ pub unsafe fn munlock(addr: *const c_void, length: size_t) -> Result<()> {
 /// Locked pages never move to the swap area. For more information, see [`mlockall(2)`].
 ///
 /// [`mlockall(2)`]: https://man7.org/linux/man-pages/man2/mlockall.2.html
+#[cfg(not(target_os = "haiku"))]
 pub fn mlockall(flags: MlockAllFlags) -> Result<()> {
     unsafe { Errno::result(libc::mlockall(flags.bits())) }.map(drop)
 }
@@ -334,6 +404,7 @@ pub fn mlockall(flags: MlockAllFlags) -> Result<()> {
 /// For more information, see [`munlockall(2)`].
 ///
 /// [`munlockall(2)`]: https://man7.org/linux/man-pages/man2/munlockall.2.html
+#[cfg(not(target_os = "haiku"))]
 pub fn munlockall() -> Result<()> {
     unsafe { Errno::result(libc::munlockall()) }.map(drop)
 }
@@ -345,8 +416,20 @@ pub fn munlockall() -> Result<()> {
 /// See the [`mmap(2)`] man page for detailed requirements.
 ///
 /// [`mmap(2)`]: https://man7.org/linux/man-pages/man2/mmap.2.html
-pub unsafe fn mmap(addr: *mut c_void, length: size_t, prot: ProtFlags, flags: MapFlags, fd: RawFd, offset: off_t) -> Result<*mut c_void> {
-    let ret = libc::mmap(addr, length, prot.bits(), flags.bits(), fd, offset);
+pub unsafe fn mmap(
+    addr: Option<NonZeroUsize>,
+    length: NonZeroUsize,
+    prot: ProtFlags,
+    flags: MapFlags,
+    fd: RawFd,
+    offset: off_t,
+) -> Result<*mut c_void> {
+    let ptr = addr.map_or(
+        std::ptr::null_mut(),
+        |a| usize::from(a) as *mut c_void
+    );
+    
+    let ret = libc::mmap(ptr, length.into(), prot.bits(), flags.bits(), fd, offset);
 
     if ret == libc::MAP_FAILED {
         Err(Errno::last())
@@ -368,10 +451,16 @@ pub unsafe fn mremap(
     old_size: size_t,
     new_size: size_t,
     flags: MRemapFlags,
-    new_address: Option<* mut c_void>,
+    new_address: Option<*mut c_void>,
 ) -> Result<*mut c_void> {
     #[cfg(target_os = "linux")]
-    let ret = libc::mremap(addr, old_size, new_size, flags.bits(), new_address.unwrap_or(std::ptr::null_mut()));
+    let ret = libc::mremap(
+        addr,
+        old_size,
+        new_size,
+        flags.bits(),
+        new_address.unwrap_or(std::ptr::null_mut()),
+    );
     #[cfg(target_os = "netbsd")]
     let ret = libc::mremap(
         addr,
@@ -379,7 +468,7 @@ pub unsafe fn mremap(
         new_address.unwrap_or(std::ptr::null_mut()),
         new_size,
         flags.bits(),
-        );
+    );
 
     if ret == libc::MAP_FAILED {
         Err(Errno::last())
@@ -408,7 +497,11 @@ pub unsafe fn munmap(addr: *mut c_void, len: size_t) -> Result<()> {
 /// [`MmapAdvise::MADV_FREE`].
 ///
 /// [`madvise(2)`]: https://man7.org/linux/man-pages/man2/madvise.2.html
-pub unsafe fn madvise(addr: *mut c_void, length: size_t, advise: MmapAdvise) -> Result<()> {
+pub unsafe fn madvise(
+    addr: *mut c_void,
+    length: size_t,
+    advise: MmapAdvise,
+) -> Result<()> {
     Errno::result(libc::madvise(addr, length, advise as i32)).map(drop)
 }
 
@@ -427,8 +520,9 @@ pub unsafe fn madvise(addr: *mut c_void, length: size_t, advise: MmapAdvise) ->
 /// # use nix::sys::mman::{mmap, mprotect, MapFlags, ProtFlags};
 /// # use std::ptr;
 /// const ONE_K: size_t = 1024;
+/// let one_k_non_zero = std::num::NonZeroUsize::new(ONE_K).unwrap();
 /// let mut slice: &mut [u8] = unsafe {
-///     let mem = mmap(ptr::null_mut(), ONE_K, ProtFlags::PROT_NONE,
+///     let mem = mmap(None, one_k_non_zero, ProtFlags::PROT_NONE,
 ///                    MapFlags::MAP_ANON | MapFlags::MAP_PRIVATE, -1, 0).unwrap();
 ///     mprotect(mem, ONE_K, ProtFlags::PROT_READ | ProtFlags::PROT_WRITE).unwrap();
 ///     std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)
@@ -437,7 +531,11 @@ pub unsafe fn madvise(addr: *mut c_void, length: size_t, advise: MmapAdvise) ->
 /// slice[0] = 0xFF;
 /// assert_eq!(slice[0], 0xFF);
 /// ```
-pub unsafe fn mprotect(addr: *mut c_void, length: size_t, prot: ProtFlags) -> Result<()> {
+pub unsafe fn mprotect(
+    addr: *mut c_void,
+    length: size_t,
+    prot: ProtFlags,
+) -> Result<()> {
     Errno::result(libc::mprotect(addr, length, prot.bits())).map(drop)
 }
 
@@ -449,17 +547,29 @@ pub unsafe fn mprotect(addr: *mut c_void, length: size_t, prot: ProtFlags) -> Re
 /// page.
 ///
 /// [`msync(2)`]: https://man7.org/linux/man-pages/man2/msync.2.html
-pub unsafe fn msync(addr: *mut c_void, length: size_t, flags: MsFlags) -> Result<()> {
+pub unsafe fn msync(
+    addr: *mut c_void,
+    length: size_t,
+    flags: MsFlags,
+) -> Result<()> {
     Errno::result(libc::msync(addr, length, flags.bits())).map(drop)
 }
 
+#[cfg(not(target_os = "android"))]
+feature! {
+#![feature = "fs"]
 /// Creates and opens a new, or opens an existing, POSIX shared memory object.
 ///
 /// For more information, see [`shm_open(3)`].
 ///
 /// [`shm_open(3)`]: https://man7.org/linux/man-pages/man3/shm_open.3.html
-#[cfg(not(target_os = "android"))]
-pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Result<RawFd> {
+pub fn shm_open<P>(
+    name: &P,
+    flag: OFlag,
+    mode: Mode
+    ) -> Result<RawFd>
+    where P: ?Sized + NixPath
+{
     let ret = name.with_nix_path(|cstr| {
         #[cfg(any(target_os = "macos", target_os = "ios"))]
         unsafe {
@@ -473,6 +583,7 @@ pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Resul
 
     Errno::result(ret)
 }
+}
 
 /// Performs the converse of [`shm_open`], removing an object previously created.
 ///
@@ -481,9 +592,8 @@ pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Resul
 /// [`shm_unlink(3)`]: https://man7.org/linux/man-pages/man3/shm_unlink.3.html
 #[cfg(not(target_os = "android"))]
 pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> Result<()> {
-    let ret = name.with_nix_path(|cstr| {
-        unsafe { libc::shm_unlink(cstr.as_ptr()) }
-    })?;
+    let ret =
+        name.with_nix_path(|cstr| unsafe { libc::shm_unlink(cstr.as_ptr()) })?;
 
     Errno::result(ret).map(drop)
 }
diff --git a/src/sys/mod.rs b/src/sys/mod.rs
index 156b0d9..2065059 100644
--- a/src/sys/mod.rs
+++ b/src/sys/mod.rs
@@ -1,130 +1,228 @@
 //! Mostly platform-specific functionality
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd"))]
-pub mod aio;
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod epoll;
-
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
-#[allow(missing_docs)]
-pub mod event;
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod eventfd;
-
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "redox",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "illumos",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "macos",
+    target_os = "netbsd"
+))]
+feature! {
+    #![feature = "aio"]
+    pub mod aio;
+}
+
+feature! {
+    #![feature = "event"]
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[allow(missing_docs)]
+    pub mod epoll;
+
+    #[cfg(any(target_os = "dragonfly",
+              target_os = "freebsd",
+              target_os = "ios",
+              target_os = "macos",
+              target_os = "netbsd",
+              target_os = "openbsd"))]
+    #[allow(missing_docs)]
+    pub mod event;
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[allow(missing_docs)]
+    pub mod eventfd;
+}
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "redox",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "illumos",
+    target_os = "openbsd"
+))]
+#[cfg(feature = "ioctl")]
+#[cfg_attr(docsrs, doc(cfg(feature = "ioctl")))]
 #[macro_use]
 pub mod ioctl;
 
-#[cfg(target_os = "linux")]
-pub mod memfd;
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+feature! {
+    #![feature = "fs"]
+    pub mod memfd;
+}
 
 #[cfg(not(target_os = "redox"))]
-#[allow(missing_docs)]
-pub mod mman;
+feature! {
+    #![feature = "mman"]
+    pub mod mman;
+}
 
 #[cfg(target_os = "linux")]
-#[allow(missing_docs)]
-pub mod personality;
-
-pub mod pthread;
-
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
-#[allow(missing_docs)]
-pub mod ptrace;
+feature! {
+    #![feature = "personality"]
+    pub mod personality;
+}
+
+feature! {
+    #![feature = "pthread"]
+    pub mod pthread;
+}
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+feature! {
+    #![feature = "ptrace"]
+    #[allow(missing_docs)]
+    pub mod ptrace;
+}
 
 #[cfg(target_os = "linux")]
-pub mod quota;
-
-#[cfg(any(target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod reboot;
+feature! {
+    #![feature = "quota"]
+    pub mod quota;
+}
 
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia", target_os = "illumos")))]
-pub mod resource;
+#[cfg(target_os = "linux")]
+feature! {
+    #![feature = "reboot"]
+    pub mod reboot;
+}
+
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "haiku"
+)))]
+feature! {
+    #![feature = "resource"]
+    pub mod resource;
+}
 
 #[cfg(not(target_os = "redox"))]
-pub mod select;
-
-#[cfg(any(target_os = "android",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos"))]
-pub mod sendfile;
+feature! {
+    #![feature = "poll"]
+    pub mod select;
+}
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos"
+))]
+feature! {
+    #![feature = "zerocopy"]
+    pub mod sendfile;
+}
 
 pub mod signal;
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod signalfd;
+feature! {
+    #![feature = "signal"]
+    #[allow(missing_docs)]
+    pub mod signalfd;
+}
 
 #[cfg(not(target_os = "redox"))]
-#[allow(missing_docs)]
-pub mod socket;
-
-#[allow(missing_docs)]
-pub mod stat;
-
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "openbsd"
+feature! {
+    #![feature = "socket"]
+    #[allow(missing_docs)]
+    pub mod socket;
+}
+
+feature! {
+    #![feature = "fs"]
+    #[allow(missing_docs)]
+    pub mod stat;
+}
+
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "openbsd"
 ))]
-pub mod statfs;
+feature! {
+    #![feature = "fs"]
+    pub mod statfs;
+}
 
-pub mod statvfs;
+feature! {
+    #![feature = "fs"]
+    pub mod statvfs;
+}
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 #[allow(missing_docs)]
 pub mod sysinfo;
 
-#[allow(missing_docs)]
-pub mod termios;
+feature! {
+    #![feature = "term"]
+    #[allow(missing_docs)]
+    pub mod termios;
+}
 
 #[allow(missing_docs)]
 pub mod time;
 
-pub mod uio;
+feature! {
+    #![feature = "uio"]
+    pub mod uio;
+}
 
-pub mod utsname;
+feature! {
+    #![feature = "feature"]
+    pub mod utsname;
+}
 
-pub mod wait;
+feature! {
+    #![feature = "process"]
+    pub mod wait;
+}
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod inotify;
+feature! {
+    #![feature = "inotify"]
+    pub mod inotify;
+}
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
-#[allow(missing_docs)]
-pub mod timerfd;
+feature! {
+    #![feature = "time"]
+    pub mod timerfd;
+}
+
+#[cfg(all(
+    any(
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd"
+    ),
+    feature = "time",
+    feature = "signal"
+))]
+feature! {
+    #![feature = "time"]
+    pub mod timer;
+}
diff --git a/src/sys/personality.rs b/src/sys/personality.rs
index b15956c..f295a05 100644
--- a/src/sys/personality.rs
+++ b/src/sys/personality.rs
@@ -1,5 +1,6 @@
-use crate::Result;
+//! Process execution domains
 use crate::errno::Errno;
+use crate::Result;
 
 use libc::{self, c_int, c_ulong};
 
@@ -7,18 +8,44 @@ libc_bitflags! {
     /// Flags used and returned by [`get()`](fn.get.html) and
     /// [`set()`](fn.set.html).
     pub struct Persona: c_int {
+        /// Provide the legacy virtual address space layout.
         ADDR_COMPAT_LAYOUT;
+        /// Disable address-space-layout randomization.
         ADDR_NO_RANDOMIZE;
+        /// Limit the address space to 32 bits.
         ADDR_LIMIT_32BIT;
+        /// Use `0xc0000000` as the offset at which to search a virtual memory
+        /// chunk on [`mmap(2)`], otherwise use `0xffffe000`.
+        ///
+        /// [`mmap(2)`]: https://man7.org/linux/man-pages/man2/mmap.2.html
         ADDR_LIMIT_3GB;
-        #[cfg(not(target_env = "musl"))]
+        /// User-space function pointers to signal handlers point to descriptors.
+        #[cfg(not(any(target_env = "musl", target_env = "uclibc")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         FDPIC_FUNCPTRS;
+        /// Map page 0 as read-only.
         MMAP_PAGE_ZERO;
+        /// `PROT_READ` implies `PROT_EXEC` for [`mmap(2)`].
+        ///
+        /// [`mmap(2)`]: https://man7.org/linux/man-pages/man2/mmap.2.html
         READ_IMPLIES_EXEC;
+        /// No effects.
         SHORT_INODE;
+        /// [`select(2)`], [`pselect(2)`], and [`ppoll(2)`] do not modify the
+        /// returned timeout argument when interrupted by a signal handler.
+        ///
+        /// [`select(2)`]: https://man7.org/linux/man-pages/man2/select.2.html
+        /// [`pselect(2)`]: https://man7.org/linux/man-pages/man2/pselect.2.html
+        /// [`ppoll(2)`]: https://man7.org/linux/man-pages/man2/ppoll.2.html
         STICKY_TIMEOUTS;
-        #[cfg(not(target_env = "musl"))]
+        /// Have [`uname(2)`] report a 2.6.40+ version number rather than a 3.x
+        /// version number.
+        ///
+        /// [`uname(2)`]: https://man7.org/linux/man-pages/man2/uname.2.html
+        #[cfg(not(any(target_env = "musl", target_env = "uclibc")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         UNAME26;
+        /// No effects.
         WHOLE_SECONDS;
     }
 }
@@ -35,9 +62,7 @@ libc_bitflags! {
 /// assert!(!pers.contains(Persona::WHOLE_SECONDS));
 /// ```
 pub fn get() -> Result<Persona> {
-    let res = unsafe {
-        libc::personality(0xFFFFFFFF)
-    };
+    let res = unsafe { libc::personality(0xFFFFFFFF) };
 
     Errno::result(res).map(Persona::from_bits_truncate)
 }
@@ -59,12 +84,10 @@ pub fn get() -> Result<Persona> {
 /// # use nix::sys::personality::{self, Persona};
 /// let mut pers = personality::get().unwrap();
 /// assert!(!pers.contains(Persona::ADDR_NO_RANDOMIZE));
-/// personality::set(pers | Persona::ADDR_NO_RANDOMIZE);
+/// personality::set(pers | Persona::ADDR_NO_RANDOMIZE).unwrap();
 /// ```
 pub fn set(persona: Persona) -> Result<Persona> {
-    let res = unsafe {
-        libc::personality(persona.bits() as c_ulong)
-    };
+    let res = unsafe { libc::personality(persona.bits() as c_ulong) };
 
     Errno::result(res).map(Persona::from_bits_truncate)
 }
diff --git a/src/sys/pthread.rs b/src/sys/pthread.rs
index d42e45d..6bad03a 100644
--- a/src/sys/pthread.rs
+++ b/src/sys/pthread.rs
@@ -4,8 +4,6 @@
 use crate::errno::Errno;
 #[cfg(not(target_os = "redox"))]
 use crate::Result;
-#[cfg(not(target_os = "redox"))]
-use crate::sys::signal::Signal;
 use libc::{self, pthread_t};
 
 /// Identifies an individual thread.
@@ -21,14 +19,20 @@ pub fn pthread_self() -> Pthread {
     unsafe { libc::pthread_self() }
 }
 
+feature! {
+#![feature = "signal"]
+
 /// Send a signal to a thread (see [`pthread_kill(3)`]).
 ///
 /// If `signal` is `None`, `pthread_kill` will only preform error checking and
 /// won't send any signal.
 ///
 /// [`pthread_kill(3)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_kill.html
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 #[cfg(not(target_os = "redox"))]
-pub fn pthread_kill<T: Into<Option<Signal>>>(thread: Pthread, signal: T) -> Result<()> {
+pub fn pthread_kill<T>(thread: Pthread, signal: T) -> Result<()>
+    where T: Into<Option<crate::sys::signal::Signal>>
+{
     let sig = match signal.into() {
         Some(s) => s as libc::c_int,
         None => 0,
@@ -36,3 +40,4 @@ pub fn pthread_kill<T: Into<Option<Signal>>>(thread: Pthread, signal: T) -> Resu
     let res = unsafe { libc::pthread_kill(thread, sig) };
     Errno::result(res).map(drop)
 }
+}
diff --git a/src/sys/ptrace/bsd.rs b/src/sys/ptrace/bsd.rs
index a62881e..ba267c6 100644
--- a/src/sys/ptrace/bsd.rs
+++ b/src/sys/ptrace/bsd.rs
@@ -1,16 +1,16 @@
-use cfg_if::cfg_if;
 use crate::errno::Errno;
-use libc::{self, c_int};
-use std::ptr;
 use crate::sys::signal::Signal;
 use crate::unistd::Pid;
 use crate::Result;
+use cfg_if::cfg_if;
+use libc::{self, c_int};
+use std::ptr;
 
 pub type RequestType = c_int;
 
 cfg_if! {
-    if #[cfg(any(target_os = "dragonfly", 
-                 target_os = "freebsd", 
+    if #[cfg(any(target_os = "dragonfly",
+                 target_os = "freebsd",
                  target_os = "macos",
                  target_os = "openbsd"))] {
         #[doc(hidden)]
@@ -30,10 +30,12 @@ libc_enum! {
         PT_READ_I,
         PT_READ_D,
         #[cfg(target_os = "macos")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PT_READ_U,
         PT_WRITE_I,
         PT_WRITE_D,
         #[cfg(target_os = "macos")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PT_WRITE_U,
         PT_CONTINUE,
         PT_KILL,
@@ -47,10 +49,13 @@ libc_enum! {
         PT_ATTACH,
         PT_DETACH,
         #[cfg(target_os = "macos")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PT_SIGEXC,
         #[cfg(target_os = "macos")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PT_THUPDATE,
         #[cfg(target_os = "macos")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PT_ATTACHEXC
     }
 }
@@ -66,7 +71,8 @@ unsafe fn ptrace_other(
         libc::pid_t::from(pid),
         addr,
         data,
-    )).map(|_| 0)
+    ))
+    .map(|_| 0)
 }
 
 /// Sets the process as traceable, as with `ptrace(PT_TRACEME, ...)`
@@ -74,14 +80,19 @@ unsafe fn ptrace_other(
 /// Indicates that this process is to be traced by its parent.
 /// This is the only ptrace request to be issued by the tracee.
 pub fn traceme() -> Result<()> {
-    unsafe { ptrace_other(Request::PT_TRACE_ME, Pid::from_raw(0), ptr::null_mut(), 0).map(drop) }
+    unsafe {
+        ptrace_other(Request::PT_TRACE_ME, Pid::from_raw(0), ptr::null_mut(), 0)
+            .map(drop)
+    }
 }
 
 /// Attach to a running process, as with `ptrace(PT_ATTACH, ...)`
 ///
 /// Attaches to the process specified by `pid`, making it a tracee of the calling process.
 pub fn attach(pid: Pid) -> Result<()> {
-    unsafe { ptrace_other(Request::PT_ATTACH, pid, ptr::null_mut(), 0).map(drop) }
+    unsafe {
+        ptrace_other(Request::PT_ATTACH, pid, ptr::null_mut(), 0).map(drop)
+    }
 }
 
 /// Detaches the current running process, as with `ptrace(PT_DETACH, ...)`
@@ -109,13 +120,14 @@ pub fn cont<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
     };
     unsafe {
         // Ignore the useless return value
-        ptrace_other(Request::PT_CONTINUE, pid, 1 as AddressType, data).map(drop)
+        ptrace_other(Request::PT_CONTINUE, pid, 1 as AddressType, data)
+            .map(drop)
     }
 }
 
 /// Issues a kill request as with `ptrace(PT_KILL, ...)`
 ///
-/// This request is equivalent to `ptrace(PT_CONTINUE, ..., SIGKILL);` 
+/// This request is equivalent to `ptrace(PT_CONTINUE, ..., SIGKILL);`
 pub fn kill(pid: Pid) -> Result<()> {
     unsafe {
         ptrace_other(Request::PT_KILL, pid, 0 as AddressType, 0).map(drop)
@@ -144,24 +156,28 @@ pub fn kill(pid: Pid) -> Result<()> {
 ///     _ => {},
 /// }
 /// ```
-#[cfg(
-    any(
-        any(target_os = "dragonfly", target_os = "freebsd", target_os = "macos"),
-        all(target_os = "openbsd", target_arch = "x86_64"),
-        all(target_os = "netbsd",
-            any(target_arch = "x86_64", target_arch = "powerpc")
-        )
+#[cfg(any(
+    any(target_os = "dragonfly", target_os = "freebsd", target_os = "macos"),
+    all(target_os = "openbsd", target_arch = "x86_64"),
+    all(
+        target_os = "netbsd",
+        any(target_arch = "x86_64", target_arch = "powerpc")
     )
-)]
+))]
 pub fn step<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
     let data = match sig.into() {
         Some(s) => s as c_int,
         None => 0,
     };
-    unsafe { ptrace_other(Request::PT_STEP, pid, ptr::null_mut(), data).map(drop) }
+    unsafe {
+        ptrace_other(Request::PT_STEP, pid, ptr::null_mut(), data).map(drop)
+    }
 }
 
 /// Reads a word from a processes memory at the given address
+// Technically, ptrace doesn't dereference the pointer.  It passes it directly
+// to the kernel.
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub fn read(pid: Pid, addr: AddressType) -> Result<c_int> {
     unsafe {
         // Traditionally there was a difference between reading data or
@@ -171,6 +187,9 @@ pub fn read(pid: Pid, addr: AddressType) -> Result<c_int> {
 }
 
 /// Writes a word into the processes memory at the given address
+// Technically, ptrace doesn't dereference the pointer.  It passes it directly
+// to the kernel.
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub fn write(pid: Pid, addr: AddressType, data: c_int) -> Result<()> {
     unsafe { ptrace_other(Request::PT_WRITE_D, pid, addr, data).map(drop) }
 }
diff --git a/src/sys/ptrace/linux.rs b/src/sys/ptrace/linux.rs
index 3723679..9687e05 100644
--- a/src/sys/ptrace/linux.rs
+++ b/src/sys/ptrace/linux.rs
@@ -1,26 +1,31 @@
 //! For detailed description of the ptrace requests, consult `man ptrace`.
 
-use cfg_if::cfg_if;
-use std::{mem, ptr};
-use crate::Result;
 use crate::errno::Errno;
-use libc::{self, c_void, c_long, siginfo_t};
-use crate::unistd::Pid;
 use crate::sys::signal::Signal;
+use crate::unistd::Pid;
+use crate::Result;
+use cfg_if::cfg_if;
+use libc::{self, c_long, c_void, siginfo_t};
+use std::{mem, ptr};
 
 pub type AddressType = *mut ::libc::c_void;
 
 #[cfg(all(
     target_os = "linux",
-    any(all(target_arch = "x86_64",
-            any(target_env = "gnu", target_env = "musl")),
-        all(target_arch = "x86", target_env = "gnu"))
+    any(
+        all(
+            target_arch = "x86_64",
+            any(target_env = "gnu", target_env = "musl")
+        ),
+        all(target_arch = "x86", target_env = "gnu")
+    )
 ))]
 use libc::user_regs_struct;
 
 cfg_if! {
     if #[cfg(any(all(target_os = "linux", target_arch = "s390x"),
-                 all(target_os = "linux", target_env = "gnu")))] {
+                 all(target_os = "linux", target_env = "gnu"),
+                 target_env = "uclibc"))] {
         #[doc(hidden)]
         pub type RequestType = ::libc::c_uint;
     } else {
@@ -29,9 +34,9 @@ cfg_if! {
     }
 }
 
-libc_enum!{
-    #[cfg_attr(not(any(target_env = "musl", target_os = "android")), repr(u32))]
-    #[cfg_attr(any(target_env = "musl", target_os = "android"), repr(i32))]
+libc_enum! {
+    #[cfg_attr(not(any(target_env = "musl", target_env = "uclibc", target_os = "android")), repr(u32))]
+    #[cfg_attr(any(target_env = "musl", target_env = "uclibc", target_os = "android"), repr(i32))]
     /// Ptrace Request enum defining the action to be taken.
     #[non_exhaustive]
     pub enum Request {
@@ -99,8 +104,10 @@ libc_enum!{
                                                target_arch = "mips64"))))]
         PTRACE_SETREGSET,
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PTRACE_SEIZE,
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PTRACE_INTERRUPT,
         #[cfg(all(target_os = "linux", not(any(target_arch = "mips",
                                                target_arch = "mips64"))))]
@@ -117,7 +124,7 @@ libc_enum!{
     }
 }
 
-libc_enum!{
+libc_enum! {
     #[repr(i32)]
     /// Using the ptrace options the tracer can configure the tracee to stop
     /// at certain events. This enum is used to define those events as defined
@@ -171,12 +178,16 @@ libc_bitflags! {
         PTRACE_O_TRACESECCOMP;
         /// Send a SIGKILL to the tracee if the tracer exits.  This is useful
         /// for ptrace jailers to prevent tracees from escaping their control.
-        #[cfg(any(target_os = "android", target_os = "linux"))]
         PTRACE_O_EXITKILL;
     }
 }
 
-fn ptrace_peek(request: Request, pid: Pid, addr: AddressType, data: *mut c_void) -> Result<c_long> {
+fn ptrace_peek(
+    request: Request,
+    pid: Pid,
+    addr: AddressType,
+    data: *mut c_void,
+) -> Result<c_long> {
     let ret = unsafe {
         Errno::clear();
         libc::ptrace(request as RequestType, libc::pid_t::from(pid), addr, data)
@@ -190,9 +201,13 @@ fn ptrace_peek(request: Request, pid: Pid, addr: AddressType, data: *mut c_void)
 /// Get user registers, as with `ptrace(PTRACE_GETREGS, ...)`
 #[cfg(all(
     target_os = "linux",
-    any(all(target_arch = "x86_64",
-            any(target_env = "gnu", target_env = "musl")),
-        all(target_arch = "x86", target_env = "gnu"))
+    any(
+        all(
+            target_arch = "x86_64",
+            any(target_env = "gnu", target_env = "musl")
+        ),
+        all(target_arch = "x86", target_env = "gnu")
+    )
 ))]
 pub fn getregs(pid: Pid) -> Result<user_regs_struct> {
     ptrace_get_data::<user_regs_struct>(Request::PTRACE_GETREGS, pid)
@@ -201,16 +216,22 @@ pub fn getregs(pid: Pid) -> Result<user_regs_struct> {
 /// Set user registers, as with `ptrace(PTRACE_SETREGS, ...)`
 #[cfg(all(
     target_os = "linux",
-    any(all(target_arch = "x86_64",
-            any(target_env = "gnu", target_env = "musl")),
-        all(target_arch = "x86", target_env = "gnu"))
+    any(
+        all(
+            target_arch = "x86_64",
+            any(target_env = "gnu", target_env = "musl")
+        ),
+        all(target_arch = "x86", target_env = "gnu")
+    )
 ))]
 pub fn setregs(pid: Pid, regs: user_regs_struct) -> Result<()> {
     let res = unsafe {
-        libc::ptrace(Request::PTRACE_SETREGS as RequestType,
-                     libc::pid_t::from(pid),
-                     ptr::null_mut::<c_void>(),
-                     &regs as *const _ as *const c_void)
+        libc::ptrace(
+            Request::PTRACE_SETREGS as RequestType,
+            libc::pid_t::from(pid),
+            ptr::null_mut::<c_void>(),
+            &regs as *const _ as *const c_void,
+        )
     };
     Errno::result(res).map(drop)
 }
@@ -222,26 +243,41 @@ pub fn setregs(pid: Pid, regs: user_regs_struct) -> Result<()> {
 fn ptrace_get_data<T>(request: Request, pid: Pid) -> Result<T> {
     let mut data = mem::MaybeUninit::uninit();
     let res = unsafe {
-        libc::ptrace(request as RequestType,
-                     libc::pid_t::from(pid),
-                     ptr::null_mut::<T>(),
-                     data.as_mut_ptr() as *const _ as *const c_void)
+        libc::ptrace(
+            request as RequestType,
+            libc::pid_t::from(pid),
+            ptr::null_mut::<T>(),
+            data.as_mut_ptr() as *const _ as *const c_void,
+        )
     };
     Errno::result(res)?;
-    Ok(unsafe{ data.assume_init() })
+    Ok(unsafe { data.assume_init() })
 }
 
-unsafe fn ptrace_other(request: Request, pid: Pid, addr: AddressType, data: *mut c_void) -> Result<c_long> {
-    Errno::result(libc::ptrace(request as RequestType, libc::pid_t::from(pid), addr, data)).map(|_| 0)
+unsafe fn ptrace_other(
+    request: Request,
+    pid: Pid,
+    addr: AddressType,
+    data: *mut c_void,
+) -> Result<c_long> {
+    Errno::result(libc::ptrace(
+        request as RequestType,
+        libc::pid_t::from(pid),
+        addr,
+        data,
+    ))
+    .map(|_| 0)
 }
 
 /// Set options, as with `ptrace(PTRACE_SETOPTIONS,...)`.
 pub fn setoptions(pid: Pid, options: Options) -> Result<()> {
     let res = unsafe {
-        libc::ptrace(Request::PTRACE_SETOPTIONS as RequestType,
-                     libc::pid_t::from(pid),
-                     ptr::null_mut::<c_void>(),
-                     options.bits() as *mut c_void)
+        libc::ptrace(
+            Request::PTRACE_SETOPTIONS as RequestType,
+            libc::pid_t::from(pid),
+            ptr::null_mut::<c_void>(),
+            options.bits() as *mut c_void,
+        )
     };
     Errno::result(res).map(drop)
 }
@@ -258,12 +294,14 @@ pub fn getsiginfo(pid: Pid) -> Result<siginfo_t> {
 
 /// Set siginfo as with `ptrace(PTRACE_SETSIGINFO,...)`
 pub fn setsiginfo(pid: Pid, sig: &siginfo_t) -> Result<()> {
-    let ret = unsafe{
+    let ret = unsafe {
         Errno::clear();
-        libc::ptrace(Request::PTRACE_SETSIGINFO as RequestType,
-                     libc::pid_t::from(pid),
-                     ptr::null_mut::<c_void>(),
-                     sig as *const _ as *const c_void)
+        libc::ptrace(
+            Request::PTRACE_SETSIGINFO as RequestType,
+            libc::pid_t::from(pid),
+            ptr::null_mut::<c_void>(),
+            sig as *const _ as *const c_void,
+        )
     };
     match Errno::result(ret) {
         Ok(_) => Ok(()),
@@ -282,7 +320,8 @@ pub fn traceme() -> Result<()> {
             Pid::from_raw(0),
             ptr::null_mut(),
             ptr::null_mut(),
-        ).map(drop) // ignore the useless return value
+        )
+        .map(drop) // ignore the useless return value
     }
 }
 
@@ -296,12 +335,8 @@ pub fn syscall<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
         None => ptr::null_mut(),
     };
     unsafe {
-        ptrace_other(
-            Request::PTRACE_SYSCALL,
-            pid,
-            ptr::null_mut(),
-            data,
-        ).map(drop) // ignore the useless return value
+        ptrace_other(Request::PTRACE_SYSCALL, pid, ptr::null_mut(), data)
+            .map(drop) // ignore the useless return value
     }
 }
 
@@ -310,14 +345,19 @@ pub fn syscall<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
 /// In contrast to the `syscall` function, the syscall stopped at will not be executed.
 /// Thus the the tracee will only be stopped once per syscall,
 /// optionally delivering a signal specified by `sig`.
-#[cfg(all(target_os = "linux", target_env = "gnu", any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(target_arch = "x86", target_arch = "x86_64")
+))]
 pub fn sysemu<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
     let data = match sig.into() {
         Some(s) => s as i32 as *mut c_void,
         None => ptr::null_mut(),
     };
     unsafe {
-        ptrace_other(Request::PTRACE_SYSEMU, pid, ptr::null_mut(), data).map(drop)
+        ptrace_other(Request::PTRACE_SYSEMU, pid, ptr::null_mut(), data)
+            .map(drop)
         // ignore the useless return value
     }
 }
@@ -332,7 +372,8 @@ pub fn attach(pid: Pid) -> Result<()> {
             pid,
             ptr::null_mut(),
             ptr::null_mut(),
-        ).map(drop) // ignore the useless return value
+        )
+        .map(drop) // ignore the useless return value
     }
 }
 
@@ -340,6 +381,7 @@ pub fn attach(pid: Pid) -> Result<()> {
 ///
 /// Attaches to the process specified in pid, making it a tracee of the calling process.
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn seize(pid: Pid, options: Options) -> Result<()> {
     unsafe {
         ptrace_other(
@@ -347,7 +389,8 @@ pub fn seize(pid: Pid, options: Options) -> Result<()> {
             pid,
             ptr::null_mut(),
             options.bits() as *mut c_void,
-        ).map(drop) // ignore the useless return value
+        )
+        .map(drop) // ignore the useless return value
     }
 }
 
@@ -361,12 +404,8 @@ pub fn detach<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
         None => ptr::null_mut(),
     };
     unsafe {
-        ptrace_other(
-            Request::PTRACE_DETACH,
-            pid,
-            ptr::null_mut(),
-            data
-        ).map(drop)
+        ptrace_other(Request::PTRACE_DETACH, pid, ptr::null_mut(), data)
+            .map(drop)
     }
 }
 
@@ -380,7 +419,8 @@ pub fn cont<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
         None => ptr::null_mut(),
     };
     unsafe {
-        ptrace_other(Request::PTRACE_CONT, pid, ptr::null_mut(), data).map(drop) // ignore the useless return value
+        ptrace_other(Request::PTRACE_CONT, pid, ptr::null_mut(), data).map(drop)
+        // ignore the useless return value
     }
 }
 
@@ -388,9 +428,16 @@ pub fn cont<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
 ///
 /// This request is equivalent to `ptrace(PTRACE_INTERRUPT, ...)`
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn interrupt(pid: Pid) -> Result<()> {
     unsafe {
-        ptrace_other(Request::PTRACE_INTERRUPT, pid, ptr::null_mut(), ptr::null_mut()).map(drop)
+        ptrace_other(
+            Request::PTRACE_INTERRUPT,
+            pid,
+            ptr::null_mut(),
+            ptr::null_mut(),
+        )
+        .map(drop)
     }
 }
 
@@ -399,7 +446,13 @@ pub fn interrupt(pid: Pid) -> Result<()> {
 /// This request is equivalent to `ptrace(PTRACE_CONT, ..., SIGKILL);`
 pub fn kill(pid: Pid) -> Result<()> {
     unsafe {
-        ptrace_other(Request::PTRACE_KILL, pid, ptr::null_mut(), ptr::null_mut()).map(drop)
+        ptrace_other(
+            Request::PTRACE_KILL,
+            pid,
+            ptr::null_mut(),
+            ptr::null_mut(),
+        )
+        .map(drop)
     }
 }
 
@@ -432,7 +485,8 @@ pub fn step<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
         None => ptr::null_mut(),
     };
     unsafe {
-        ptrace_other(Request::PTRACE_SINGLESTEP, pid, ptr::null_mut(), data).map(drop)
+        ptrace_other(Request::PTRACE_SINGLESTEP, pid, ptr::null_mut(), data)
+            .map(drop)
     }
 }
 
@@ -442,7 +496,11 @@ pub fn step<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
 /// Advances the execution by a single step or until the next syscall.
 /// In case the tracee is stopped at a syscall, the syscall will not be executed.
 /// Optionally, the signal specified by `sig` is delivered to the tracee upon continuation.
-#[cfg(all(target_os = "linux", target_env = "gnu", any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(all(
+    target_os = "linux",
+    target_env = "gnu",
+    any(target_arch = "x86", target_arch = "x86_64")
+))]
 pub fn sysemu_step<T: Into<Option<Signal>>>(pid: Pid, sig: T) -> Result<()> {
     let data = match sig.into() {
         Some(s) => s as i32 as *mut c_void,
@@ -473,7 +531,28 @@ pub fn read(pid: Pid, addr: AddressType) -> Result<c_long> {
 pub unsafe fn write(
     pid: Pid,
     addr: AddressType,
-    data: *mut c_void) -> Result<()>
-{
+    data: *mut c_void,
+) -> Result<()> {
     ptrace_other(Request::PTRACE_POKEDATA, pid, addr, data).map(drop)
 }
+
+/// Reads a word from a user area at `offset`.
+/// The user struct definition can be found in `/usr/include/sys/user.h`.
+pub fn read_user(pid: Pid, offset: AddressType) -> Result<c_long> {
+    ptrace_peek(Request::PTRACE_PEEKUSER, pid, offset, ptr::null_mut())
+}
+
+/// Writes a word to a user area at `offset`.
+/// The user struct definition can be found in `/usr/include/sys/user.h`.
+///
+/// # Safety
+///
+/// The `data` argument is passed directly to `ptrace(2)`.  Read that man page
+/// for guidance.
+pub unsafe fn write_user(
+    pid: Pid,
+    offset: AddressType,
+    data: *mut c_void,
+) -> Result<()> {
+    ptrace_other(Request::PTRACE_POKEUSER, pid, offset, data).map(drop)
+}
diff --git a/src/sys/ptrace/mod.rs b/src/sys/ptrace/mod.rs
index 782c304..2b121c0 100644
--- a/src/sys/ptrace/mod.rs
+++ b/src/sys/ptrace/mod.rs
@@ -1,4 +1,4 @@
-///! Provides helpers for making ptrace system calls 
+///! Provides helpers for making ptrace system calls
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod linux;
@@ -6,17 +6,20 @@ mod linux;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 pub use self::linux::*;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 mod bsd;
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"
-          ))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 pub use self::bsd::*;
diff --git a/src/sys/quota.rs b/src/sys/quota.rs
index 6e34e38..b3c44ca 100644
--- a/src/sys/quota.rs
+++ b/src/sys/quota.rs
@@ -6,17 +6,17 @@
 //!
 //! ```rust,no_run
 //! # use nix::sys::quota::{Dqblk, quotactl_on, quotactl_set, QuotaFmt, QuotaType, QuotaValidFlags};
-//! quotactl_on(QuotaType::USRQUOTA, "/dev/sda1", QuotaFmt::QFMT_VFS_V1, "aquota.user");
+//! quotactl_on(QuotaType::USRQUOTA, "/dev/sda1", QuotaFmt::QFMT_VFS_V1, "aquota.user").unwrap();
 //! let mut dqblk: Dqblk = Default::default();
 //! dqblk.set_blocks_hard_limit(10000);
 //! dqblk.set_blocks_soft_limit(8000);
-//! quotactl_set(QuotaType::USRQUOTA, "/dev/sda1", 50, &dqblk, QuotaValidFlags::QIF_BLIMITS);
+//! quotactl_set(QuotaType::USRQUOTA, "/dev/sda1", 50, &dqblk, QuotaValidFlags::QIF_BLIMITS).unwrap();
 //! ```
+use crate::errno::Errno;
+use crate::{NixPath, Result};
+use libc::{self, c_char, c_int};
 use std::default::Default;
 use std::{mem, ptr};
-use libc::{self, c_int, c_char};
-use crate::{Result, NixPath};
-use crate::errno::Errno;
 
 struct QuotaCmd(QuotaSubCmd, QuotaType);
 
@@ -28,7 +28,7 @@ impl QuotaCmd {
 }
 
 // linux quota version >= 2
-libc_enum!{
+libc_enum! {
     #[repr(i32)]
     enum QuotaSubCmd {
         Q_SYNC,
@@ -39,7 +39,7 @@ libc_enum!{
     }
 }
 
-libc_enum!{
+libc_enum! {
     /// The scope of the quota.
     #[repr(i32)]
     #[non_exhaustive]
@@ -51,7 +51,7 @@ libc_enum!{
     }
 }
 
-libc_enum!{
+libc_enum! {
     /// The type of quota format to use.
     #[repr(i32)]
     #[non_exhaustive]
@@ -120,7 +120,8 @@ impl Default for Dqblk {
 impl Dqblk {
     /// The absolute limit on disk quota blocks allocated.
     pub fn blocks_hard_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_BLIMITS) {
             Some(self.0.dqb_bhardlimit)
         } else {
@@ -135,7 +136,8 @@ impl Dqblk {
 
     /// Preferred limit on disk quota blocks
     pub fn blocks_soft_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_BLIMITS) {
             Some(self.0.dqb_bsoftlimit)
         } else {
@@ -150,7 +152,8 @@ impl Dqblk {
 
     /// Current occupied space (bytes).
     pub fn occupied_space(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_SPACE) {
             Some(self.0.dqb_curspace)
         } else {
@@ -160,7 +163,8 @@ impl Dqblk {
 
     /// Maximum number of allocated inodes.
     pub fn inodes_hard_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_ILIMITS) {
             Some(self.0.dqb_ihardlimit)
         } else {
@@ -175,7 +179,8 @@ impl Dqblk {
 
     /// Preferred inode limit
     pub fn inodes_soft_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_ILIMITS) {
             Some(self.0.dqb_isoftlimit)
         } else {
@@ -190,7 +195,8 @@ impl Dqblk {
 
     /// Current number of allocated inodes.
     pub fn allocated_inodes(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_INODES) {
             Some(self.0.dqb_curinodes)
         } else {
@@ -200,7 +206,8 @@ impl Dqblk {
 
     /// Time limit for excessive disk use.
     pub fn block_time_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_BTIME) {
             Some(self.0.dqb_btime)
         } else {
@@ -215,7 +222,8 @@ impl Dqblk {
 
     /// Time limit for excessive files.
     pub fn inode_time_limit(&self) -> Option<u64> {
-        let valid_fields = QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
+        let valid_fields =
+            QuotaValidFlags::from_bits_truncate(self.0.dqb_valid);
         if valid_fields.contains(QuotaValidFlags::QIF_ITIME) {
             Some(self.0.dqb_itime)
         } else {
@@ -229,11 +237,18 @@ impl Dqblk {
     }
 }
 
-fn quotactl<P: ?Sized + NixPath>(cmd: QuotaCmd, special: Option<&P>, id: c_int, addr: *mut c_char) -> Result<()> {
+fn quotactl<P: ?Sized + NixPath>(
+    cmd: QuotaCmd,
+    special: Option<&P>,
+    id: c_int,
+    addr: *mut c_char,
+) -> Result<()> {
     unsafe {
         Errno::clear();
         let res = match special {
-            Some(dev) => dev.with_nix_path(|path| libc::quotactl(cmd.as_int(), path.as_ptr(), id, addr)),
+            Some(dev) => dev.with_nix_path(|path| {
+                libc::quotactl(cmd.as_int(), path.as_ptr(), id, addr)
+            }),
             None => Ok(libc::quotactl(cmd.as_int(), ptr::null(), id, addr)),
         }?;
 
@@ -242,36 +257,82 @@ fn quotactl<P: ?Sized + NixPath>(cmd: QuotaCmd, special: Option<&P>, id: c_int,
 }
 
 /// Turn on disk quotas for a block device.
-pub fn quotactl_on<P: ?Sized + NixPath>(which: QuotaType, special: &P, format: QuotaFmt, quota_file: &P) -> Result<()> {
+pub fn quotactl_on<P: ?Sized + NixPath>(
+    which: QuotaType,
+    special: &P,
+    format: QuotaFmt,
+    quota_file: &P,
+) -> Result<()> {
     quota_file.with_nix_path(|path| {
         let mut path_copy = path.to_bytes_with_nul().to_owned();
         let p: *mut c_char = path_copy.as_mut_ptr() as *mut c_char;
-        quotactl(QuotaCmd(QuotaSubCmd::Q_QUOTAON, which), Some(special), format as c_int, p)
+        quotactl(
+            QuotaCmd(QuotaSubCmd::Q_QUOTAON, which),
+            Some(special),
+            format as c_int,
+            p,
+        )
     })?
 }
 
 /// Disable disk quotas for a block device.
-pub fn quotactl_off<P: ?Sized + NixPath>(which: QuotaType, special: &P) -> Result<()> {
-    quotactl(QuotaCmd(QuotaSubCmd::Q_QUOTAOFF, which), Some(special), 0, ptr::null_mut())
+pub fn quotactl_off<P: ?Sized + NixPath>(
+    which: QuotaType,
+    special: &P,
+) -> Result<()> {
+    quotactl(
+        QuotaCmd(QuotaSubCmd::Q_QUOTAOFF, which),
+        Some(special),
+        0,
+        ptr::null_mut(),
+    )
 }
 
 /// Update the on-disk copy of quota usages for a filesystem.
 ///
 /// If `special` is `None`, then all file systems with active quotas are sync'd.
-pub fn quotactl_sync<P: ?Sized + NixPath>(which: QuotaType, special: Option<&P>) -> Result<()> {
-    quotactl(QuotaCmd(QuotaSubCmd::Q_SYNC, which), special, 0, ptr::null_mut())
+pub fn quotactl_sync<P: ?Sized + NixPath>(
+    which: QuotaType,
+    special: Option<&P>,
+) -> Result<()> {
+    quotactl(
+        QuotaCmd(QuotaSubCmd::Q_SYNC, which),
+        special,
+        0,
+        ptr::null_mut(),
+    )
 }
 
 /// Get disk quota limits and current usage for the given user/group id.
-pub fn quotactl_get<P: ?Sized + NixPath>(which: QuotaType, special: &P, id: c_int) -> Result<Dqblk> {
+pub fn quotactl_get<P: ?Sized + NixPath>(
+    which: QuotaType,
+    special: &P,
+    id: c_int,
+) -> Result<Dqblk> {
     let mut dqblk = mem::MaybeUninit::uninit();
-    quotactl(QuotaCmd(QuotaSubCmd::Q_GETQUOTA, which), Some(special), id, dqblk.as_mut_ptr() as *mut c_char)?;
-    Ok(unsafe{ Dqblk(dqblk.assume_init())})
+    quotactl(
+        QuotaCmd(QuotaSubCmd::Q_GETQUOTA, which),
+        Some(special),
+        id,
+        dqblk.as_mut_ptr() as *mut c_char,
+    )?;
+    Ok(unsafe { Dqblk(dqblk.assume_init()) })
 }
 
 /// Configure quota values for the specified fields for a given user/group id.
-pub fn quotactl_set<P: ?Sized + NixPath>(which: QuotaType, special: &P, id: c_int, dqblk: &Dqblk, fields: QuotaValidFlags) -> Result<()> {
+pub fn quotactl_set<P: ?Sized + NixPath>(
+    which: QuotaType,
+    special: &P,
+    id: c_int,
+    dqblk: &Dqblk,
+    fields: QuotaValidFlags,
+) -> Result<()> {
     let mut dqblk_copy = *dqblk;
     dqblk_copy.0.dqb_valid = fields.bits();
-    quotactl(QuotaCmd(QuotaSubCmd::Q_SETQUOTA, which), Some(special), id, &mut dqblk_copy as *mut _ as *mut c_char)
+    quotactl(
+        QuotaCmd(QuotaSubCmd::Q_SETQUOTA, which),
+        Some(special),
+        id,
+        &mut dqblk_copy as *mut _ as *mut c_char,
+    )
 }
diff --git a/src/sys/reboot.rs b/src/sys/reboot.rs
index 46ab68b..02d9816 100644
--- a/src/sys/reboot.rs
+++ b/src/sys/reboot.rs
@@ -1,7 +1,7 @@
 //! Reboot/shutdown or enable/disable Ctrl-Alt-Delete.
 
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 use std::convert::Infallible;
 use std::mem::drop;
 
@@ -13,19 +13,24 @@ libc_enum! {
     #[repr(i32)]
     #[non_exhaustive]
     pub enum RebootMode {
+        /// Halt the system.
         RB_HALT_SYSTEM,
+        /// Execute a kernel that has been loaded earlier with
+        /// [`kexec_load(2)`](https://man7.org/linux/man-pages/man2/kexec_load.2.html).
         RB_KEXEC,
+        /// Stop the system and switch off power, if possible.
         RB_POWER_OFF,
+        /// Restart the system.
         RB_AUTOBOOT,
-        // we do not support Restart2,
+        // we do not support Restart2.
+        /// Suspend the system using software suspend.
         RB_SW_SUSPEND,
     }
 }
 
+/// Reboots or shuts down the system.
 pub fn reboot(how: RebootMode) -> Result<Infallible> {
-    unsafe {
-        libc::reboot(how as libc::c_int)
-    };
+    unsafe { libc::reboot(how as libc::c_int) };
     Err(Errno::last())
 }
 
@@ -38,8 +43,6 @@ pub fn set_cad_enabled(enable: bool) -> Result<()> {
     } else {
         libc::RB_DISABLE_CAD
     };
-    let res = unsafe {
-        libc::reboot(cmd)
-    };
+    let res = unsafe { libc::reboot(cmd) };
     Errno::result(res).map(drop)
 }
diff --git a/src/sys/resource.rs b/src/sys/resource.rs
index f3bfb67..8927737 100644
--- a/src/sys/resource.rs
+++ b/src/sys/resource.rs
@@ -1,15 +1,18 @@
 //! Configure the process resource limits.
 use cfg_if::cfg_if;
+use libc::{c_int, c_long, rusage};
 
 use crate::errno::Errno;
+use crate::sys::time::TimeVal;
 use crate::Result;
 pub use libc::rlim_t;
+pub use libc::RLIM_INFINITY;
 use std::mem;
 
 cfg_if! {
-    if #[cfg(all(target_os = "linux", target_env = "gnu"))]{
-        use libc::{__rlimit_resource_t, rlimit, RLIM_INFINITY};
-    }else if #[cfg(any(
+    if #[cfg(all(target_os = "linux", any(target_env = "gnu", target_env = "uclibc")))]{
+        use libc::{__rlimit_resource_t, rlimit};
+    } else if #[cfg(any(
         target_os = "freebsd",
         target_os = "openbsd",
         target_os = "netbsd",
@@ -19,24 +22,27 @@ cfg_if! {
         target_os = "dragonfly",
         all(target_os = "linux", not(target_env = "gnu"))
     ))]{
-        use libc::{c_int, rlimit, RLIM_INFINITY};
+        use libc::rlimit;
     }
 }
 
 libc_enum! {
+    /// Types of process resources.
+    ///
     /// The Resource enum is platform dependent. Check different platform
-    /// manuals for more details. Some platform links has been provided for
-    /// earier reference (non-exhaustive).
+    /// manuals for more details. Some platform links have been provided for
+    /// easier reference (non-exhaustive).
     ///
     /// * [Linux](https://man7.org/linux/man-pages/man2/getrlimit.2.html)
     /// * [FreeBSD](https://www.freebsd.org/cgi/man.cgi?query=setrlimit)
+    /// * [NetBSD](https://man.netbsd.org/setrlimit.2)
 
     // linux-gnu uses u_int as resource enum, which is implemented in libc as
     // well.
     //
     // https://gcc.gnu.org/legacy-ml/gcc/2015-08/msg00441.html
     // https://github.com/rust-lang/libc/blob/master/src/unix/linux_like/linux/gnu/mod.rs
-    #[cfg_attr(all(target_os = "linux", target_env = "gnu"), repr(u32))]
+    #[cfg_attr(all(target_os = "linux", any(target_env = "gnu", target_env = "uclibc")), repr(u32))]
     #[cfg_attr(any(
             target_os = "freebsd",
             target_os = "openbsd",
@@ -45,15 +51,12 @@ libc_enum! {
             target_os = "ios",
             target_os = "android",
             target_os = "dragonfly",
-            all(target_os = "linux", not(target_env = "gnu"))
+            all(target_os = "linux", not(any(target_env = "gnu", target_env = "uclibc")))
         ), repr(i32))]
     #[non_exhaustive]
     pub enum Resource {
-        #[cfg(not(any(
-                    target_os = "freebsd",
-                    target_os = "netbsd",
-                    target_os = "openbsd"
-        )))]
+        #[cfg(not(any(target_os = "freebsd", target_os = "netbsd", target_os = "openbsd")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum amount (in bytes) of virtual memory the process is
         /// allowed to map.
         RLIMIT_AS,
@@ -72,69 +75,100 @@ libc_enum! {
         RLIMIT_STACK,
 
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum number of kqueues this user id is allowed to create.
         RLIMIT_KQUEUES,
 
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A limit on the combined number of flock locks and fcntl leases that
         /// this process may establish.
         RLIMIT_LOCKS,
 
-        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "openbsd", target_os = "linux"))]
+        #[cfg(any(
+            target_os = "android",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "linux",
+            target_os = "netbsd"
+        ))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum size (in bytes) which a process may lock into memory
         /// using the mlock(2) system call.
         RLIMIT_MEMLOCK,
 
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A limit on the number of bytes that can be allocated for POSIX
         /// message queues  for  the  real  user  ID  of  the  calling process.
         RLIMIT_MSGQUEUE,
 
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A ceiling to which the process's nice value can be raised using
         /// setpriority or nice.
         RLIMIT_NICE,
 
-        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "openbsd", target_os = "linux"))]
+        #[cfg(any(
+            target_os = "android",
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "linux",
+        ))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum number of simultaneous processes for this user id.
         RLIMIT_NPROC,
 
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum number of pseudo-terminals this user id is allowed to
         /// create.
         RLIMIT_NPTS,
 
-        #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "openbsd", target_os = "linux"))]
+        #[cfg(any(target_os = "android",
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "linux",
+        ))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// When there is memory pressure and swap is available, prioritize
         /// eviction of a process' resident pages beyond this amount (in bytes).
         RLIMIT_RSS,
 
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A ceiling on the real-time priority that may be set for this process
         /// using sched_setscheduler and  sched_set‐ param.
         RLIMIT_RTPRIO,
 
         #[cfg(any(target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A limit (in microseconds) on the amount of CPU time that a process
         /// scheduled under a real-time scheduling policy may con‐ sume without
         /// making a blocking system call.
         RLIMIT_RTTIME,
 
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// A limit on the number of signals that may be queued for the real
         /// user ID of the  calling  process.
         RLIMIT_SIGPENDING,
 
         #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum size (in bytes) of socket buffer usage for this user.
         RLIMIT_SBSIZE,
 
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// The maximum size (in bytes) of the swap space that may be reserved
         /// or used by all of this user id's processes.
         RLIMIT_SWAP,
 
         #[cfg(target_os = "freebsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// An alias for RLIMIT_AS.
         RLIMIT_VMEM,
     }
@@ -142,8 +176,8 @@ libc_enum! {
 
 /// Get the current processes resource limits
 ///
-/// A value of `None` indicates the value equals to `RLIM_INFINITY` which means
-/// there is no limit.
+/// The special value [`RLIM_INFINITY`] indicates that no limit will be
+/// enforced.
 ///
 /// # Parameters
 ///
@@ -155,8 +189,8 @@ libc_enum! {
 /// # use nix::sys::resource::{getrlimit, Resource};
 ///
 /// let (soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
-/// println!("current soft_limit: {:?}", soft_limit);
-/// println!("current hard_limit: {:?}", hard_limit);
+/// println!("current soft_limit: {}", soft_limit);
+/// println!("current hard_limit: {}", hard_limit);
 /// ```
 ///
 /// # References
@@ -164,20 +198,20 @@ libc_enum! {
 /// [getrlimit(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrlimit.html#tag_16_215)
 ///
 /// [`Resource`]: enum.Resource.html
-pub fn getrlimit(resource: Resource) -> Result<(Option<rlim_t>, Option<rlim_t>)> {
+pub fn getrlimit(resource: Resource) -> Result<(rlim_t, rlim_t)> {
     let mut old_rlim = mem::MaybeUninit::<rlimit>::uninit();
 
     cfg_if! {
-        if #[cfg(all(target_os = "linux", target_env = "gnu"))]{
+        if #[cfg(all(target_os = "linux", any(target_env = "gnu", target_env = "uclibc")))]{
             let res = unsafe { libc::getrlimit(resource as __rlimit_resource_t, old_rlim.as_mut_ptr()) };
-        }else{
+        } else {
             let res = unsafe { libc::getrlimit(resource as c_int, old_rlim.as_mut_ptr()) };
         }
     }
 
     Errno::result(res).map(|_| {
         let rlimit { rlim_cur, rlim_max } = unsafe { old_rlim.assume_init() };
-        (Some(rlim_cur), Some(rlim_max))
+        (rlim_cur, rlim_max)
     })
 }
 
@@ -187,21 +221,20 @@ pub fn getrlimit(resource: Resource) -> Result<(Option<rlim_t>, Option<rlim_t>)>
 ///
 /// * `resource`: The [`Resource`] that we want to set the limits of.
 /// * `soft_limit`: The value that the kernel enforces for the corresponding
-///   resource. Note: `None` input will be replaced by constant `RLIM_INFINITY`.
+///   resource.
 /// * `hard_limit`: The ceiling for the soft limit. Must be lower or equal to
-///   the current hard limit for non-root users. Note: `None` input will be
-///   replaced by constant `RLIM_INFINITY`.
+///   the current hard limit for non-root users.
 ///
-/// > Note: for some os (linux_gnu), setting hard_limit to `RLIM_INFINITY` can
-/// > results `EPERM` Error. So you will need to set the number explicitly.
+/// The special value [`RLIM_INFINITY`] indicates that no limit will be
+/// enforced.
 ///
 /// # Examples
 ///
 /// ```
 /// # use nix::sys::resource::{setrlimit, Resource};
 ///
-/// let soft_limit = Some(512);
-/// let hard_limit = Some(1024);
+/// let soft_limit = 512;
+/// let hard_limit = 1024;
 /// setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
 /// ```
 ///
@@ -214,15 +247,15 @@ pub fn getrlimit(resource: Resource) -> Result<(Option<rlim_t>, Option<rlim_t>)>
 /// Note: `setrlimit` provides a safe wrapper to libc's `setrlimit`.
 pub fn setrlimit(
     resource: Resource,
-    soft_limit: Option<rlim_t>,
-    hard_limit: Option<rlim_t>,
+    soft_limit: rlim_t,
+    hard_limit: rlim_t,
 ) -> Result<()> {
     let new_rlim = rlimit {
-        rlim_cur: soft_limit.unwrap_or(RLIM_INFINITY),
-        rlim_max: hard_limit.unwrap_or(RLIM_INFINITY),
+        rlim_cur: soft_limit,
+        rlim_max: hard_limit,
     };
     cfg_if! {
-        if #[cfg(all(target_os = "linux", target_env = "gnu"))]{
+        if #[cfg(all(target_os = "linux", any(target_env = "gnu", target_env = "uclibc")))]{
             let res = unsafe { libc::setrlimit(resource as __rlimit_resource_t, &new_rlim as *const rlimit) };
         }else{
             let res = unsafe { libc::setrlimit(resource as c_int, &new_rlim as *const rlimit) };
@@ -231,3 +264,180 @@ pub fn setrlimit(
 
     Errno::result(res).map(drop)
 }
+
+libc_enum! {
+    /// Whose resource usage should be returned by [`getrusage`].
+    #[repr(i32)]
+    #[non_exhaustive]
+    pub enum UsageWho {
+        /// Resource usage for the current process.
+        RUSAGE_SELF,
+
+        /// Resource usage for all the children that have terminated and been waited for.
+        RUSAGE_CHILDREN,
+
+        #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        /// Resource usage for the calling thread.
+        RUSAGE_THREAD,
+    }
+}
+
+/// Output of `getrusage` with information about resource usage. Some of the fields
+/// may be unused in some platforms, and will be always zeroed out. See their manuals
+/// for details.
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct Usage(rusage);
+
+impl AsRef<rusage> for Usage {
+    fn as_ref(&self) -> &rusage {
+        &self.0
+    }
+}
+
+impl AsMut<rusage> for Usage {
+    fn as_mut(&mut self) -> &mut rusage {
+        &mut self.0
+    }
+}
+
+impl Usage {
+    /// Total amount of time spent executing in user mode.
+    pub fn user_time(&self) -> TimeVal {
+        TimeVal::from(self.0.ru_utime)
+    }
+
+    /// Total amount of time spent executing in kernel mode.
+    pub fn system_time(&self) -> TimeVal {
+        TimeVal::from(self.0.ru_stime)
+    }
+
+    /// The resident set size at its peak, in kilobytes.
+    pub fn max_rss(&self) -> c_long {
+        self.0.ru_maxrss
+    }
+
+    /// Integral value expressed in kilobytes times ticks of execution indicating
+    /// the amount of text memory shared with other processes.
+    pub fn shared_integral(&self) -> c_long {
+        self.0.ru_ixrss
+    }
+
+    /// Integral value expressed in kilobytes times ticks of execution indicating
+    /// the amount of unshared memory used by data.
+    pub fn unshared_data_integral(&self) -> c_long {
+        self.0.ru_idrss
+    }
+
+    /// Integral value expressed in kilobytes times ticks of execution indicating
+    /// the amount of unshared memory used for stack space.
+    pub fn unshared_stack_integral(&self) -> c_long {
+        self.0.ru_isrss
+    }
+
+    /// Number of page faults that were served without resorting to I/O, with pages
+    /// that have been allocated previously by the kernel.
+    pub fn minor_page_faults(&self) -> c_long {
+        self.0.ru_minflt
+    }
+
+    /// Number of page faults that were served through I/O (i.e. swap).
+    pub fn major_page_faults(&self) -> c_long {
+        self.0.ru_majflt
+    }
+
+    /// Number of times all of the memory was fully swapped out.
+    pub fn full_swaps(&self) -> c_long {
+        self.0.ru_nswap
+    }
+
+    /// Number of times a read was done from a block device.
+    pub fn block_reads(&self) -> c_long {
+        self.0.ru_inblock
+    }
+
+    /// Number of times a write was done to a block device.
+    pub fn block_writes(&self) -> c_long {
+        self.0.ru_oublock
+    }
+
+    /// Number of IPC messages sent.
+    pub fn ipc_sends(&self) -> c_long {
+        self.0.ru_msgsnd
+    }
+
+    /// Number of IPC messages received.
+    pub fn ipc_receives(&self) -> c_long {
+        self.0.ru_msgrcv
+    }
+
+    /// Number of signals received.
+    pub fn signals(&self) -> c_long {
+        self.0.ru_nsignals
+    }
+
+    /// Number of times a context switch was voluntarily invoked.
+    pub fn voluntary_context_switches(&self) -> c_long {
+        self.0.ru_nvcsw
+    }
+
+    /// Number of times a context switch was imposed by the kernel (usually due to
+    /// time slice expiring or preemption by a higher priority process).
+    pub fn involuntary_context_switches(&self) -> c_long {
+        self.0.ru_nivcsw
+    }
+}
+
+/// Get usage information for a process, its children or the current thread
+///
+/// Real time information can be obtained for either the current process or (in some
+/// systems) thread, but information about children processes is only provided for
+/// those that have terminated and been waited for (see [`super::wait::wait`]).
+///
+/// Some information may be missing depending on the platform, and the way information
+/// is provided for children may also vary. Check the manuals for details.
+///
+/// # References
+///
+/// * [getrusage(2)](https://pubs.opengroup.org/onlinepubs/009696699/functions/getrusage.html)
+/// * [Linux](https://man7.org/linux/man-pages/man2/getrusage.2.html)
+/// * [FreeBSD](https://www.freebsd.org/cgi/man.cgi?query=getrusage)
+/// * [NetBSD](https://man.netbsd.org/getrusage.2)
+/// * [MacOS](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/getrusage.2.html)
+///
+/// [`UsageWho`]: enum.UsageWho.html
+///
+/// Note: `getrusage` provides a safe wrapper to libc's [`libc::getrusage`].
+pub fn getrusage(who: UsageWho) -> Result<Usage> {
+    unsafe {
+        let mut rusage = mem::MaybeUninit::<rusage>::uninit();
+        let res = libc::getrusage(who as c_int, rusage.as_mut_ptr());
+        Errno::result(res).map(|_| Usage(rusage.assume_init()))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{getrusage, UsageWho};
+
+    #[test]
+    pub fn test_self_cpu_time() {
+        // Make sure some CPU time is used.
+        let mut numbers: Vec<i32> = (1..1_000_000).collect();
+        numbers.iter_mut().for_each(|item| *item *= 2);
+
+        // FIXME: this is here to help ensure the compiler does not optimize the whole
+        // thing away. Replace the assert with test::black_box once stabilized.
+        assert_eq!(numbers[100..200].iter().sum::<i32>(), 30_100);
+
+        let usage = getrusage(UsageWho::RUSAGE_SELF)
+            .expect("Failed to call getrusage for SELF");
+        let rusage = usage.as_ref();
+
+        let user = usage.user_time();
+        assert!(user.tv_sec() > 0 || user.tv_usec() > 0);
+        assert_eq!(user.tv_sec(), rusage.ru_utime.tv_sec);
+        assert_eq!(user.tv_usec(), rusage.ru_utime.tv_usec);
+    }
+}
diff --git a/src/sys/select.rs b/src/sys/select.rs
index 4d7576a..7a94cff 100644
--- a/src/sys/select.rs
+++ b/src/sys/select.rs
@@ -1,15 +1,14 @@
 //! Portably monitor a group of file descriptors for readiness.
+use crate::errno::Errno;
+use crate::sys::time::{TimeSpec, TimeVal};
+use crate::Result;
+use libc::{self, c_int};
 use std::convert::TryFrom;
 use std::iter::FusedIterator;
 use std::mem;
 use std::ops::Range;
 use std::os::unix::io::RawFd;
 use std::ptr::{null, null_mut};
-use libc::{self, c_int};
-use crate::Result;
-use crate::errno::Errno;
-use crate::sys::signal::SigSet;
-use crate::sys::time::{TimeSpec, TimeVal};
 
 pub use libc::FD_SETSIZE;
 
@@ -174,11 +173,13 @@ impl<'a> FusedIterator for Fds<'a> {}
 /// [select(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/select.html)
 ///
 /// [`FdSet::highest`]: struct.FdSet.html#method.highest
-pub fn select<'a, N, R, W, E, T>(nfds: N,
+pub fn select<'a, N, R, W, E, T>(
+    nfds: N,
     readfds: R,
     writefds: W,
     errorfds: E,
-                                 timeout: T) -> Result<c_int>
+    timeout: T,
+) -> Result<c_int>
 where
     N: Into<Option<c_int>>,
     R: Into<Option<&'a mut FdSet>>,
@@ -192,27 +193,40 @@ where
     let timeout = timeout.into();
 
     let nfds = nfds.into().unwrap_or_else(|| {
-        readfds.iter_mut()
+        readfds
+            .iter_mut()
             .chain(writefds.iter_mut())
             .chain(errorfds.iter_mut())
             .map(|set| set.highest().unwrap_or(-1))
             .max()
-            .unwrap_or(-1) + 1
+            .unwrap_or(-1)
+            + 1
     });
 
-    let readfds = readfds.map(|set| set as *mut _ as *mut libc::fd_set).unwrap_or(null_mut());
-    let writefds = writefds.map(|set| set as *mut _ as *mut libc::fd_set).unwrap_or(null_mut());
-    let errorfds = errorfds.map(|set| set as *mut _ as *mut libc::fd_set).unwrap_or(null_mut());
-    let timeout = timeout.map(|tv| tv as *mut _ as *mut libc::timeval)
+    let readfds = readfds
+        .map(|set| set as *mut _ as *mut libc::fd_set)
+        .unwrap_or(null_mut());
+    let writefds = writefds
+        .map(|set| set as *mut _ as *mut libc::fd_set)
+        .unwrap_or(null_mut());
+    let errorfds = errorfds
+        .map(|set| set as *mut _ as *mut libc::fd_set)
+        .unwrap_or(null_mut());
+    let timeout = timeout
+        .map(|tv| tv as *mut _ as *mut libc::timeval)
         .unwrap_or(null_mut());
 
-    let res = unsafe {
-        libc::select(nfds, readfds, writefds, errorfds, timeout)
-    };
+    let res =
+        unsafe { libc::select(nfds, readfds, writefds, errorfds, timeout) };
 
     Errno::result(res)
 }
 
+feature! {
+#![feature = "signal"]
+
+use crate::sys::signal::SigSet;
+
 /// Monitors file descriptors for readiness with an altered signal mask.
 ///
 /// Returns the total number of ready file descriptors in all sets. The sets are changed so that all
@@ -283,14 +297,14 @@ where
 
     Errno::result(res)
 }
-
+}
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::os::unix::io::RawFd;
     use crate::sys::time::{TimeVal, TimeValLike};
-    use crate::unistd::{write, pipe};
+    use crate::unistd::{pipe, write};
+    use std::os::unix::io::RawFd;
 
     #[test]
     fn fdset_insert() {
@@ -379,11 +393,10 @@ mod tests {
         fd_set.insert(r2);
 
         let mut timeout = TimeVal::seconds(10);
-        assert_eq!(1, select(None,
-                             &mut fd_set,
-                             None,
-                             None,
-                             &mut timeout).unwrap());
+        assert_eq!(
+            1,
+            select(None, &mut fd_set, None, None, &mut timeout).unwrap()
+        );
         assert!(fd_set.contains(r1));
         assert!(!fd_set.contains(r2));
     }
@@ -399,11 +412,17 @@ mod tests {
         fd_set.insert(r2);
 
         let mut timeout = TimeVal::seconds(10);
-        assert_eq!(1, select(Some(fd_set.highest().unwrap() + 1),
+        assert_eq!(
+            1,
+            select(
+                Some(fd_set.highest().unwrap() + 1),
                 &mut fd_set,
                 None,
                 None,
-                             &mut timeout).unwrap());
+                &mut timeout
+            )
+            .unwrap()
+        );
         assert!(fd_set.contains(r1));
         assert!(!fd_set.contains(r2));
     }
@@ -419,11 +438,17 @@ mod tests {
         fd_set.insert(r2);
 
         let mut timeout = TimeVal::seconds(10);
-        assert_eq!(1, select(::std::cmp::max(r1, r2) + 1,
+        assert_eq!(
+            1,
+            select(
+                ::std::cmp::max(r1, r2) + 1,
                 &mut fd_set,
                 None,
                 None,
-                             &mut timeout).unwrap());
+                &mut timeout
+            )
+            .unwrap()
+        );
         assert!(fd_set.contains(r1));
         assert!(!fd_set.contains(r2));
     }
diff --git a/src/sys/sendfile.rs b/src/sys/sendfile.rs
index 7a210c6..fb293a4 100644
--- a/src/sys/sendfile.rs
+++ b/src/sys/sendfile.rs
@@ -6,8 +6,8 @@ use std::ptr;
 
 use libc::{self, off_t};
 
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 
 /// Copy up to `count` bytes to `out_fd` from `in_fd` starting at `offset`.
 ///
@@ -22,6 +22,7 @@ use crate::errno::Errno;
 ///
 /// For more information, see [the sendfile(2) man page.](https://man7.org/linux/man-pages/man2/sendfile.2.html)
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn sendfile(
     out_fd: RawFd,
     in_fd: RawFd,
@@ -48,6 +49,7 @@ pub fn sendfile(
 ///
 /// For more information, see [the sendfile(2) man page.](https://man7.org/linux/man-pages/man2/sendfile.2.html)
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn sendfile64(
     out_fd: RawFd,
     in_fd: RawFd,
@@ -62,16 +64,17 @@ pub fn sendfile64(
 }
 
 cfg_if! {
-    if #[cfg(any(target_os = "freebsd",
+    if #[cfg(any(target_os = "dragonfly",
+                 target_os = "freebsd",
                  target_os = "ios",
                  target_os = "macos"))] {
-        use crate::sys::uio::IoVec;
+        use std::io::IoSlice;
 
-        #[derive(Clone, Debug, Eq, Hash, PartialEq)]
+        #[derive(Clone, Debug)]
         struct SendfileHeaderTrailer<'a>(
             libc::sf_hdtr,
-            Option<Vec<IoVec<&'a [u8]>>>,
-            Option<Vec<IoVec<&'a [u8]>>>,
+            Option<Vec<IoSlice<'a>>>,
+            Option<Vec<IoSlice<'a>>>,
         );
 
         impl<'a> SendfileHeaderTrailer<'a> {
@@ -79,10 +82,10 @@ cfg_if! {
                 headers: Option<&'a [&'a [u8]]>,
                 trailers: Option<&'a [&'a [u8]]>
             ) -> SendfileHeaderTrailer<'a> {
-                let header_iovecs: Option<Vec<IoVec<&[u8]>>> =
-                    headers.map(|s| s.iter().map(|b| IoVec::from_slice(b)).collect());
-                let trailer_iovecs: Option<Vec<IoVec<&[u8]>>> =
-                    trailers.map(|s| s.iter().map(|b| IoVec::from_slice(b)).collect());
+                let header_iovecs: Option<Vec<IoSlice<'_>>> =
+                    headers.map(|s| s.iter().map(|b| IoSlice::new(b)).collect());
+                let trailer_iovecs: Option<Vec<IoSlice<'_>>> =
+                    trailers.map(|s| s.iter().map(|b| IoSlice::new(b)).collect());
                 SendfileHeaderTrailer(
                     libc::sf_hdtr {
                         headers: {
@@ -182,6 +185,49 @@ cfg_if! {
             };
             (Errno::result(return_code).and(Ok(())), bytes_sent)
         }
+    } else if #[cfg(target_os = "dragonfly")] {
+        /// Read up to `count` bytes from `in_fd` starting at `offset` and write to `out_sock`.
+        ///
+        /// Returns a `Result` and a count of bytes written. Bytes written may be non-zero even if
+        /// an error occurs.
+        ///
+        /// `in_fd` must describe a regular file. `out_sock` must describe a stream socket.
+        ///
+        /// If `offset` falls past the end of the file, the function returns success and zero bytes
+        /// written.
+        ///
+        /// If `count` is `None` or 0, bytes will be read from `in_fd` until reaching the end of
+        /// file (EOF).
+        ///
+        /// `headers` and `trailers` specify optional slices of byte slices to be sent before and
+        /// after the data read from `in_fd`, respectively. The length of headers and trailers sent
+        /// is included in the returned count of bytes written. The values of `offset` and `count`
+        /// do not apply to headers or trailers.
+        ///
+        /// For more information, see
+        /// [the sendfile(2) man page.](https://leaf.dragonflybsd.org/cgi/web-man?command=sendfile&section=2)
+        pub fn sendfile(
+            in_fd: RawFd,
+            out_sock: RawFd,
+            offset: off_t,
+            count: Option<usize>,
+            headers: Option<&[&[u8]]>,
+            trailers: Option<&[&[u8]]>,
+        ) -> (Result<()>, off_t) {
+            let mut bytes_sent: off_t = 0;
+            let hdtr = headers.or(trailers).map(|_| SendfileHeaderTrailer::new(headers, trailers));
+            let hdtr_ptr = hdtr.as_ref().map_or(ptr::null(), |s| &s.0 as *const libc::sf_hdtr);
+            let return_code = unsafe {
+                libc::sendfile(in_fd,
+                               out_sock,
+                               offset,
+                               count.unwrap_or(0),
+                               hdtr_ptr as *mut libc::sf_hdtr,
+                               &mut bytes_sent as *mut off_t,
+                               0)
+            };
+            (Errno::result(return_code).and(Ok(())), bytes_sent)
+        }
     } else if #[cfg(any(target_os = "ios", target_os = "macos"))] {
         /// Read bytes from `in_fd` starting at `offset` and write up to `count` bytes to
         /// `out_sock`.
diff --git a/src/sys/signal.rs b/src/sys/signal.rs
index 61bdc74..d3746e6 100644
--- a/src/sys/signal.rs
+++ b/src/sys/signal.rs
@@ -3,20 +3,22 @@
 
 //! Operating system signals.
 
-use crate::{Error, Result};
 use crate::errno::Errno;
-use crate::unistd::Pid;
-use std::mem;
+use crate::{Error, Result};
+use cfg_if::cfg_if;
 use std::fmt;
-use std::str::FromStr;
+use std::mem;
 #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
 use std::os::unix::io::RawFd;
 use std::ptr;
+use std::str::FromStr;
 
 #[cfg(not(any(target_os = "openbsd", target_os = "redox")))]
+#[cfg(any(feature = "aio", feature = "signal"))]
 pub use self::sigevent::*;
 
-libc_enum!{
+#[cfg(any(feature = "aio", feature = "process", feature = "signal"))]
+libc_enum! {
     /// Types of operating system signals
     // Currently there is only one definition of c_int in libc, as well as only one
     // type for signal constants.
@@ -24,6 +26,7 @@ libc_enum!{
     // this is not (yet) possible.
     #[repr(i32)]
     #[non_exhaustive]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "aio", feature = "signal"))))]
     pub enum Signal {
         /// Hangup
         SIGHUP,
@@ -86,27 +89,33 @@ libc_enum!{
         /// Window size changes
         SIGWINCH,
         /// Input/output possible signal
+        #[cfg(not(target_os = "haiku"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         SIGIO,
         #[cfg(any(target_os = "android", target_os = "emscripten",
                   target_os = "fuchsia", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// Power failure imminent.
         SIGPWR,
         /// Bad system call
         SIGSYS,
         #[cfg(not(any(target_os = "android", target_os = "emscripten",
                       target_os = "fuchsia", target_os = "linux",
-                      target_os = "redox")))]
+                      target_os = "redox", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// Emulator trap
         SIGEMT,
         #[cfg(not(any(target_os = "android", target_os = "emscripten",
                       target_os = "fuchsia", target_os = "linux",
-                      target_os = "redox")))]
+                      target_os = "redox", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         /// Information request
         SIGINFO,
     }
     impl TryFrom<i32>
 }
 
+#[cfg(feature = "signal")]
 impl FromStr for Signal {
     type Err = Error;
     fn from_str(s: &str) -> Result<Signal> {
@@ -126,10 +135,19 @@ impl FromStr for Signal {
             "SIGPIPE" => Signal::SIGPIPE,
             "SIGALRM" => Signal::SIGALRM,
             "SIGTERM" => Signal::SIGTERM,
-            #[cfg(all(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux"),
-                      not(any(target_arch = "mips", target_arch = "mips64",
-                              target_arch = "sparc64"))))]
+            #[cfg(all(
+                any(
+                    target_os = "android",
+                    target_os = "emscripten",
+                    target_os = "fuchsia",
+                    target_os = "linux"
+                ),
+                not(any(
+                    target_arch = "mips",
+                    target_arch = "mips64",
+                    target_arch = "sparc64"
+                ))
+            ))]
             "SIGSTKFLT" => Signal::SIGSTKFLT,
             "SIGCHLD" => Signal::SIGCHLD,
             "SIGCONT" => Signal::SIGCONT,
@@ -143,24 +161,40 @@ impl FromStr for Signal {
             "SIGVTALRM" => Signal::SIGVTALRM,
             "SIGPROF" => Signal::SIGPROF,
             "SIGWINCH" => Signal::SIGWINCH,
+            #[cfg(not(target_os = "haiku"))]
             "SIGIO" => Signal::SIGIO,
-            #[cfg(any(target_os = "android", target_os = "emscripten",
-                      target_os = "fuchsia", target_os = "linux"))]
+            #[cfg(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux"
+            ))]
             "SIGPWR" => Signal::SIGPWR,
             "SIGSYS" => Signal::SIGSYS,
-            #[cfg(not(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux",
-                          target_os = "redox")))]
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux",
+                target_os = "redox",
+                target_os = "haiku"
+            )))]
             "SIGEMT" => Signal::SIGEMT,
-            #[cfg(not(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux",
-                          target_os = "redox")))]
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux",
+                target_os = "redox",
+                target_os = "haiku"
+            )))]
             "SIGINFO" => Signal::SIGINFO,
             _ => return Err(Errno::EINVAL),
         })
     }
 }
 
+#[cfg(feature = "signal")]
 impl Signal {
     /// Returns name of signal.
     ///
@@ -184,9 +218,19 @@ impl Signal {
             Signal::SIGPIPE => "SIGPIPE",
             Signal::SIGALRM => "SIGALRM",
             Signal::SIGTERM => "SIGTERM",
-            #[cfg(all(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux"),
-                      not(any(target_arch = "mips", target_arch = "mips64", target_arch = "sparc64"))))]
+            #[cfg(all(
+                any(
+                    target_os = "android",
+                    target_os = "emscripten",
+                    target_os = "fuchsia",
+                    target_os = "linux"
+                ),
+                not(any(
+                    target_arch = "mips",
+                    target_arch = "mips64",
+                    target_arch = "sparc64"
+                ))
+            ))]
             Signal::SIGSTKFLT => "SIGSTKFLT",
             Signal::SIGCHLD => "SIGCHLD",
             Signal::SIGCONT => "SIGCONT",
@@ -200,174 +244,125 @@ impl Signal {
             Signal::SIGVTALRM => "SIGVTALRM",
             Signal::SIGPROF => "SIGPROF",
             Signal::SIGWINCH => "SIGWINCH",
+            #[cfg(not(target_os = "haiku"))]
             Signal::SIGIO => "SIGIO",
-            #[cfg(any(target_os = "android", target_os = "emscripten",
-                      target_os = "fuchsia", target_os = "linux"))]
+            #[cfg(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux"
+            ))]
             Signal::SIGPWR => "SIGPWR",
             Signal::SIGSYS => "SIGSYS",
-            #[cfg(not(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux",
-                          target_os = "redox")))]
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux",
+                target_os = "redox",
+                target_os = "haiku"
+            )))]
             Signal::SIGEMT => "SIGEMT",
-            #[cfg(not(any(target_os = "android", target_os = "emscripten",
-                          target_os = "fuchsia", target_os = "linux",
-                          target_os = "redox")))]
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "emscripten",
+                target_os = "fuchsia",
+                target_os = "linux",
+                target_os = "redox",
+                target_os = "haiku"
+            )))]
             Signal::SIGINFO => "SIGINFO",
         }
     }
 }
 
+#[cfg(feature = "signal")]
 impl AsRef<str> for Signal {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
+#[cfg(feature = "signal")]
 impl fmt::Display for Signal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(self.as_ref())
     }
 }
 
+#[cfg(feature = "signal")]
 pub use self::Signal::*;
 
 #[cfg(target_os = "redox")]
+#[cfg(feature = "signal")]
 const SIGNALS: [Signal; 29] = [
-    SIGHUP,
-    SIGINT,
-    SIGQUIT,
-    SIGILL,
-    SIGTRAP,
-    SIGABRT,
-    SIGBUS,
-    SIGFPE,
-    SIGKILL,
-    SIGUSR1,
-    SIGSEGV,
-    SIGUSR2,
-    SIGPIPE,
-    SIGALRM,
-    SIGTERM,
-    SIGCHLD,
-    SIGCONT,
-    SIGSTOP,
-    SIGTSTP,
-    SIGTTIN,
-    SIGTTOU,
-    SIGURG,
-    SIGXCPU,
-    SIGXFSZ,
-    SIGVTALRM,
-    SIGPROF,
-    SIGWINCH,
-    SIGIO,
-    SIGSYS];
-#[cfg(all(any(target_os = "linux", target_os = "android",
-              target_os = "emscripten", target_os = "fuchsia"),
-          not(any(target_arch = "mips", target_arch = "mips64",
-                  target_arch = "sparc64"))))]
+    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGKILL,
+    SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGCONT,
+    SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM,
+    SIGPROF, SIGWINCH, SIGIO, SIGSYS,
+];
+#[cfg(target_os = "haiku")]
+#[cfg(feature = "signal")]
+const SIGNALS: [Signal; 28] = [
+    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGKILL,
+    SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGCONT,
+    SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM,
+    SIGPROF, SIGWINCH, SIGSYS,
+];
+#[cfg(all(
+    any(
+        target_os = "linux",
+        target_os = "android",
+        target_os = "emscripten",
+        target_os = "fuchsia"
+    ),
+    not(any(
+        target_arch = "mips",
+        target_arch = "mips64",
+        target_arch = "sparc64"
+    ))
+))]
+#[cfg(feature = "signal")]
 const SIGNALS: [Signal; 31] = [
-    SIGHUP,
-    SIGINT,
-    SIGQUIT,
-    SIGILL,
-    SIGTRAP,
-    SIGABRT,
-    SIGBUS,
-    SIGFPE,
-    SIGKILL,
-    SIGUSR1,
-    SIGSEGV,
-    SIGUSR2,
-    SIGPIPE,
-    SIGALRM,
-    SIGTERM,
-    SIGSTKFLT,
-    SIGCHLD,
-    SIGCONT,
-    SIGSTOP,
-    SIGTSTP,
-    SIGTTIN,
-    SIGTTOU,
-    SIGURG,
-    SIGXCPU,
-    SIGXFSZ,
-    SIGVTALRM,
-    SIGPROF,
-    SIGWINCH,
-    SIGIO,
-    SIGPWR,
-    SIGSYS];
-#[cfg(all(any(target_os = "linux", target_os = "android",
-              target_os = "emscripten", target_os = "fuchsia"),
-          any(target_arch = "mips", target_arch = "mips64",
-              target_arch = "sparc64")))]
+    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGKILL,
+    SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGSTKFLT, SIGCHLD,
+    SIGCONT, SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ,
+    SIGVTALRM, SIGPROF, SIGWINCH, SIGIO, SIGPWR, SIGSYS,
+];
+#[cfg(all(
+    any(
+        target_os = "linux",
+        target_os = "android",
+        target_os = "emscripten",
+        target_os = "fuchsia"
+    ),
+    any(target_arch = "mips", target_arch = "mips64", target_arch = "sparc64")
+))]
+#[cfg(feature = "signal")]
 const SIGNALS: [Signal; 30] = [
-    SIGHUP,
-    SIGINT,
-    SIGQUIT,
-    SIGILL,
-    SIGTRAP,
-    SIGABRT,
-    SIGBUS,
-    SIGFPE,
-    SIGKILL,
-    SIGUSR1,
-    SIGSEGV,
-    SIGUSR2,
-    SIGPIPE,
-    SIGALRM,
-    SIGTERM,
-    SIGCHLD,
-    SIGCONT,
-    SIGSTOP,
-    SIGTSTP,
-    SIGTTIN,
-    SIGTTOU,
-    SIGURG,
-    SIGXCPU,
-    SIGXFSZ,
-    SIGVTALRM,
-    SIGPROF,
-    SIGWINCH,
-    SIGIO,
-    SIGPWR,
-    SIGSYS];
-#[cfg(not(any(target_os = "linux", target_os = "android",
-              target_os = "fuchsia", target_os = "emscripten",
-              target_os = "redox")))]
+    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGKILL,
+    SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGCONT,
+    SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM,
+    SIGPROF, SIGWINCH, SIGIO, SIGPWR, SIGSYS,
+];
+#[cfg(not(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "fuchsia",
+    target_os = "emscripten",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
+#[cfg(feature = "signal")]
 const SIGNALS: [Signal; 31] = [
-    SIGHUP,
-    SIGINT,
-    SIGQUIT,
-    SIGILL,
-    SIGTRAP,
-    SIGABRT,
-    SIGBUS,
-    SIGFPE,
-    SIGKILL,
-    SIGUSR1,
-    SIGSEGV,
-    SIGUSR2,
-    SIGPIPE,
-    SIGALRM,
-    SIGTERM,
-    SIGCHLD,
-    SIGCONT,
-    SIGSTOP,
-    SIGTSTP,
-    SIGTTIN,
-    SIGTTOU,
-    SIGURG,
-    SIGXCPU,
-    SIGXFSZ,
-    SIGVTALRM,
-    SIGPROF,
-    SIGWINCH,
-    SIGIO,
-    SIGSYS,
-    SIGEMT,
-    SIGINFO];
+    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGBUS, SIGFPE, SIGKILL,
+    SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGCONT,
+    SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM,
+    SIGPROF, SIGWINCH, SIGIO, SIGSYS, SIGEMT, SIGINFO,
+];
+
+feature! {
+#![feature = "signal"]
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 /// Iterate through all signals defined by this operating system
@@ -399,17 +394,26 @@ impl Signal {
 /// Alias for [`SIGABRT`]
 pub const SIGIOT : Signal = SIGABRT;
 /// Alias for [`SIGIO`]
+#[cfg(not(target_os = "haiku"))]
 pub const SIGPOLL : Signal = SIGIO;
 /// Alias for [`SIGSYS`]
 pub const SIGUNUSED : Signal = SIGSYS;
 
-#[cfg(not(target_os = "redox"))]
-type SaFlags_t = libc::c_int;
-#[cfg(target_os = "redox")]
-type SaFlags_t = libc::c_ulong;
+cfg_if! {
+    if #[cfg(target_os = "redox")] {
+        type SaFlags_t = libc::c_ulong;
+    } else if #[cfg(target_env = "uclibc")] {
+        type SaFlags_t = libc::c_ulong;
+    } else {
+        type SaFlags_t = libc::c_int;
+    }
+}
+}
 
-libc_bitflags!{
+#[cfg(feature = "signal")]
+libc_bitflags! {
     /// Controls the behavior of a [`SigAction`]
+    #[cfg_attr(docsrs, doc(cfg(feature = "signal")))]
     pub struct SaFlags: SaFlags_t {
         /// When catching a [`Signal::SIGCHLD`] signal, the signal will be
         /// generated only when a child process exits, not when a child process
@@ -435,10 +439,12 @@ libc_bitflags!{
     }
 }
 
+#[cfg(feature = "signal")]
 libc_enum! {
     /// Specifies how certain functions should manipulate a signal mask
     #[repr(i32)]
     #[non_exhaustive]
+    #[cfg_attr(docsrs, doc(cfg(feature = "signal")))]
     pub enum SigmaskHow {
         /// The new mask is the union of the current mask and the specified set.
         SIG_BLOCK,
@@ -450,15 +456,26 @@ libc_enum! {
     }
 }
 
+feature! {
+#![feature = "signal"]
+
+use crate::unistd::Pid;
+use std::iter::Extend;
+use std::iter::FromIterator;
+use std::iter::IntoIterator;
+
 /// Specifies a set of [`Signal`]s that may be blocked, waited for, etc.
+// We are using `transparent` here to be super sure that `SigSet`
+// is represented exactly like the `sigset_t` struct from C.
+#[repr(transparent)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct SigSet {
     sigset: libc::sigset_t
 }
 
-
 impl SigSet {
     /// Initialize to include all signals.
+    #[doc(alias("sigfillset"))]
     pub fn all() -> SigSet {
         let mut sigset = mem::MaybeUninit::uninit();
         let _ = unsafe { libc::sigfillset(sigset.as_mut_ptr()) };
@@ -467,6 +484,7 @@ impl SigSet {
     }
 
     /// Initialize to include nothing.
+    #[doc(alias("sigemptyset"))]
     pub fn empty() -> SigSet {
         let mut sigset = mem::MaybeUninit::uninit();
         let _ = unsafe { libc::sigemptyset(sigset.as_mut_ptr()) };
@@ -475,21 +493,25 @@ impl SigSet {
     }
 
     /// Add the specified signal to the set.
+    #[doc(alias("sigaddset"))]
     pub fn add(&mut self, signal: Signal) {
         unsafe { libc::sigaddset(&mut self.sigset as *mut libc::sigset_t, signal as libc::c_int) };
     }
 
     /// Remove all signals from this set.
+    #[doc(alias("sigemptyset"))]
     pub fn clear(&mut self) {
         unsafe { libc::sigemptyset(&mut self.sigset as *mut libc::sigset_t) };
     }
 
     /// Remove the specified signal from this set.
+    #[doc(alias("sigdelset"))]
     pub fn remove(&mut self, signal: Signal) {
         unsafe { libc::sigdelset(&mut self.sigset as *mut libc::sigset_t, signal as libc::c_int) };
     }
 
     /// Return whether this set includes the specified signal.
+    #[doc(alias("sigismember"))]
     pub fn contains(&self, signal: Signal) -> bool {
         let res = unsafe { libc::sigismember(&self.sigset as *const libc::sigset_t, signal as libc::c_int) };
 
@@ -500,14 +522,9 @@ impl SigSet {
         }
     }
 
-    /// Merge all of `other`'s signals into this set.
-    // TODO: use libc::sigorset on supported operating systems.
-    pub fn extend(&mut self, other: &SigSet) {
-        for signal in Signal::iterator() {
-            if other.contains(signal) {
-                self.add(signal);
-            }
-        }
+    /// Returns an iterator that yields the signals contained in this set.
+    pub fn iter(&self) -> SigSetIter<'_> {
+        self.into_iter()
     }
 
     /// Gets the currently blocked (masked) set of signals for the calling thread.
@@ -542,6 +559,7 @@ impl SigSet {
     /// Suspends execution of the calling thread until one of the signals in the
     /// signal mask becomes pending, and returns the accepted signal.
     #[cfg(not(target_os = "redox"))] // RedoxFS does not yet support sigwait
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn wait(&self) -> Result<Signal> {
         use std::convert::TryFrom;
 
@@ -552,6 +570,19 @@ impl SigSet {
             Signal::try_from(signum.assume_init()).unwrap()
         })
     }
+
+    /// Converts a `libc::sigset_t` object to a [`SigSet`] without checking  whether the
+    /// `libc::sigset_t` is already initialized.
+    ///
+    /// # Safety
+    ///
+    /// The `sigset` passed in must be a valid an initialized `libc::sigset_t` by calling either
+    /// [`sigemptyset(3)`](https://man7.org/linux/man-pages/man3/sigemptyset.3p.html) or
+    /// [`sigfillset(3)`](https://man7.org/linux/man-pages/man3/sigfillset.3p.html).
+    /// Otherwise, the results are undefined.
+    pub unsafe fn from_sigset_t_unchecked(sigset: libc::sigset_t) -> SigSet {
+        SigSet { sigset }
+    }
 }
 
 impl AsRef<libc::sigset_t> for SigSet {
@@ -560,6 +591,55 @@ impl AsRef<libc::sigset_t> for SigSet {
     }
 }
 
+// TODO: Consider specialization for the case where T is &SigSet and libc::sigorset is available.
+impl Extend<Signal> for SigSet {
+    fn extend<T>(&mut self, iter: T)
+    where T: IntoIterator<Item = Signal> {
+        for signal in iter {
+            self.add(signal);
+        }
+    }
+}
+
+impl FromIterator<Signal> for SigSet {
+    fn from_iter<T>(iter: T) -> Self
+    where T: IntoIterator<Item = Signal> {
+        let mut sigset = SigSet::empty();
+        sigset.extend(iter);
+        sigset
+    }
+}
+
+/// Iterator for a [`SigSet`].
+///
+/// Call [`SigSet::iter`] to create an iterator.
+#[derive(Clone, Debug)]
+pub struct SigSetIter<'a> {
+    sigset: &'a SigSet,
+    inner: SignalIterator,
+}
+
+impl Iterator for SigSetIter<'_> {
+    type Item = Signal;
+    fn next(&mut self) -> Option<Signal> {
+        loop {
+            match self.inner.next() {
+                None => return None,
+                Some(signal) if self.sigset.contains(signal) => return Some(signal),
+                Some(_signal) => continue,
+            }
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a SigSet {
+    type Item = Signal;
+    type IntoIter = SigSetIter<'a>;
+    fn into_iter(self) -> Self::IntoIter {
+        SigSetIter { sigset: self, inner: Signal::iterator() }
+    }
+}
+
 /// A signal handler.
 #[allow(unknown_lints)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
@@ -573,6 +653,7 @@ pub enum SigHandler {
     /// Use the given signal-catching function, which takes in the signal, information about how
     /// the signal was generated, and a pointer to the threads `ucontext_t`.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SigAction(extern fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void))
 }
 
@@ -589,21 +670,12 @@ impl SigAction {
     /// is the `SigAction` variant). `mask` specifies other signals to block during execution of
     /// the signal-catching function.
     pub fn new(handler: SigHandler, flags: SaFlags, mask: SigSet) -> SigAction {
-        #[cfg(target_os = "redox")]
-        unsafe fn install_sig(p: *mut libc::sigaction, handler: SigHandler) {
-            (*p).sa_handler = match handler {
-                SigHandler::SigDfl => libc::SIG_DFL,
-                SigHandler::SigIgn => libc::SIG_IGN,
-                SigHandler::Handler(f) => f as *const extern fn(libc::c_int) as usize,
-            };
-        }
-
-        #[cfg(not(target_os = "redox"))]
         unsafe fn install_sig(p: *mut libc::sigaction, handler: SigHandler) {
             (*p).sa_sigaction = match handler {
                 SigHandler::SigDfl => libc::SIG_DFL,
                 SigHandler::SigIgn => libc::SIG_IGN,
                 SigHandler::Handler(f) => f as *const extern fn(libc::c_int) as usize,
+                #[cfg(not(target_os = "redox"))]
                 SigHandler::SigAction(f) => f as *const extern fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void) as usize,
             };
         }
@@ -635,11 +707,11 @@ impl SigAction {
     }
 
     /// Returns the action's handler.
-    #[cfg(not(target_os = "redox"))]
     pub fn handler(&self) -> SigHandler {
         match self.sigaction.sa_sigaction {
             libc::SIG_DFL => SigHandler::SigDfl,
             libc::SIG_IGN => SigHandler::SigIgn,
+            #[cfg(not(target_os = "redox"))]
             p if self.flags().contains(SaFlags::SA_SIGINFO) =>
                 SigHandler::SigAction(
                 // Safe for one of two reasons:
@@ -667,27 +739,6 @@ impl SigAction {
                 as extern fn(libc::c_int)),
         }
     }
-
-    /// Returns the action's handler.
-    #[cfg(target_os = "redox")]
-    pub fn handler(&self) -> SigHandler {
-        match self.sigaction.sa_handler {
-            libc::SIG_DFL => SigHandler::SigDfl,
-            libc::SIG_IGN => SigHandler::SigIgn,
-            p => SigHandler::Handler(
-                // Safe for one of two reasons:
-                // * The SigHandler was created by SigHandler::new, in which
-                //   case the pointer is correct, or
-                // * The SigHandler was created by signal or sigaction, which
-                //   are unsafe functions, so the caller should've somehow
-                //   ensured that it is correctly initialized.
-                unsafe{
-                    *(&p as *const usize
-                         as *const extern fn(libc::c_int))
-                }
-                as extern fn(libc::c_int)),
-        }
-    }
 }
 
 /// Changes the action taken by a process on receipt of a specific signal.
@@ -836,7 +887,7 @@ pub fn pthread_sigmask(how: SigmaskHow,
 
 /// Examine and change blocked signals.
 ///
-/// For more informations see the [`sigprocmask` man
+/// For more information see the [`sigprocmask` man
 /// pages](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html).
 pub fn sigprocmask(how: SigmaskHow, set: Option<&SigSet>, oldset: Option<&mut SigSet>) -> Result<()> {
     if set.is_none() && oldset.is_none() {
@@ -860,10 +911,11 @@ pub fn sigprocmask(how: SigmaskHow, set: Option<&SigSet>, oldset: Option<&mut Si
 /// # Arguments
 ///
 /// * `pid` -    Specifies which processes should receive the signal.
-///   - If positive, specifies an individual process
+///   - If positive, specifies an individual process.
 ///   - If zero, the signal will be sent to all processes whose group
 ///     ID is equal to the process group ID of the sender.  This is a
-///     variant of [`killpg`].
+#[cfg_attr(target_os = "fuchsia", doc = "variant of `killpg`.")]
+#[cfg_attr(not(target_os = "fuchsia"), doc = "variant of [`killpg`].")]
 ///   - If `-1` and the process has super-user privileges, the signal
 ///     is sent to all processes exclusing system processes.
 ///   - If less than `-1`, the signal is sent to all processes whose
@@ -912,7 +964,10 @@ pub fn raise(signal: Signal) -> Result<()> {
 
     Errno::result(res).map(drop)
 }
+}
 
+feature! {
+#![any(feature = "aio", feature = "signal")]
 
 /// Identifies a thread for [`SigevNotify::SigevThreadId`]
 #[cfg(target_os = "freebsd")]
@@ -942,6 +997,7 @@ pub enum SigevNotify {
     // expose a way to set the union members needed by SIGEV_THREAD.
     /// Notify by delivering an event to a kqueue.
     #[cfg(any(target_os = "dragonfly", target_os = "freebsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SigevKevent {
         /// File descriptor of the kqueue to notify.
         kq: RawFd,
@@ -950,6 +1006,7 @@ pub enum SigevNotify {
     },
     /// Notify by delivering a signal to a thread.
     #[cfg(any(target_os = "freebsd", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SigevThreadId {
         /// Signal to send
         signal: Signal,
@@ -960,9 +1017,14 @@ pub enum SigevNotify {
         si_value: libc::intptr_t
     },
 }
+}
 
 #[cfg(not(any(target_os = "openbsd", target_os = "redox")))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod sigevent {
+    feature! {
+    #![any(feature = "aio", feature = "signal")]
+
     use std::mem;
     use std::ptr;
     use super::SigevNotify;
@@ -1005,6 +1067,8 @@ mod sigevent {
                 SigevNotify::SigevThreadId{..} => libc::SIGEV_THREAD_ID,
                 #[cfg(all(target_os = "linux", target_env = "gnu", not(target_arch = "mips")))]
                 SigevNotify::SigevThreadId{..} => libc::SIGEV_THREAD_ID,
+                #[cfg(all(target_os = "linux", target_env = "uclibc"))]
+                SigevNotify::SigevThreadId{..} => libc::SIGEV_THREAD_ID,
                 #[cfg(any(all(target_os = "linux", target_env = "musl"), target_arch = "mips"))]
                 SigevNotify::SigevThreadId{..} => 4  // No SIGEV_THREAD_ID defined
             };
@@ -1044,6 +1108,11 @@ mod sigevent {
         pub fn sigevent(&self) -> libc::sigevent {
             self.sigevent
         }
+
+        /// Returns a mutable pointer to the `sigevent` wrapped by `self`
+        pub fn as_mut_ptr(&mut self) -> *mut libc::sigevent {
+            &mut self.sigevent
+        }
     }
 
     impl<'a> From<&'a libc::sigevent> for SigEvent {
@@ -1051,13 +1120,14 @@ mod sigevent {
             SigEvent{ sigevent: *sigevent }
         }
     }
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     #[cfg(not(target_os = "redox"))]
     use std::thread;
-    use super::*;
 
     #[test]
     fn test_contains() {
@@ -1120,15 +1190,19 @@ mod tests {
             let mut test_mask = prev_mask;
             test_mask.add(SIGUSR1);
 
-            assert!(test_mask.thread_set_mask().is_ok());
-            let new_mask = SigSet::thread_get_mask()
-                .expect("Failed to get new mask!");
+            test_mask.thread_set_mask().expect("assertion failed");
+            let new_mask =
+                SigSet::thread_get_mask().expect("Failed to get new mask!");
 
             assert!(new_mask.contains(SIGUSR1));
             assert!(!new_mask.contains(SIGUSR2));
 
-            prev_mask.thread_set_mask().expect("Failed to revert signal mask!");
-        }).join().unwrap();
+            prev_mask
+                .thread_set_mask()
+                .expect("Failed to revert signal mask!");
+        })
+        .join()
+        .unwrap();
     }
 
     #[test]
@@ -1138,10 +1212,12 @@ mod tests {
             let mut mask = SigSet::empty();
             mask.add(SIGUSR1);
 
-            assert!(mask.thread_block().is_ok());
+            mask.thread_block().expect("assertion failed");
 
             assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
     }
 
     #[test]
@@ -1151,10 +1227,12 @@ mod tests {
             let mut mask = SigSet::empty();
             mask.add(SIGUSR1);
 
-            assert!(mask.thread_unblock().is_ok());
+            mask.thread_unblock().expect("assertion failed");
 
             assert!(!SigSet::thread_get_mask().unwrap().contains(SIGUSR1));
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
     }
 
     #[test]
@@ -1170,36 +1248,51 @@ mod tests {
             let mut mask2 = SigSet::empty();
             mask2.add(SIGUSR2);
 
-            let oldmask = mask2.thread_swap_mask(SigmaskHow::SIG_SETMASK)
-                .unwrap();
+            let oldmask =
+                mask2.thread_swap_mask(SigmaskHow::SIG_SETMASK).unwrap();
 
             assert!(oldmask.contains(SIGUSR1));
             assert!(!oldmask.contains(SIGUSR2));
 
             assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR2));
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_from_and_into_iterator() {
+        let sigset = SigSet::from_iter(vec![Signal::SIGUSR1, Signal::SIGUSR2]);
+        let signals = sigset.into_iter().collect::<Vec<Signal>>();
+        assert_eq!(signals, [Signal::SIGUSR1, Signal::SIGUSR2]);
     }
 
     #[test]
     #[cfg(not(target_os = "redox"))]
     fn test_sigaction() {
         thread::spawn(|| {
-            extern fn test_sigaction_handler(_: libc::c_int) {}
-            extern fn test_sigaction_action(_: libc::c_int,
-                _: *mut libc::siginfo_t, _: *mut libc::c_void) {}
+            extern "C" fn test_sigaction_handler(_: libc::c_int) {}
+            extern "C" fn test_sigaction_action(
+                _: libc::c_int,
+                _: *mut libc::siginfo_t,
+                _: *mut libc::c_void,
+            ) {
+            }
 
             let handler_sig = SigHandler::Handler(test_sigaction_handler);
 
-            let flags = SaFlags::SA_ONSTACK | SaFlags::SA_RESTART |
-                        SaFlags::SA_SIGINFO;
+            let flags =
+                SaFlags::SA_ONSTACK | SaFlags::SA_RESTART | SaFlags::SA_SIGINFO;
 
             let mut mask = SigSet::empty();
             mask.add(SIGUSR1);
 
             let action_sig = SigAction::new(handler_sig, flags, mask);
 
-            assert_eq!(action_sig.flags(),
-                       SaFlags::SA_ONSTACK | SaFlags::SA_RESTART);
+            assert_eq!(
+                action_sig.flags(),
+                SaFlags::SA_ONSTACK | SaFlags::SA_RESTART
+            );
             assert_eq!(action_sig.handler(), handler_sig);
 
             mask = action_sig.mask();
@@ -1215,7 +1308,9 @@ mod tests {
 
             let action_ign = SigAction::new(SigHandler::SigIgn, flags, mask);
             assert_eq!(action_ign.handler(), SigHandler::SigIgn);
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
     }
 
     #[test]
@@ -1229,6 +1324,25 @@ mod tests {
 
             raise(SIGUSR1).unwrap();
             assert_eq!(mask.wait().unwrap(), SIGUSR1);
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn test_from_sigset_t_unchecked() {
+        let src_set = SigSet::empty();
+        let set = unsafe { SigSet::from_sigset_t_unchecked(src_set.sigset) };
+
+        for signal in Signal::iterator() {
+            assert!(!set.contains(signal));
+        }
+
+        let src_set = SigSet::all();
+        let set = unsafe { SigSet::from_sigset_t_unchecked(src_set.sigset) };
+
+        for signal in Signal::iterator() {
+            assert!(set.contains(signal));
+        }
     }
 }
diff --git a/src/sys/signalfd.rs b/src/sys/signalfd.rs
index bc4a452..095e590 100644
--- a/src/sys/signalfd.rs
+++ b/src/sys/signalfd.rs
@@ -15,17 +15,16 @@
 //!
 //! Please note that signal discarding is not specific to `signalfd`, but also happens with regular
 //! signal handlers.
-use crate::unistd;
-use crate::Result;
 use crate::errno::Errno;
 pub use crate::sys::signal::{self, SigSet};
+use crate::unistd;
+use crate::Result;
 pub use libc::signalfd_siginfo as siginfo;
 
-use std::os::unix::io::{RawFd, AsRawFd};
 use std::mem;
+use std::os::unix::io::{AsRawFd, RawFd};
 
-
-libc_bitflags!{
+libc_bitflags! {
     pub struct SfdFlags: libc::c_int {
         SFD_NONBLOCK;
         SFD_CLOEXEC;
@@ -49,7 +48,11 @@ pub const SIGNALFD_SIGINFO_SIZE: usize = mem::size_of::<siginfo>();
 /// See [the signalfd man page for more information](https://man7.org/linux/man-pages/man2/signalfd.2.html)
 pub fn signalfd(fd: RawFd, mask: &SigSet, flags: SfdFlags) -> Result<RawFd> {
     unsafe {
-        Errno::result(libc::signalfd(fd as libc::c_int, mask.as_ref(), flags.bits()))
+        Errno::result(libc::signalfd(
+            fd as libc::c_int,
+            mask.as_ref(),
+            flags.bits(),
+        ))
     }
 }
 
@@ -103,12 +106,13 @@ impl SignalFd {
         let size = mem::size_of_val(&buffer);
         let res = Errno::result(unsafe {
             libc::read(self.0, buffer.as_mut_ptr() as *mut libc::c_void, size)
-        }).map(|r| r as usize);
+        })
+        .map(|r| r as usize);
         match res {
             Ok(x) if x == size => Ok(Some(unsafe { buffer.assume_init() })),
             Ok(_) => unreachable!("partial read on signalfd"),
             Err(Errno::EAGAIN) => Ok(None),
-            Err(error) => Err(error)
+            Err(error) => Err(error),
         }
     }
 }
@@ -139,7 +143,6 @@ impl Iterator for SignalFd {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -147,21 +150,24 @@ mod tests {
     #[test]
     fn create_signalfd() {
         let mask = SigSet::empty();
-        let fd = SignalFd::new(&mask);
-        assert!(fd.is_ok());
+        SignalFd::new(&mask).unwrap();
     }
 
     #[test]
     fn create_signalfd_with_opts() {
         let mask = SigSet::empty();
-        let fd = SignalFd::with_flags(&mask, SfdFlags::SFD_CLOEXEC | SfdFlags::SFD_NONBLOCK);
-        assert!(fd.is_ok());
+        SignalFd::with_flags(
+            &mask,
+            SfdFlags::SFD_CLOEXEC | SfdFlags::SFD_NONBLOCK,
+        )
+        .unwrap();
     }
 
     #[test]
     fn read_empty_signalfd() {
         let mask = SigSet::empty();
-        let mut fd = SignalFd::with_flags(&mask, SfdFlags::SFD_NONBLOCK).unwrap();
+        let mut fd =
+            SignalFd::with_flags(&mask, SfdFlags::SFD_NONBLOCK).unwrap();
 
         let res = fd.read_signal();
         assert!(res.unwrap().is_none());
diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs
index b119642..4e565a5 100644
--- a/src/sys/socket/addr.rs
+++ b/src/sys/socket/addr.rs
@@ -1,36 +1,71 @@
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "illumos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "haiku",
+    target_os = "fuchsia"
+))]
+#[cfg(feature = "net")]
+pub use self::datalink::LinkAddr;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+pub use self::vsock::VsockAddr;
 use super::sa_family_t;
-use crate::{Result, NixPath};
 use crate::errno::Errno;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+use crate::sys::socket::addr::alg::AlgAddr;
+#[cfg(any(target_os = "android", target_os = "linux"))]
+use crate::sys::socket::addr::netlink::NetlinkAddr;
+#[cfg(all(
+    feature = "ioctl",
+    any(target_os = "ios", target_os = "macos")
+))]
+use crate::sys::socket::addr::sys_control::SysControlAddr;
+use crate::{NixPath, Result};
+use cfg_if::cfg_if;
 use memoffset::offset_of;
-use std::{fmt, mem, net, ptr, slice};
+use std::convert::TryInto;
 use std::ffi::OsStr;
 use std::hash::{Hash, Hasher};
-use std::path::Path;
 use std::os::unix::ffi::OsStrExt;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::sys::socket::addr::netlink::NetlinkAddr;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-use crate::sys::socket::addr::alg::AlgAddr;
 #[cfg(any(target_os = "ios", target_os = "macos"))]
 use std::os::unix::io::RawFd;
-#[cfg(any(target_os = "ios", target_os = "macos"))]
-use crate::sys::socket::addr::sys_control::SysControlAddr;
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "illumos",
-          target_os = "netbsd",
-          target_os = "openbsd",
-          target_os = "fuchsia"))]
-pub use self::datalink::LinkAddr;
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub use self::vsock::VsockAddr;
+use std::path::Path;
+use std::{fmt, mem, net, ptr, slice};
+
+/// Convert a std::net::Ipv4Addr into the libc form.
+#[cfg(feature = "net")]
+pub(crate) const fn ipv4addr_to_libc(addr: net::Ipv4Addr) -> libc::in_addr {
+    static_assertions::assert_eq_size!(net::Ipv4Addr, libc::in_addr);
+    // Safe because both types have the same memory layout, and no fancy Drop
+    // impls.
+    unsafe {
+        mem::transmute(addr)
+    }
+}
+
+/// Convert a std::net::Ipv6Addr into the libc form.
+#[cfg(feature = "net")]
+pub(crate) const fn ipv6addr_to_libc(addr: &net::Ipv6Addr) -> libc::in6_addr {
+    static_assertions::assert_eq_size!(net::Ipv6Addr, libc::in6_addr);
+    // Safe because both are Newtype wrappers around the same libc type
+    unsafe {
+        mem::transmute(*addr)
+    }
+}
 
 /// These constants specify the protocol family to be used
 /// in [`socket`](fn.socket.html) and [`socketpair`](fn.socketpair.html)
+///
+/// # References
+///
+/// [address_families(7)](https://man7.org/linux/man-pages/man7/address_families.7.html)
+// Should this be u8?
 #[repr(i32)]
 #[non_exhaustive]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
@@ -43,191 +78,331 @@ pub enum AddressFamily {
     Inet6 = libc::AF_INET6,
     /// Kernel user interface device (see [`netlink(7)`](https://man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Netlink = libc::AF_NETLINK,
     /// Low level packet interface (see [`packet(7)`](https://man7.org/linux/man-pages/man7/packet.7.html))
-    #[cfg(any(target_os = "android",
-              target_os = "linux",
-              target_os = "illumos",
-              target_os = "fuchsia",
-              target_os = "solaris"))]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "linux",
+        target_os = "illumos",
+        target_os = "fuchsia",
+        target_os = "solaris"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Packet = libc::AF_PACKET,
     /// KEXT Controls and Notifications
     #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     System = libc::AF_SYSTEM,
     /// Amateur radio AX.25 protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ax25 = libc::AF_AX25,
     /// IPX - Novell protocols
     Ipx = libc::AF_IPX,
     /// AppleTalk
     AppleTalk = libc::AF_APPLETALK,
+    /// AX.25 packet layer protocol.
+    /// (see [netrom(4)](https://www.unix.com/man-page/linux/4/netrom/))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetRom = libc::AF_NETROM,
+    /// Can't be used for creating sockets; mostly used for bridge
+    /// links in
+    /// [rtnetlink(7)](https://man7.org/linux/man-pages/man7/rtnetlink.7.html)
+    /// protocol commands.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Bridge = libc::AF_BRIDGE,
     /// Access to raw ATM PVCs
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AtmPvc = libc::AF_ATMPVC,
     /// ITU-T X.25 / ISO-8208 protocol (see [`x25(7)`](https://man7.org/linux/man-pages/man7/x25.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     X25 = libc::AF_X25,
+    /// RATS (Radio Amateur Telecommunications Society) Open
+    /// Systems environment (ROSE) AX.25 packet layer protocol.
+    /// (see [netrom(4)](https://www.unix.com/man-page/linux/4/netrom/))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Rose = libc::AF_ROSE,
+    /// DECet protocol sockets.
+    #[cfg(not(target_os = "haiku"))]
     Decnet = libc::AF_DECnet,
+    /// Reserved for "802.2LLC project"; never used.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetBeui = libc::AF_NETBEUI,
+    /// This was a short-lived (between Linux 2.1.30 and
+    /// 2.1.99pre2) protocol family for firewall upcalls.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Security = libc::AF_SECURITY,
+    /// Key management protocol.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Key = libc::AF_KEY,
+    #[allow(missing_docs)] // Not documented anywhere that I can find
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ash = libc::AF_ASH,
+    /// Acorn Econet protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Econet = libc::AF_ECONET,
+    /// Access to ATM Switched Virtual Circuits
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AtmSvc = libc::AF_ATMSVC,
+    /// Reliable Datagram Sockets (RDS) protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Rds = libc::AF_RDS,
+    /// IBM SNA
+    #[cfg(not(target_os = "haiku"))]
     Sna = libc::AF_SNA,
+    /// Socket interface over IrDA
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Irda = libc::AF_IRDA,
+    /// Generic PPP transport layer, for setting up L2 tunnels (L2TP and PPPoE)
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Pppox = libc::AF_PPPOX,
+    /// Legacy protocol for wide area network (WAN) connectivity that was used
+    /// by Sangoma WAN cards
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Wanpipe = libc::AF_WANPIPE,
+    /// Logical link control (IEEE 802.2 LLC) protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Llc = libc::AF_LLC,
-    #[cfg(target_os = "linux")]
+    /// InfiniBand native addressing
+    #[cfg(all(target_os = "linux", not(target_env = "uclibc")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ib = libc::AF_IB,
-    #[cfg(target_os = "linux")]
+    /// Multiprotocol Label Switching
+    #[cfg(all(target_os = "linux", not(target_env = "uclibc")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Mpls = libc::AF_MPLS,
+    /// Controller Area Network automotive bus protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Can = libc::AF_CAN,
+    /// TIPC, "cluster domain sockets" protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Tipc = libc::AF_TIPC,
-    #[cfg(not(any(target_os = "illumos",
-                  target_os = "ios",
-                  target_os = "macos",
-                  target_os = "solaris")))]
+    /// Bluetooth low-level socket protocol
+    #[cfg(not(any(
+        target_os = "illumos",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "solaris"
+    )))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Bluetooth = libc::AF_BLUETOOTH,
+    /// IUCV (inter-user communication vehicle) z/VM protocol for
+    /// hypervisor-guest interaction
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Iucv = libc::AF_IUCV,
+    /// Rx, Andrew File System remote procedure call protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     RxRpc = libc::AF_RXRPC,
-    #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+    /// New "modular ISDN" driver interface protocol
+    #[cfg(not(any(
+        target_os = "illumos",
+        target_os = "solaris",
+        target_os = "haiku"
+    )))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Isdn = libc::AF_ISDN,
+    /// Nokia cellular modem IPC/RPC interface
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Phonet = libc::AF_PHONET,
+    /// IEEE 802.15.4 WPAN (wireless personal area network) raw packet protocol
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ieee802154 = libc::AF_IEEE802154,
+    /// Ericsson's Communication CPU to Application CPU interface (CAIF)
+    /// protocol.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Caif = libc::AF_CAIF,
     /// Interface to kernel crypto API
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Alg = libc::AF_ALG,
+    /// Near field communication
     #[cfg(target_os = "linux")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Nfc = libc::AF_NFC,
+    /// VMWare VSockets protocol for hypervisor-guest interaction.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Vsock = libc::AF_VSOCK,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// ARPANet IMP addresses
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ImpLink = libc::AF_IMPLINK,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// PUP protocols, e.g. BSP
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Pup = libc::AF_PUP,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// MIT CHAOS protocols
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Chaos = libc::AF_CHAOS,
-    #[cfg(any(target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// Novell and Xerox protocol
+    #[cfg(any(
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ns = libc::AF_NS,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    #[allow(missing_docs)] // Not documented anywhere that I can find
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Iso = libc::AF_ISO,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// Bell Labs virtual circuit switch ?
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Datakit = libc::AF_DATAKIT,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// CCITT protocols, X.25 etc
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Ccitt = libc::AF_CCITT,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// DEC Direct data link interface
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Dli = libc::AF_DLI,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    #[allow(missing_docs)] // Not documented anywhere that I can find
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Lat = libc::AF_LAT,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// NSC Hyperchannel
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Hylink = libc::AF_HYLINK,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "illumos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// Link layer interface
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "illumos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Link = libc::AF_LINK,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// connection-oriented IP, aka ST II
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Coip = libc::AF_COIP,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// Computer Network Technology
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Cnt = libc::AF_CNT,
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    /// Native ATM access
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Natm = libc::AF_NATM,
     /// Unspecified address family, (see [`getaddrinfo(3)`](https://man7.org/linux/man-pages/man3/getaddrinfo.3.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Unspec = libc::AF_UNSPEC,
 }
 
@@ -248,33 +423,50 @@ impl AddressFamily {
             libc::AF_SYSTEM => Some(AddressFamily::System),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             libc::AF_PACKET => Some(AddressFamily::Packet),
-            #[cfg(any(target_os = "dragonfly",
-                      target_os = "freebsd",
-                      target_os = "ios",
-                      target_os = "macos",
-                      target_os = "netbsd",
-                      target_os = "illumos",
-                      target_os = "openbsd"))]
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "illumos",
+                target_os = "openbsd"
+            ))]
             libc::AF_LINK => Some(AddressFamily::Link),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             libc::AF_VSOCK => Some(AddressFamily::Vsock),
-            _ => None
+            _ => None,
         }
     }
 }
 
+feature! {
+#![feature = "net"]
+
+#[deprecated(
+    since = "0.24.0",
+    note = "use SockaddrIn, SockaddrIn6, or SockaddrStorage instead"
+)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum InetAddr {
     V4(libc::sockaddr_in),
     V6(libc::sockaddr_in6),
 }
 
+#[allow(missing_docs)]  // It's deprecated anyway
+#[allow(deprecated)]
 impl InetAddr {
     #[allow(clippy::needless_update)]   // It isn't needless on all OSes
     pub fn from_std(std: &net::SocketAddr) -> InetAddr {
         match *std {
             net::SocketAddr::V4(ref addr) => {
                 InetAddr::V4(libc::sockaddr_in {
+                    #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
+                              target_os = "haiku", target_os = "hermit",
+                              target_os = "ios", target_os = "macos",
+                              target_os = "netbsd", target_os = "openbsd"))]
+                    sin_len: mem::size_of::<libc::sockaddr_in>() as u8,
                     sin_family: AddressFamily::Inet as sa_family_t,
                     sin_port: addr.port().to_be(),  // network byte order
                     sin_addr: Ipv4Addr::from_std(addr.ip()).0,
@@ -283,6 +475,11 @@ impl InetAddr {
             }
             net::SocketAddr::V6(ref addr) => {
                 InetAddr::V6(libc::sockaddr_in6 {
+                    #[cfg(any(target_os = "dragonfly", target_os = "freebsd",
+                              target_os = "haiku", target_os = "hermit",
+                              target_os = "ios", target_os = "macos",
+                              target_os = "netbsd", target_os = "openbsd"))]
+                    sin6_len: mem::size_of::<libc::sockaddr_in6>() as u8,
                     sin6_family: AddressFamily::Inet6 as sa_family_t,
                     sin6_port: addr.port().to_be(),  // network byte order
                     sin6_addr: Ipv6Addr::from_std(addr.ip()).0,
@@ -352,6 +549,7 @@ impl InetAddr {
     }
 }
 
+#[allow(deprecated)]
 impl fmt::Display for InetAddr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -366,12 +564,20 @@ impl fmt::Display for InetAddr {
  * ===== IpAddr =====
  *
  */
+#[allow(missing_docs)]  // Since they're all deprecated anyway
+#[allow(deprecated)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[deprecated(
+    since = "0.24.0",
+    note = "Use std::net::IpAddr instead"
+)]
 pub enum IpAddr {
     V4(Ipv4Addr),
     V6(Ipv6Addr),
 }
 
+#[allow(deprecated)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 impl IpAddr {
     /// Create a new IpAddr that contains an IPv4 address.
     ///
@@ -404,6 +610,7 @@ impl IpAddr {
     }
 }
 
+#[allow(deprecated)]
 impl fmt::Display for IpAddr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -419,9 +626,17 @@ impl fmt::Display for IpAddr {
  *
  */
 
+#[deprecated(
+    since = "0.24.0",
+    note = "Use std::net::Ipv4Addr instead"
+)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[repr(transparent)]
 pub struct Ipv4Addr(pub libc::in_addr);
 
+#[allow(deprecated)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 impl Ipv4Addr {
     #[allow(clippy::identity_op)]   // More readable this way
     pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
@@ -455,6 +670,7 @@ impl Ipv4Addr {
     }
 }
 
+#[allow(deprecated)]
 impl fmt::Display for Ipv4Addr {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let octets = self.octets();
@@ -468,7 +684,13 @@ impl fmt::Display for Ipv4Addr {
  *
  */
 
+#[deprecated(
+    since = "0.24.0",
+    note = "Use std::net::Ipv6Addr instead"
+)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[repr(transparent)]
 pub struct Ipv6Addr(pub libc::in6_addr);
 
 // Note that IPv6 addresses are stored in big endian order on all architectures.
@@ -487,6 +709,8 @@ macro_rules! to_u16_array {
     }
 }
 
+#[allow(deprecated)]
+#[allow(missing_docs)]  // Since they're all deprecated anyway
 impl Ipv6Addr {
     #[allow(clippy::many_single_char_names)]
     #[allow(clippy::too_many_arguments)]
@@ -510,18 +734,30 @@ impl Ipv6Addr {
     }
 }
 
+#[allow(deprecated)]
 impl fmt::Display for Ipv6Addr {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         self.to_std().fmt(fmt)
     }
 }
+}
 
 /// A wrapper around `sockaddr_un`.
 #[derive(Clone, Copy, Debug)]
+#[repr(C)]
 pub struct UnixAddr {
-    // INVARIANT: sun & path_len are valid as defined by docs for from_raw_parts
+    // INVARIANT: sun & sun_len are valid as defined by docs for from_raw_parts
     sun: libc::sockaddr_un,
-    path_len: usize,
+    /// The length of the valid part of `sun`, including the sun_family field
+    /// but excluding any trailing nul.
+    // On the BSDs, this field is built into sun
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux"
+    ))]
+    sun_len: u8,
 }
 
 // linux man page unix(7) says there are 3 kinds of unix socket:
@@ -538,97 +774,164 @@ enum UnixAddrKind<'a> {
     Abstract(&'a [u8]),
 }
 impl<'a> UnixAddrKind<'a> {
-    /// Safety: sun & path_len must be valid
-    unsafe fn get(sun: &'a libc::sockaddr_un, path_len: usize) -> Self {
+    /// Safety: sun & sun_len must be valid
+    unsafe fn get(sun: &'a libc::sockaddr_un, sun_len: u8) -> Self {
+        assert!(sun_len as usize >= offset_of!(libc::sockaddr_un, sun_path));
+        let path_len =
+            sun_len as usize - offset_of!(libc::sockaddr_un, sun_path);
         if path_len == 0 {
             return Self::Unnamed;
         }
         #[cfg(any(target_os = "android", target_os = "linux"))]
         if sun.sun_path[0] == 0 {
-            let name =
-                slice::from_raw_parts(sun.sun_path.as_ptr().add(1) as *const u8, path_len - 1);
+            let name = slice::from_raw_parts(
+                sun.sun_path.as_ptr().add(1) as *const u8,
+                path_len - 1,
+            );
             return Self::Abstract(name);
         }
-        let pathname = slice::from_raw_parts(sun.sun_path.as_ptr() as *const u8, path_len - 1);
-        Self::Pathname(Path::new(OsStr::from_bytes(pathname)))
+        let pathname =
+            slice::from_raw_parts(sun.sun_path.as_ptr() as *const u8, path_len);
+        if pathname.last() == Some(&0) {
+            // A trailing NUL is not considered part of the path, and it does
+            // not need to be included in the addrlen passed to functions like
+            // bind().  However, Linux adds a trailing NUL, even if one was not
+            // originally present, when returning addrs from functions like
+            // getsockname() (the BSDs do not do that).  So we need to filter
+            // out any trailing NUL here, so sockaddrs can round-trip through
+            // the kernel and still compare equal.
+            Self::Pathname(Path::new(OsStr::from_bytes(
+                &pathname[0..pathname.len() - 1],
+            )))
+        } else {
+            Self::Pathname(Path::new(OsStr::from_bytes(pathname)))
+        }
     }
 }
 
 impl UnixAddr {
     /// Create a new sockaddr_un representing a filesystem path.
     pub fn new<P: ?Sized + NixPath>(path: &P) -> Result<UnixAddr> {
-        path.with_nix_path(|cstr| {
-            unsafe {
-                let mut ret = libc::sockaddr_un {
-                    sun_family: AddressFamily::Unix as sa_family_t,
-                    .. mem::zeroed()
-                };
+        path.with_nix_path(|cstr| unsafe {
+            let mut ret = libc::sockaddr_un {
+                sun_family: AddressFamily::Unix as sa_family_t,
+                ..mem::zeroed()
+            };
 
-                let bytes = cstr.to_bytes();
+            let bytes = cstr.to_bytes();
 
-                if bytes.len() >= ret.sun_path.len() {
-                    return Err(Errno::ENAMETOOLONG);
-                }
-
-                ptr::copy_nonoverlapping(bytes.as_ptr(),
-                                         ret.sun_path.as_mut_ptr() as *mut u8,
-                                         bytes.len());
+            if bytes.len() >= ret.sun_path.len() {
+                return Err(Errno::ENAMETOOLONG);
+            }
 
-                Ok(UnixAddr::from_raw_parts(ret, bytes.len() + 1))
+            let sun_len = (bytes.len()
+                + offset_of!(libc::sockaddr_un, sun_path))
+            .try_into()
+            .unwrap();
+
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ))]
+            {
+                ret.sun_len = sun_len;
             }
+            ptr::copy_nonoverlapping(
+                bytes.as_ptr(),
+                ret.sun_path.as_mut_ptr() as *mut u8,
+                bytes.len(),
+            );
+
+            Ok(UnixAddr::from_raw_parts(ret, sun_len))
         })?
     }
 
     /// Create a new `sockaddr_un` representing an address in the "abstract namespace".
     ///
-    /// The leading null byte for the abstract namespace is automatically added;
-    /// thus the input `path` is expected to be the bare name, not null-prefixed.
+    /// The leading nul byte for the abstract namespace is automatically added;
+    /// thus the input `path` is expected to be the bare name, not NUL-prefixed.
     /// This is a Linux-specific extension, primarily used to allow chrooted
     /// processes to communicate with processes having a different filesystem view.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn new_abstract(path: &[u8]) -> Result<UnixAddr> {
         unsafe {
             let mut ret = libc::sockaddr_un {
                 sun_family: AddressFamily::Unix as sa_family_t,
-                .. mem::zeroed()
+                ..mem::zeroed()
             };
 
             if path.len() >= ret.sun_path.len() {
                 return Err(Errno::ENAMETOOLONG);
             }
+            let sun_len =
+                (path.len() + 1 + offset_of!(libc::sockaddr_un, sun_path))
+                    .try_into()
+                    .unwrap();
 
             // Abstract addresses are represented by sun_path[0] ==
             // b'\0', so copy starting one byte in.
-            ptr::copy_nonoverlapping(path.as_ptr(),
-                                     ret.sun_path.as_mut_ptr().offset(1) as *mut u8,
-                                     path.len());
+            ptr::copy_nonoverlapping(
+                path.as_ptr(),
+                ret.sun_path.as_mut_ptr().offset(1) as *mut u8,
+                path.len(),
+            );
 
-            Ok(UnixAddr::from_raw_parts(ret, path.len() + 1))
+            Ok(UnixAddr::from_raw_parts(ret, sun_len))
         }
     }
 
-    /// Create a UnixAddr from a raw `sockaddr_un` struct and a size. `path_len` is the "addrlen"
-    /// of this address, but minus `offsetof(struct sockaddr_un, sun_path)`. Basically the length
-    /// of the data in `sun_path`.
+    /// Create a new `sockaddr_un` representing an "unnamed" unix socket address.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn new_unnamed() -> UnixAddr {
+        let ret = libc::sockaddr_un {
+            sun_family: AddressFamily::Unix as sa_family_t,
+            .. unsafe { mem::zeroed() }
+        };
+
+        let sun_len: u8 = offset_of!(libc::sockaddr_un, sun_path).try_into().unwrap();
+
+        unsafe { UnixAddr::from_raw_parts(ret, sun_len) }
+    }
+
+    /// Create a UnixAddr from a raw `sockaddr_un` struct and a size. `sun_len`
+    /// is the size of the valid portion of the struct, excluding any trailing
+    /// NUL.
     ///
     /// # Safety
-    /// This pair of sockaddr_un & path_len must be a valid unix addr, which means:
-    /// - path_len <= sockaddr_un.sun_path.len()
-    /// - if this is a unix addr with a pathname, sun.sun_path is a nul-terminated fs path and
-    ///   sun.sun_path[path_len - 1] == 0 || sun.sun_path[path_len] == 0
-    pub(crate) unsafe fn from_raw_parts(sun: libc::sockaddr_un, mut path_len: usize) -> UnixAddr {
-        if let UnixAddrKind::Pathname(_) = UnixAddrKind::get(&sun, path_len) {
-            if sun.sun_path[path_len - 1] != 0 {
-                assert_eq!(sun.sun_path[path_len], 0);
-                path_len += 1
+    /// This pair of sockaddr_un & sun_len must be a valid unix addr, which
+    /// means:
+    /// - sun_len >= offset_of(sockaddr_un, sun_path)
+    /// - sun_len <= sockaddr_un.sun_path.len() - offset_of(sockaddr_un, sun_path)
+    /// - if this is a unix addr with a pathname, sun.sun_path is a
+    ///   fs path, not necessarily nul-terminated.
+    pub(crate) unsafe fn from_raw_parts(
+        sun: libc::sockaddr_un,
+        sun_len: u8,
+    ) -> UnixAddr {
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                     target_os = "fuchsia",
+                     target_os = "illumos",
+                     target_os = "linux"
+                ))]
+            {
+                UnixAddr { sun, sun_len }
+            } else {
+                assert_eq!(sun_len, sun.sun_len);
+                UnixAddr {sun}
             }
         }
-        UnixAddr { sun, path_len }
     }
 
     fn kind(&self) -> UnixAddrKind<'_> {
         // SAFETY: our sockaddr is always valid because of the invariant on the struct
-        unsafe { UnixAddrKind::get(&self.sun, self.path_len) }
+        unsafe { UnixAddrKind::get(&self.sun, self.sun_len()) }
     }
 
     /// If this address represents a filesystem path, return that path.
@@ -642,8 +945,9 @@ impl UnixAddr {
     /// If this address represents an abstract socket, return its name.
     ///
     /// For abstract sockets only the bare name is returned, without the
-    /// leading null byte. `None` is returned for unnamed or path-backed sockets.
+    /// leading NUL byte. `None` is returned for unnamed or path-backed sockets.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn as_abstract(&self) -> Option<&[u8]> {
         match self.kind() {
             UnixAddrKind::Abstract(name) => Some(name),
@@ -651,10 +955,18 @@ impl UnixAddr {
         }
     }
 
+    /// Check if this address is an "unnamed" unix socket address.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    #[inline]
+    pub fn is_unnamed(&self) -> bool {
+        matches!(self.kind(), UnixAddrKind::Unnamed)
+    }
+
     /// Returns the addrlen of this socket - `offsetof(struct sockaddr_un, sun_path)`
     #[inline]
     pub fn path_len(&self) -> usize {
-        self.path_len
+        self.sun_len() as usize - offset_of!(libc::sockaddr_un, sun_path)
     }
     /// Returns a pointer to the raw `sockaddr_un` struct
     #[inline]
@@ -666,6 +978,83 @@ impl UnixAddr {
     pub fn as_mut_ptr(&mut self) -> *mut libc::sockaddr_un {
         &mut self.sun
     }
+
+    fn sun_len(&self) -> u8 {
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                     target_os = "fuchsia",
+                     target_os = "illumos",
+                     target_os = "linux"
+                ))]
+            {
+                self.sun_len
+            } else {
+                self.sun.sun_len
+            }
+        }
+    }
+}
+
+impl private::SockaddrLikePriv for UnixAddr {}
+impl SockaddrLike for UnixAddr {
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux"
+    ))]
+    fn len(&self) -> libc::socklen_t {
+        self.sun_len.into()
+    }
+
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        len: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        if let Some(l) = len {
+            if (l as usize) < offset_of!(libc::sockaddr_un, sun_path)
+                || l > u8::MAX as libc::socklen_t
+            {
+                return None;
+            }
+        }
+        if (*addr).sa_family as i32 != libc::AF_UNIX {
+            return None;
+        }
+        let mut su: libc::sockaddr_un = mem::zeroed();
+        let sup = &mut su as *mut libc::sockaddr_un as *mut u8;
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                         target_os = "fuchsia",
+                         target_os = "illumos",
+                         target_os = "linux"
+                ))] {
+                let su_len = len.unwrap_or(
+                    mem::size_of::<libc::sockaddr_un>() as libc::socklen_t
+                );
+            } else {
+                let su_len = len.unwrap_or((*addr).sa_len as libc::socklen_t);
+            }
+        };
+        ptr::copy(addr as *const u8, sup, su_len as usize);
+        Some(Self::from_raw_parts(su, su_len as u8))
+    }
+
+    fn size() -> libc::socklen_t
+    where
+        Self: Sized,
+    {
+        mem::size_of::<libc::sockaddr_un>() as libc::socklen_t
+    }
+}
+
+impl AsRef<libc::sockaddr_un> for UnixAddr {
+    fn as_ref(&self) -> &libc::sockaddr_un {
+        &self.sun
+    }
 }
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -705,82 +1094,1004 @@ impl Hash for UnixAddr {
     }
 }
 
+/// Anything that, in C, can be cast back and forth to `sockaddr`.
+///
+/// Most implementors also implement `AsRef<libc::XXX>` to access their
+/// inner type read-only.
+#[allow(clippy::len_without_is_empty)]
+pub trait SockaddrLike: private::SockaddrLikePriv {
+    /// Returns a raw pointer to the inner structure.  Useful for FFI.
+    fn as_ptr(&self) -> *const libc::sockaddr {
+        self as *const Self as *const libc::sockaddr
+    }
+
+    /// Unsafe constructor from a variable length source
+    ///
+    /// Some C APIs from provide `len`, and others do not.  If it's provided it
+    /// will be validated.  If not, it will be guessed based on the family.
+    ///
+    /// # Arguments
+    ///
+    /// - `addr`:   raw pointer to something that can be cast to a
+    ///             `libc::sockaddr`. For example, `libc::sockaddr_in`,
+    ///             `libc::sockaddr_in6`, etc.
+    /// - `len`:    For fixed-width types like `sockaddr_in`, it will be
+    ///             validated if present and ignored if not.  For variable-width
+    ///             types it is required and must be the total length of valid
+    ///             data.  For example, if `addr` points to a
+    ///             named `sockaddr_un`, then `len` must be the length of the
+    ///             structure up to but not including the trailing NUL.
+    ///
+    /// # Safety
+    ///
+    /// `addr` must be valid for the specific type of sockaddr.  `len`, if
+    /// present, must not exceed the length of valid data in `addr`.
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        len: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized;
+
+    /// Return the address family of this socket
+    ///
+    /// # Examples
+    /// One common use is to match on the family of a union type, like this:
+    /// ```
+    /// # use nix::sys::socket::*;
+    /// let fd = socket(AddressFamily::Inet, SockType::Stream,
+    ///     SockFlag::empty(), None).unwrap();
+    /// let ss: SockaddrStorage = getsockname(fd).unwrap();
+    /// match ss.family().unwrap() {
+    ///     AddressFamily::Inet => println!("{}", ss.as_sockaddr_in().unwrap()),
+    ///     AddressFamily::Inet6 => println!("{}", ss.as_sockaddr_in6().unwrap()),
+    ///     _ => println!("Unexpected address family")
+    /// }
+    /// ```
+    fn family(&self) -> Option<AddressFamily> {
+        // Safe since all implementors have a sa_family field at the same
+        // address, and they're all repr(C)
+        AddressFamily::from_i32(unsafe {
+            (*(self as *const Self as *const libc::sockaddr)).sa_family as i32
+        })
+    }
+
+    cfg_if! {
+        if #[cfg(any(target_os = "dragonfly",
+                  target_os = "freebsd",
+                  target_os = "ios",
+                  target_os = "macos",
+                  target_os = "netbsd",
+                  target_os = "openbsd"))] {
+            /// Return the length of valid data in the sockaddr structure.
+            ///
+            /// For fixed-size sockaddrs, this should be the size of the
+            /// structure.  But for variable-sized types like [`UnixAddr`] it
+            /// may be less.
+            fn len(&self) -> libc::socklen_t {
+                // Safe since all implementors have a sa_len field at the same
+                // address, and they're all repr(transparent).
+                // Robust for all implementors.
+                unsafe {
+                    (*(self as *const Self as *const libc::sockaddr)).sa_len
+                }.into()
+            }
+        } else {
+            /// Return the length of valid data in the sockaddr structure.
+            ///
+            /// For fixed-size sockaddrs, this should be the size of the
+            /// structure.  But for variable-sized types like [`UnixAddr`] it
+            /// may be less.
+            fn len(&self) -> libc::socklen_t {
+                // No robust default implementation is possible without an
+                // sa_len field.  Implementors with a variable size must
+                // override this method.
+                mem::size_of_val(self) as libc::socklen_t
+            }
+        }
+    }
+
+    /// Return the available space in the structure
+    fn size() -> libc::socklen_t
+    where
+        Self: Sized,
+    {
+        mem::size_of::<Self>() as libc::socklen_t
+    }
+}
+
+impl private::SockaddrLikePriv for () {
+    fn as_mut_ptr(&mut self) -> *mut libc::sockaddr {
+        ptr::null_mut()
+    }
+}
+
+/// `()` can be used in place of a real Sockaddr when no address is expected,
+/// for example for a field of `Option<S> where S: SockaddrLike`.
+// If this RFC ever stabilizes, then ! will be a better choice.
+// https://github.com/rust-lang/rust/issues/35121
+impl SockaddrLike for () {
+    fn as_ptr(&self) -> *const libc::sockaddr {
+        ptr::null()
+    }
+
+    unsafe fn from_raw(
+        _: *const libc::sockaddr,
+        _: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        None
+    }
+
+    fn family(&self) -> Option<AddressFamily> {
+        None
+    }
+
+    fn len(&self) -> libc::socklen_t {
+        0
+    }
+}
+
+/// An IPv4 socket address
+// This is identical to net::SocketAddrV4.  But the standard library
+// doesn't allow direct access to the libc fields, which we need.  So we
+// reimplement it here.
+#[cfg(feature = "net")]
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct SockaddrIn(libc::sockaddr_in);
+
+#[cfg(feature = "net")]
+impl SockaddrIn {
+    /// Returns the IP address associated with this socket address, in native
+    /// endian.
+    pub const fn ip(&self) -> libc::in_addr_t {
+        u32::from_be(self.0.sin_addr.s_addr)
+    }
+
+    /// Creates a new socket address from IPv4 octets and a port number.
+    pub fn new(a: u8, b: u8, c: u8, d: u8, port: u16) -> Self {
+        Self(libc::sockaddr_in {
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "haiku",
+                target_os = "openbsd"
+            ))]
+            sin_len: Self::size() as u8,
+            sin_family: AddressFamily::Inet as sa_family_t,
+            sin_port: u16::to_be(port),
+            sin_addr: libc::in_addr {
+                s_addr: u32::from_ne_bytes([a, b, c, d]),
+            },
+            sin_zero: unsafe { mem::zeroed() },
+        })
+    }
+
+    /// Returns the port number associated with this socket address, in native
+    /// endian.
+    pub const fn port(&self) -> u16 {
+        u16::from_be(self.0.sin_port)
+    }
+}
+
+#[cfg(feature = "net")]
+impl private::SockaddrLikePriv for SockaddrIn {}
+#[cfg(feature = "net")]
+impl SockaddrLike for SockaddrIn {
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        len: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        if let Some(l) = len {
+            if l != mem::size_of::<libc::sockaddr_in>() as libc::socklen_t {
+                return None;
+            }
+        }
+        if (*addr).sa_family as i32 != libc::AF_INET {
+            return None;
+        }
+        Some(Self(ptr::read_unaligned(addr as *const _)))
+    }
+}
+
+#[cfg(feature = "net")]
+impl AsRef<libc::sockaddr_in> for SockaddrIn {
+    fn as_ref(&self) -> &libc::sockaddr_in {
+        &self.0
+    }
+}
+
+#[cfg(feature = "net")]
+impl fmt::Display for SockaddrIn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let ne = u32::from_be(self.0.sin_addr.s_addr);
+        let port = u16::from_be(self.0.sin_port);
+        write!(
+            f,
+            "{}.{}.{}.{}:{}",
+            ne >> 24,
+            (ne >> 16) & 0xFF,
+            (ne >> 8) & 0xFF,
+            ne & 0xFF,
+            port
+        )
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<net::SocketAddrV4> for SockaddrIn {
+    fn from(addr: net::SocketAddrV4) -> Self {
+        Self(libc::sockaddr_in {
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "haiku",
+                target_os = "hermit",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ))]
+            sin_len: mem::size_of::<libc::sockaddr_in>() as u8,
+            sin_family: AddressFamily::Inet as sa_family_t,
+            sin_port: addr.port().to_be(), // network byte order
+            sin_addr: ipv4addr_to_libc(*addr.ip()),
+            ..unsafe { mem::zeroed() }
+        })
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<SockaddrIn> for net::SocketAddrV4 {
+    fn from(addr: SockaddrIn) -> Self {
+        net::SocketAddrV4::new(
+            net::Ipv4Addr::from(addr.0.sin_addr.s_addr.to_ne_bytes()),
+            u16::from_be(addr.0.sin_port),
+        )
+    }
+}
+
+#[cfg(feature = "net")]
+impl std::str::FromStr for SockaddrIn {
+    type Err = net::AddrParseError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        net::SocketAddrV4::from_str(s).map(SockaddrIn::from)
+    }
+}
+
+/// An IPv6 socket address
+#[cfg(feature = "net")]
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct SockaddrIn6(libc::sockaddr_in6);
+
+#[cfg(feature = "net")]
+impl SockaddrIn6 {
+    /// Returns the flow information associated with this address.
+    pub const fn flowinfo(&self) -> u32 {
+        self.0.sin6_flowinfo
+    }
+
+    /// Returns the IP address associated with this socket address.
+    pub fn ip(&self) -> net::Ipv6Addr {
+        net::Ipv6Addr::from(self.0.sin6_addr.s6_addr)
+    }
+
+    /// Returns the port number associated with this socket address, in native
+    /// endian.
+    pub const fn port(&self) -> u16 {
+        u16::from_be(self.0.sin6_port)
+    }
+
+    /// Returns the scope ID associated with this address.
+    pub const fn scope_id(&self) -> u32 {
+        self.0.sin6_scope_id
+    }
+}
+
+#[cfg(feature = "net")]
+impl private::SockaddrLikePriv for SockaddrIn6 {}
+#[cfg(feature = "net")]
+impl SockaddrLike for SockaddrIn6 {
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        len: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        if let Some(l) = len {
+            if l != mem::size_of::<libc::sockaddr_in6>() as libc::socklen_t {
+                return None;
+            }
+        }
+        if (*addr).sa_family as i32 != libc::AF_INET6 {
+            return None;
+        }
+        Some(Self(ptr::read_unaligned(addr as *const _)))
+    }
+}
+
+#[cfg(feature = "net")]
+impl AsRef<libc::sockaddr_in6> for SockaddrIn6 {
+    fn as_ref(&self) -> &libc::sockaddr_in6 {
+        &self.0
+    }
+}
+
+#[cfg(feature = "net")]
+impl fmt::Display for SockaddrIn6 {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // These things are really hard to display properly.  Easier to let std
+        // do it.
+        let std = net::SocketAddrV6::new(
+            self.ip(),
+            self.port(),
+            self.flowinfo(),
+            self.scope_id(),
+        );
+        std.fmt(f)
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<net::SocketAddrV6> for SockaddrIn6 {
+    fn from(addr: net::SocketAddrV6) -> Self {
+        #[allow(clippy::needless_update)] // It isn't needless on Illumos
+        Self(libc::sockaddr_in6 {
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "haiku",
+                target_os = "hermit",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ))]
+            sin6_len: mem::size_of::<libc::sockaddr_in6>() as u8,
+            sin6_family: AddressFamily::Inet6 as sa_family_t,
+            sin6_port: addr.port().to_be(), // network byte order
+            sin6_addr: ipv6addr_to_libc(addr.ip()),
+            sin6_flowinfo: addr.flowinfo(), // host byte order
+            sin6_scope_id: addr.scope_id(), // host byte order
+            ..unsafe { mem::zeroed() }
+        })
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<SockaddrIn6> for net::SocketAddrV6 {
+    fn from(addr: SockaddrIn6) -> Self {
+        net::SocketAddrV6::new(
+            net::Ipv6Addr::from(addr.0.sin6_addr.s6_addr),
+            u16::from_be(addr.0.sin6_port),
+            addr.0.sin6_flowinfo,
+            addr.0.sin6_scope_id,
+        )
+    }
+}
+
+#[cfg(feature = "net")]
+impl std::str::FromStr for SockaddrIn6 {
+    type Err = net::AddrParseError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        net::SocketAddrV6::from_str(s).map(SockaddrIn6::from)
+    }
+}
+
+/// A container for any sockaddr type
+///
+/// Just like C's `sockaddr_storage`, this type is large enough to hold any type
+/// of sockaddr.  It can be used as an argument with functions like
+/// [`bind`](super::bind) and [`getsockname`](super::getsockname).  Though it is
+/// a union, it can be safely accessed through the `as_*` methods.
+///
+/// # Example
+/// ```
+/// # use nix::sys::socket::*;
+/// # use std::str::FromStr;
+/// let localhost = SockaddrIn::from_str("127.0.0.1:8081").unwrap();
+/// let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(),
+///     None).unwrap();
+/// bind(fd, &localhost).expect("bind");
+/// let ss: SockaddrStorage = getsockname(fd).expect("getsockname");
+/// assert_eq!(&localhost, ss.as_sockaddr_in().unwrap());
+/// ```
+#[derive(Clone, Copy, Eq)]
+#[repr(C)]
+pub union SockaddrStorage {
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    alg: AlgAddr,
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    dl: LinkAddr,
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    nl: NetlinkAddr,
+    #[cfg(all(
+        feature = "ioctl",
+        any(target_os = "ios", target_os = "macos")
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "ioctl")))]
+    sctl: SysControlAddr,
+    #[cfg(feature = "net")]
+    sin: SockaddrIn,
+    #[cfg(feature = "net")]
+    sin6: SockaddrIn6,
+    ss: libc::sockaddr_storage,
+    su: UnixAddr,
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    vsock: VsockAddr,
+}
+impl private::SockaddrLikePriv for SockaddrStorage {}
+impl SockaddrLike for SockaddrStorage {
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        l: Option<libc::socklen_t>,
+    ) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        if addr.is_null() {
+            return None;
+        }
+        if let Some(len) = l {
+            let ulen = len as usize;
+            if ulen < offset_of!(libc::sockaddr, sa_data)
+                || ulen > mem::size_of::<libc::sockaddr_storage>()
+            {
+                None
+            } else {
+                let mut ss: libc::sockaddr_storage = mem::zeroed();
+                let ssp = &mut ss as *mut libc::sockaddr_storage as *mut u8;
+                ptr::copy(addr as *const u8, ssp, len as usize);
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "fuchsia",
+                    target_os = "illumos",
+                    target_os = "linux"
+                ))]
+                if i32::from(ss.ss_family) == libc::AF_UNIX {
+                    // Safe because we UnixAddr is strictly smaller than
+                    // SockaddrStorage, and we just initialized the structure.
+                    (*(&mut ss as *mut libc::sockaddr_storage as *mut UnixAddr)).sun_len = len as u8;
+                }
+                Some(Self { ss })
+            }
+        } else {
+            // If length is not available and addr is of a fixed-length type,
+            // copy it.  If addr is of a variable length type and len is not
+            // available, then there's nothing we can do.
+            match (*addr).sa_family as i32 {
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_ALG => {
+                    AlgAddr::from_raw(addr, l).map(|alg| Self { alg })
+                }
+                #[cfg(feature = "net")]
+                libc::AF_INET => {
+                    SockaddrIn::from_raw(addr, l).map(|sin| Self { sin })
+                }
+                #[cfg(feature = "net")]
+                libc::AF_INET6 => {
+                    SockaddrIn6::from_raw(addr, l).map(|sin6| Self { sin6 })
+                }
+                #[cfg(any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "illumos",
+                    target_os = "netbsd",
+                    target_os = "haiku",
+                    target_os = "openbsd"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_LINK => {
+                    LinkAddr::from_raw(addr, l).map(|dl| Self { dl })
+                }
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_NETLINK => {
+                    NetlinkAddr::from_raw(addr, l).map(|nl| Self { nl })
+                }
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "fuchsia",
+                    target_os = "linux"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_PACKET => {
+                    LinkAddr::from_raw(addr, l).map(|dl| Self { dl })
+                }
+                #[cfg(all(
+                    feature = "ioctl",
+                    any(target_os = "ios", target_os = "macos")
+                ))]
+                libc::AF_SYSTEM => {
+                    SysControlAddr::from_raw(addr, l).map(|sctl| Self { sctl })
+                }
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_VSOCK => {
+                    VsockAddr::from_raw(addr, l).map(|vsock| Self { vsock })
+                }
+                _ => None,
+            }
+        }
+    }
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "illumos",
+        target_os = "linux"
+    ))]
+    fn len(&self) -> libc::socklen_t {
+        match self.as_unix_addr() {
+            // The UnixAddr type knows its own length
+            Some(ua) => ua.len(),
+            // For all else, we're just a boring SockaddrStorage
+            None => mem::size_of_val(self) as libc::socklen_t
+        }
+    }
+}
+
+macro_rules! accessors {
+    (
+        $fname:ident,
+        $fname_mut:ident,
+        $sockty:ty,
+        $family:expr,
+        $libc_ty:ty,
+        $field:ident) => {
+        /// Safely and falliably downcast to an immutable reference
+        pub fn $fname(&self) -> Option<&$sockty> {
+            if self.family() == Some($family)
+                && self.len() >= mem::size_of::<$libc_ty>() as libc::socklen_t
+            {
+                // Safe because family and len are validated
+                Some(unsafe { &self.$field })
+            } else {
+                None
+            }
+        }
+
+        /// Safely and falliably downcast to a mutable reference
+        pub fn $fname_mut(&mut self) -> Option<&mut $sockty> {
+            if self.family() == Some($family)
+                && self.len() >= mem::size_of::<$libc_ty>() as libc::socklen_t
+            {
+                // Safe because family and len are validated
+                Some(unsafe { &mut self.$field })
+            } else {
+                None
+            }
+        }
+    };
+}
+
+impl SockaddrStorage {
+    /// Downcast to an immutable `[UnixAddr]` reference.
+    pub fn as_unix_addr(&self) -> Option<&UnixAddr> {
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                     target_os = "fuchsia",
+                     target_os = "illumos",
+                     target_os = "linux"
+                ))]
+            {
+                let p = unsafe{ &self.ss as *const libc::sockaddr_storage };
+                // Safe because UnixAddr is strictly smaller than
+                // sockaddr_storage, and we're fully initialized
+                let len = unsafe {
+                    (*(p as *const UnixAddr )).sun_len as usize
+                };
+            } else {
+                let len = self.len() as usize;
+            }
+        }
+        // Sanity checks
+        if self.family() != Some(AddressFamily::Unix) ||
+           len < offset_of!(libc::sockaddr_un, sun_path) ||
+           len > mem::size_of::<libc::sockaddr_un>() {
+            None
+        } else {
+            Some(unsafe{&self.su})
+        }
+    }
+
+    /// Downcast to a mutable `[UnixAddr]` reference.
+    pub fn as_unix_addr_mut(&mut self) -> Option<&mut UnixAddr> {
+        cfg_if! {
+            if #[cfg(any(target_os = "android",
+                     target_os = "fuchsia",
+                     target_os = "illumos",
+                     target_os = "linux"
+                ))]
+            {
+                let p = unsafe{ &self.ss as *const libc::sockaddr_storage };
+                // Safe because UnixAddr is strictly smaller than
+                // sockaddr_storage, and we're fully initialized
+                let len = unsafe {
+                    (*(p as *const UnixAddr )).sun_len as usize
+                };
+            } else {
+                let len = self.len() as usize;
+            }
+        }
+        // Sanity checks
+        if self.family() != Some(AddressFamily::Unix) ||
+           len < offset_of!(libc::sockaddr_un, sun_path) ||
+           len > mem::size_of::<libc::sockaddr_un>() {
+            None
+        } else {
+            Some(unsafe{&mut self.su})
+        }
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    accessors! {as_alg_addr, as_alg_addr_mut, AlgAddr,
+    AddressFamily::Alg, libc::sockaddr_alg, alg}
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "linux"
+    ))]
+    #[cfg(feature = "net")]
+    accessors! {
+    as_link_addr, as_link_addr_mut, LinkAddr,
+    AddressFamily::Packet, libc::sockaddr_ll, dl}
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "illumos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg(feature = "net")]
+    accessors! {
+    as_link_addr, as_link_addr_mut, LinkAddr,
+    AddressFamily::Link, libc::sockaddr_dl, dl}
+
+    #[cfg(feature = "net")]
+    accessors! {
+    as_sockaddr_in, as_sockaddr_in_mut, SockaddrIn,
+    AddressFamily::Inet, libc::sockaddr_in, sin}
+
+    #[cfg(feature = "net")]
+    accessors! {
+    as_sockaddr_in6, as_sockaddr_in6_mut, SockaddrIn6,
+    AddressFamily::Inet6, libc::sockaddr_in6, sin6}
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    accessors! {as_netlink_addr, as_netlink_addr_mut, NetlinkAddr,
+    AddressFamily::Netlink, libc::sockaddr_nl, nl}
+
+    #[cfg(all(feature = "ioctl", any(target_os = "ios", target_os = "macos")))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "ioctl")))]
+    accessors! {as_sys_control_addr, as_sys_control_addr_mut, SysControlAddr,
+    AddressFamily::System, libc::sockaddr_ctl, sctl}
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    accessors! {as_vsock_addr, as_vsock_addr_mut, VsockAddr,
+    AddressFamily::Vsock, libc::sockaddr_vm, vsock}
+}
+
+impl fmt::Debug for SockaddrStorage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("SockaddrStorage")
+            // Safe because sockaddr_storage has the least specific
+            // field types
+            .field("ss", unsafe { &self.ss })
+            .finish()
+    }
+}
+
+impl fmt::Display for SockaddrStorage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        unsafe {
+            match self.ss.ss_family as i32 {
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_ALG => self.alg.fmt(f),
+                #[cfg(feature = "net")]
+                libc::AF_INET => self.sin.fmt(f),
+                #[cfg(feature = "net")]
+                libc::AF_INET6 => self.sin6.fmt(f),
+                #[cfg(any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "illumos",
+                    target_os = "netbsd",
+                    target_os = "openbsd"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_LINK => self.dl.fmt(f),
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_NETLINK => self.nl.fmt(f),
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "linux",
+                    target_os = "fuchsia"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_PACKET => self.dl.fmt(f),
+                #[cfg(any(target_os = "ios", target_os = "macos"))]
+                #[cfg(feature = "ioctl")]
+                libc::AF_SYSTEM => self.sctl.fmt(f),
+                libc::AF_UNIX => self.su.fmt(f),
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_VSOCK => self.vsock.fmt(f),
+                _ => "<Address family unspecified>".fmt(f),
+            }
+        }
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<net::SocketAddrV4> for SockaddrStorage {
+    fn from(s: net::SocketAddrV4) -> Self {
+        unsafe {
+            let mut ss: Self = mem::zeroed();
+            ss.sin = SockaddrIn::from(s);
+            ss
+        }
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<net::SocketAddrV6> for SockaddrStorage {
+    fn from(s: net::SocketAddrV6) -> Self {
+        unsafe {
+            let mut ss: Self = mem::zeroed();
+            ss.sin6 = SockaddrIn6::from(s);
+            ss
+        }
+    }
+}
+
+#[cfg(feature = "net")]
+impl From<net::SocketAddr> for SockaddrStorage {
+    fn from(s: net::SocketAddr) -> Self {
+        match s {
+            net::SocketAddr::V4(sa4) => Self::from(sa4),
+            net::SocketAddr::V6(sa6) => Self::from(sa6),
+        }
+    }
+}
+
+impl Hash for SockaddrStorage {
+    fn hash<H: Hasher>(&self, s: &mut H) {
+        unsafe {
+            match self.ss.ss_family as i32 {
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_ALG => self.alg.hash(s),
+                #[cfg(feature = "net")]
+                libc::AF_INET => self.sin.hash(s),
+                #[cfg(feature = "net")]
+                libc::AF_INET6 => self.sin6.hash(s),
+                #[cfg(any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "illumos",
+                    target_os = "netbsd",
+                    target_os = "openbsd"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_LINK => self.dl.hash(s),
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_NETLINK => self.nl.hash(s),
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "linux",
+                    target_os = "fuchsia"
+                ))]
+                #[cfg(feature = "net")]
+                libc::AF_PACKET => self.dl.hash(s),
+                #[cfg(any(target_os = "ios", target_os = "macos"))]
+                #[cfg(feature = "ioctl")]
+                libc::AF_SYSTEM => self.sctl.hash(s),
+                libc::AF_UNIX => self.su.hash(s),
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                libc::AF_VSOCK => self.vsock.hash(s),
+                _ => self.ss.hash(s),
+            }
+        }
+    }
+}
+
+impl PartialEq for SockaddrStorage {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe {
+            match (self.ss.ss_family as i32, other.ss.ss_family as i32) {
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                (libc::AF_ALG, libc::AF_ALG) => self.alg == other.alg,
+                #[cfg(feature = "net")]
+                (libc::AF_INET, libc::AF_INET) => self.sin == other.sin,
+                #[cfg(feature = "net")]
+                (libc::AF_INET6, libc::AF_INET6) => self.sin6 == other.sin6,
+                #[cfg(any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "illumos",
+                    target_os = "netbsd",
+                    target_os = "openbsd"
+                ))]
+                #[cfg(feature = "net")]
+                (libc::AF_LINK, libc::AF_LINK) => self.dl == other.dl,
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                (libc::AF_NETLINK, libc::AF_NETLINK) => self.nl == other.nl,
+                #[cfg(any(
+                    target_os = "android",
+                    target_os = "fuchsia",
+                    target_os = "linux"
+                ))]
+                #[cfg(feature = "net")]
+                (libc::AF_PACKET, libc::AF_PACKET) => self.dl == other.dl,
+                #[cfg(any(target_os = "ios", target_os = "macos"))]
+                #[cfg(feature = "ioctl")]
+                (libc::AF_SYSTEM, libc::AF_SYSTEM) => self.sctl == other.sctl,
+                (libc::AF_UNIX, libc::AF_UNIX) => self.su == other.su,
+                #[cfg(any(target_os = "android", target_os = "linux"))]
+                (libc::AF_VSOCK, libc::AF_VSOCK) => self.vsock == other.vsock,
+                _ => false,
+            }
+        }
+    }
+}
+
+mod private {
+    pub trait SockaddrLikePriv {
+        /// Returns a mutable raw pointer to the inner structure.
+        ///
+        /// # Safety
+        ///
+        /// This method is technically safe, but modifying the inner structure's
+        /// `family` or `len` fields may result in violating Nix's invariants.
+        /// It is best to use this method only with foreign functions that do
+        /// not change the sockaddr type.
+        fn as_mut_ptr(&mut self) -> *mut libc::sockaddr {
+            self as *mut Self as *mut libc::sockaddr
+        }
+    }
+}
+
 /// Represents a socket address
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[deprecated(
+    since = "0.24.0",
+    note = "use SockaddrLike or SockaddrStorage instead"
+)]
+#[allow(missing_docs)] // Since they're all deprecated anyway
+#[allow(deprecated)]
 #[non_exhaustive]
 pub enum SockAddr {
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Inet(InetAddr),
     Unix(UnixAddr),
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Netlink(NetlinkAddr),
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Alg(AlgAddr),
-    #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg(all(
+        feature = "ioctl",
+        any(target_os = "ios", target_os = "macos")
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "ioctl")))]
     SysControl(SysControlAddr),
     /// Datalink address (MAC)
-    #[cfg(any(target_os = "android",
-              target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "linux",
-              target_os = "macos",
-              target_os = "illumos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "ios",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "illumos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Link(LinkAddr),
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     Vsock(VsockAddr),
 }
 
+#[allow(missing_docs)] // Since they're all deprecated anyway
+#[allow(deprecated)]
 impl SockAddr {
+    feature! {
+    #![feature = "net"]
     pub fn new_inet(addr: InetAddr) -> SockAddr {
         SockAddr::Inet(addr)
     }
+    }
 
     pub fn new_unix<P: ?Sized + NixPath>(path: &P) -> Result<SockAddr> {
         Ok(SockAddr::Unix(UnixAddr::new(path)?))
     }
 
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn new_netlink(pid: u32, groups: u32) -> SockAddr {
         SockAddr::Netlink(NetlinkAddr::new(pid, groups))
     }
 
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn new_alg(alg_type: &str, alg_name: &str) -> SockAddr {
         SockAddr::Alg(AlgAddr::new(alg_type, alg_name))
     }
 
+    feature! {
+    #![feature = "ioctl"]
     #[cfg(any(target_os = "ios", target_os = "macos"))]
     pub fn new_sys_control(sockfd: RawFd, name: &str, unit: u32) -> Result<SockAddr> {
         SysControlAddr::from_name(sockfd, name, unit).map(SockAddr::SysControl)
     }
+    }
 
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn new_vsock(cid: u32, port: u32) -> SockAddr {
         SockAddr::Vsock(VsockAddr::new(cid, port))
     }
 
     pub fn family(&self) -> AddressFamily {
         match *self {
+            #[cfg(feature = "net")]
             SockAddr::Inet(InetAddr::V4(..)) => AddressFamily::Inet,
+            #[cfg(feature = "net")]
             SockAddr::Inet(InetAddr::V6(..)) => AddressFamily::Inet6,
             SockAddr::Unix(..) => AddressFamily::Unix,
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Netlink(..) => AddressFamily::Netlink,
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Alg(..) => AddressFamily::Alg,
-            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            #[cfg(all(
+                feature = "ioctl",
+                any(target_os = "ios", target_os = "macos")
+            ))]
             SockAddr::SysControl(..) => AddressFamily::System,
             #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(feature = "net")]
             SockAddr::Link(..) => AddressFamily::Packet,
-            #[cfg(any(target_os = "dragonfly",
-                      target_os = "freebsd",
-                      target_os = "ios",
-                      target_os = "macos",
-                      target_os = "netbsd",
-                      target_os = "illumos",
-                      target_os = "openbsd"))]
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "illumos",
+                target_os = "openbsd"
+            ))]
+            #[cfg(feature = "net")]
             SockAddr::Link(..) => AddressFamily::Link,
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Vsock(..) => AddressFamily::Vsock,
@@ -802,43 +2113,62 @@ impl SockAddr {
     /// unsafe because it takes a raw pointer as argument.  The caller must
     /// ensure that the pointer is valid.
     #[cfg(not(target_os = "fuchsia"))]
-    pub(crate) unsafe fn from_libc_sockaddr(addr: *const libc::sockaddr) -> Option<SockAddr> {
+    #[cfg(feature = "net")]
+    pub(crate) unsafe fn from_libc_sockaddr(
+        addr: *const libc::sockaddr,
+    ) -> Option<SockAddr> {
         if addr.is_null() {
             None
         } else {
             match AddressFamily::from_i32(i32::from((*addr).sa_family)) {
                 Some(AddressFamily::Unix) => None,
+                #[cfg(feature = "net")]
                 Some(AddressFamily::Inet) => Some(SockAddr::Inet(
-                    InetAddr::V4(*(addr as *const libc::sockaddr_in)))),
+                    InetAddr::V4(ptr::read_unaligned(addr as *const _)),
+                )),
+                #[cfg(feature = "net")]
                 Some(AddressFamily::Inet6) => Some(SockAddr::Inet(
-                    InetAddr::V6(*(addr as *const libc::sockaddr_in6)))),
+                    InetAddr::V6(ptr::read_unaligned(addr as *const _)),
+                )),
                 #[cfg(any(target_os = "android", target_os = "linux"))]
                 Some(AddressFamily::Netlink) => Some(SockAddr::Netlink(
-                    NetlinkAddr(*(addr as *const libc::sockaddr_nl)))),
-                #[cfg(any(target_os = "ios", target_os = "macos"))]
+                    NetlinkAddr(ptr::read_unaligned(addr as *const _)),
+                )),
+                #[cfg(all(
+                    feature = "ioctl",
+                    any(target_os = "ios", target_os = "macos")
+                ))]
                 Some(AddressFamily::System) => Some(SockAddr::SysControl(
-                    SysControlAddr(*(addr as *const libc::sockaddr_ctl)))),
+                    SysControlAddr(ptr::read_unaligned(addr as *const _)),
+                )),
                 #[cfg(any(target_os = "android", target_os = "linux"))]
-                Some(AddressFamily::Packet) => Some(SockAddr::Link(
-                    LinkAddr(*(addr as *const libc::sockaddr_ll)))),
-                #[cfg(any(target_os = "dragonfly",
-                          target_os = "freebsd",
-                          target_os = "ios",
-                          target_os = "macos",
-                          target_os = "netbsd",
-                          target_os = "illumos",
-                          target_os = "openbsd"))]
+                #[cfg(feature = "net")]
+                Some(AddressFamily::Packet) => Some(SockAddr::Link(LinkAddr(
+                    ptr::read_unaligned(addr as *const _),
+                ))),
+                #[cfg(any(
+                    target_os = "dragonfly",
+                    target_os = "freebsd",
+                    target_os = "ios",
+                    target_os = "macos",
+                    target_os = "netbsd",
+                    target_os = "illumos",
+                    target_os = "openbsd"
+                ))]
+                #[cfg(feature = "net")]
                 Some(AddressFamily::Link) => {
-                    let ether_addr = LinkAddr(*(addr as *const libc::sockaddr_dl));
+                    let ether_addr =
+                        LinkAddr(ptr::read_unaligned(addr as *const _));
                     if ether_addr.is_empty() {
                         None
                     } else {
                         Some(SockAddr::Link(ether_addr))
                     }
-                },
+                }
                 #[cfg(any(target_os = "android", target_os = "linux"))]
-                Some(AddressFamily::Vsock) => Some(SockAddr::Vsock(
-                    VsockAddr(*(addr as *const libc::sockaddr_vm)))),
+                Some(AddressFamily::Vsock) => Some(SockAddr::Vsock(VsockAddr(
+                    ptr::read_unaligned(addr as *const _),
+                ))),
                 // Other address families are currently not supported and simply yield a None
                 // entry instead of a proper conversion to a `SockAddr`.
                 Some(_) | None => None,
@@ -855,26 +2185,31 @@ impl SockAddr {
     /// a sockaddr * need to take the size of the underlying type as well and then internally cast it back.
     pub fn as_ffi_pair(&self) -> (&libc::sockaddr, libc::socklen_t) {
         match *self {
+            #[cfg(feature = "net")]
             SockAddr::Inet(InetAddr::V4(ref addr)) => (
                 // This cast is always allowed in C
                 unsafe {
-                    &*(addr as *const libc::sockaddr_in as *const libc::sockaddr)
+                    &*(addr as *const libc::sockaddr_in
+                        as *const libc::sockaddr)
                 },
-                mem::size_of_val(addr) as libc::socklen_t
+                mem::size_of_val(addr) as libc::socklen_t,
             ),
+            #[cfg(feature = "net")]
             SockAddr::Inet(InetAddr::V6(ref addr)) => (
                 // This cast is always allowed in C
                 unsafe {
-                    &*(addr as *const libc::sockaddr_in6 as *const libc::sockaddr)
+                    &*(addr as *const libc::sockaddr_in6
+                        as *const libc::sockaddr)
                 },
-                mem::size_of_val(addr) as libc::socklen_t
+                mem::size_of_val(addr) as libc::socklen_t,
             ),
-            SockAddr::Unix(UnixAddr { ref sun, path_len }) => (
+            SockAddr::Unix(ref unix_addr) => (
                 // This cast is always allowed in C
                 unsafe {
-                    &*(sun as *const libc::sockaddr_un as *const libc::sockaddr)
+                    &*(&unix_addr.sun as *const libc::sockaddr_un
+                        as *const libc::sockaddr)
                 },
-                (path_len + offset_of!(libc::sockaddr_un, sun_path)) as libc::socklen_t
+                unix_addr.sun_len() as libc::socklen_t,
             ),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Netlink(NetlinkAddr(ref sa)) => (
@@ -882,7 +2217,7 @@ impl SockAddr {
                 unsafe {
                     &*(sa as *const libc::sockaddr_nl as *const libc::sockaddr)
                 },
-                mem::size_of_val(sa) as libc::socklen_t
+                mem::size_of_val(sa) as libc::socklen_t,
             ),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Alg(AlgAddr(ref sa)) => (
@@ -890,38 +2225,46 @@ impl SockAddr {
                 unsafe {
                     &*(sa as *const libc::sockaddr_alg as *const libc::sockaddr)
                 },
-                mem::size_of_val(sa) as libc::socklen_t
+                mem::size_of_val(sa) as libc::socklen_t,
             ),
-            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            #[cfg(all(
+                feature = "ioctl",
+                any(target_os = "ios", target_os = "macos")
+            ))]
             SockAddr::SysControl(SysControlAddr(ref sa)) => (
                 // This cast is always allowed in C
                 unsafe {
                     &*(sa as *const libc::sockaddr_ctl as *const libc::sockaddr)
                 },
-                mem::size_of_val(sa) as libc::socklen_t
-
+                mem::size_of_val(sa) as libc::socklen_t,
             ),
             #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(feature = "net")]
             SockAddr::Link(LinkAddr(ref addr)) => (
                 // This cast is always allowed in C
                 unsafe {
-                    &*(addr as *const libc::sockaddr_ll as *const libc::sockaddr)
+                    &*(addr as *const libc::sockaddr_ll
+                        as *const libc::sockaddr)
                 },
-                mem::size_of_val(addr) as libc::socklen_t
+                mem::size_of_val(addr) as libc::socklen_t,
             ),
-            #[cfg(any(target_os = "dragonfly",
-                      target_os = "freebsd",
-                      target_os = "ios",
-                      target_os = "macos",
-                      target_os = "illumos",
-                      target_os = "netbsd",
-                      target_os = "openbsd"))]
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "illumos",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            ))]
+            #[cfg(feature = "net")]
             SockAddr::Link(LinkAddr(ref addr)) => (
                 // This cast is always allowed in C
                 unsafe {
-                    &*(addr as *const libc::sockaddr_dl as *const libc::sockaddr)
+                    &*(addr as *const libc::sockaddr_dl
+                        as *const libc::sockaddr)
                 },
-                mem::size_of_val(addr) as libc::socklen_t
+                mem::size_of_val(addr) as libc::socklen_t,
             ),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Vsock(VsockAddr(ref sa)) => (
@@ -929,32 +2272,40 @@ impl SockAddr {
                 unsafe {
                     &*(sa as *const libc::sockaddr_vm as *const libc::sockaddr)
                 },
-                mem::size_of_val(sa) as libc::socklen_t
+                mem::size_of_val(sa) as libc::socklen_t,
             ),
         }
     }
 }
 
+#[allow(deprecated)]
 impl fmt::Display for SockAddr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            #[cfg(feature = "net")]
             SockAddr::Inet(ref inet) => inet.fmt(f),
             SockAddr::Unix(ref unix) => unix.fmt(f),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Netlink(ref nl) => nl.fmt(f),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Alg(ref nl) => nl.fmt(f),
-            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            #[cfg(all(
+                feature = "ioctl",
+                any(target_os = "ios", target_os = "macos")
+            ))]
             SockAddr::SysControl(ref sc) => sc.fmt(f),
-            #[cfg(any(target_os = "android",
-                      target_os = "dragonfly",
-                      target_os = "freebsd",
-                      target_os = "ios",
-                      target_os = "linux",
-                      target_os = "macos",
-                      target_os = "netbsd",
-                      target_os = "illumos",
-                      target_os = "openbsd"))]
+            #[cfg(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "linux",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "illumos",
+                target_os = "openbsd"
+            ))]
+            #[cfg(feature = "net")]
             SockAddr::Link(ref ether_addr) => ether_addr.fmt(f),
             #[cfg(any(target_os = "android", target_os = "linux"))]
             SockAddr::Vsock(ref svm) => svm.fmt(f),
@@ -962,16 +2313,42 @@ impl fmt::Display for SockAddr {
     }
 }
 
+#[cfg(not(target_os = "fuchsia"))]
+#[cfg(feature = "net")]
+#[allow(deprecated)]
+impl private::SockaddrLikePriv for SockAddr {}
+#[cfg(not(target_os = "fuchsia"))]
+#[cfg(feature = "net")]
+#[allow(deprecated)]
+impl SockaddrLike for SockAddr {
+    unsafe fn from_raw(
+        addr: *const libc::sockaddr,
+        _len: Option<libc::socklen_t>,
+    ) -> Option<Self> {
+        Self::from_libc_sockaddr(addr)
+    }
+}
+
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub mod netlink {
+    use super::*;
     use crate::sys::socket::addr::AddressFamily;
     use libc::{sa_family_t, sockaddr_nl};
     use std::{fmt, mem};
 
+    /// Address for the Linux kernel user interface device.
+    ///
+    /// # References
+    ///
+    /// [netlink(7)](https://man7.org/linux/man-pages/man7/netlink.7.html)
     #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-    pub struct NetlinkAddr(pub sockaddr_nl);
+    #[repr(transparent)]
+    pub struct NetlinkAddr(pub(in super::super) sockaddr_nl);
 
     impl NetlinkAddr {
+        /// Construct a new socket address from its port ID and multicast groups
+        /// mask.
         pub fn new(pid: u32, groups: u32) -> NetlinkAddr {
             let mut addr: sockaddr_nl = unsafe { mem::zeroed() };
             addr.nl_family = AddressFamily::Netlink as sa_family_t;
@@ -981,15 +2358,44 @@ pub mod netlink {
             NetlinkAddr(addr)
         }
 
+        /// Return the socket's port ID.
         pub const fn pid(&self) -> u32 {
             self.0.nl_pid
         }
 
+        /// Return the socket's multicast groups mask
         pub const fn groups(&self) -> u32 {
             self.0.nl_groups
         }
     }
 
+    impl private::SockaddrLikePriv for NetlinkAddr {}
+    impl SockaddrLike for NetlinkAddr {
+        unsafe fn from_raw(
+            addr: *const libc::sockaddr,
+            len: Option<libc::socklen_t>,
+        ) -> Option<Self>
+        where
+            Self: Sized,
+        {
+            if let Some(l) = len {
+                if l != mem::size_of::<libc::sockaddr_nl>() as libc::socklen_t {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_NETLINK {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
+        }
+    }
+
+    impl AsRef<libc::sockaddr_nl> for NetlinkAddr {
+        fn as_ref(&self) -> &libc::sockaddr_nl {
+            &self.0
+        }
+    }
+
     impl fmt::Display for NetlinkAddr {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
             write!(f, "pid: {} groups: {}", self.pid(), self.groups())
@@ -998,21 +2404,64 @@ pub mod netlink {
 }
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub mod alg {
-    use libc::{AF_ALG, sockaddr_alg, c_char};
-    use std::{fmt, mem, str};
-    use std::hash::{Hash, Hasher};
+    use super::*;
+    use libc::{c_char, sockaddr_alg, AF_ALG};
     use std::ffi::CStr;
+    use std::hash::{Hash, Hasher};
+    use std::{fmt, mem, str};
 
+    /// Socket address for the Linux kernel crypto API
     #[derive(Copy, Clone)]
-    pub struct AlgAddr(pub sockaddr_alg);
+    #[repr(transparent)]
+    pub struct AlgAddr(pub(in super::super) sockaddr_alg);
+
+    impl private::SockaddrLikePriv for AlgAddr {}
+    impl SockaddrLike for AlgAddr {
+        unsafe fn from_raw(
+            addr: *const libc::sockaddr,
+            l: Option<libc::socklen_t>,
+        ) -> Option<Self>
+        where
+            Self: Sized,
+        {
+            if let Some(l) = l {
+                if l != mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t
+                {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_ALG {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
+        }
+    }
+
+    impl AsRef<libc::sockaddr_alg> for AlgAddr {
+        fn as_ref(&self) -> &libc::sockaddr_alg {
+            &self.0
+        }
+    }
 
     // , PartialEq, Eq, Debug, Hash
     impl PartialEq for AlgAddr {
         fn eq(&self, other: &Self) -> bool {
             let (inner, other) = (self.0, other.0);
-            (inner.salg_family, &inner.salg_type[..], inner.salg_feat, inner.salg_mask, &inner.salg_name[..]) ==
-            (other.salg_family, &other.salg_type[..], other.salg_feat, other.salg_mask, &other.salg_name[..])
+            (
+                inner.salg_family,
+                &inner.salg_type[..],
+                inner.salg_feat,
+                inner.salg_mask,
+                &inner.salg_name[..],
+            ) == (
+                other.salg_family,
+                &other.salg_type[..],
+                other.salg_feat,
+                other.salg_mask,
+                &other.salg_name[..],
+            )
         }
     }
 
@@ -1021,35 +2470,53 @@ pub mod alg {
     impl Hash for AlgAddr {
         fn hash<H: Hasher>(&self, s: &mut H) {
             let inner = self.0;
-            (inner.salg_family, &inner.salg_type[..], inner.salg_feat, inner.salg_mask, &inner.salg_name[..]).hash(s);
+            (
+                inner.salg_family,
+                &inner.salg_type[..],
+                inner.salg_feat,
+                inner.salg_mask,
+                &inner.salg_name[..],
+            )
+                .hash(s);
         }
     }
 
     impl AlgAddr {
+        /// Construct an `AF_ALG` socket from its cipher name and type.
         pub fn new(alg_type: &str, alg_name: &str) -> AlgAddr {
             let mut addr: sockaddr_alg = unsafe { mem::zeroed() };
             addr.salg_family = AF_ALG as u16;
-            addr.salg_type[..alg_type.len()].copy_from_slice(alg_type.to_string().as_bytes());
-            addr.salg_name[..alg_name.len()].copy_from_slice(alg_name.to_string().as_bytes());
+            addr.salg_type[..alg_type.len()]
+                .copy_from_slice(alg_type.to_string().as_bytes());
+            addr.salg_name[..alg_name.len()]
+                .copy_from_slice(alg_name.to_string().as_bytes());
 
             AlgAddr(addr)
         }
 
-
+        /// Return the socket's cipher type, for example `hash` or `aead`.
         pub fn alg_type(&self) -> &CStr {
-            unsafe { CStr::from_ptr(self.0.salg_type.as_ptr() as *const c_char) }
+            unsafe {
+                CStr::from_ptr(self.0.salg_type.as_ptr() as *const c_char)
+            }
         }
 
+        /// Return the socket's cipher name, for example `sha1`.
         pub fn alg_name(&self) -> &CStr {
-            unsafe { CStr::from_ptr(self.0.salg_name.as_ptr() as *const c_char) }
+            unsafe {
+                CStr::from_ptr(self.0.salg_name.as_ptr() as *const c_char)
+            }
         }
     }
 
     impl fmt::Display for AlgAddr {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            write!(f, "type: {} alg: {}",
-                   self.alg_name().to_string_lossy(),
-                   self.alg_type().to_string_lossy())
+            write!(
+                f,
+                "type: {} alg: {}",
+                self.alg_name().to_string_lossy(),
+                self.alg_type().to_string_lossy()
+            )
         }
     }
 
@@ -1060,13 +2527,16 @@ pub mod alg {
     }
 }
 
+feature! {
+#![feature = "ioctl"]
 #[cfg(any(target_os = "ios", target_os = "macos"))]
 pub mod sys_control {
     use crate::sys::socket::addr::AddressFamily;
     use libc::{self, c_uchar};
-    use std::{fmt, mem};
+    use std::{fmt, mem, ptr};
     use std::os::unix::io::RawFd;
     use crate::{Errno, Result};
+    use super::{private, SockaddrLike};
 
     // FIXME: Move type into `libc`
     #[repr(C)]
@@ -1083,11 +2553,41 @@ pub mod sys_control {
 
     ioctl_readwrite!(ctl_info, CTL_IOC_MAGIC, CTL_IOC_INFO, ctl_ioc_info);
 
-    #[repr(C)]
+    /// Apple system control socket
+    ///
+    /// # References
+    ///
+    /// <https://developer.apple.com/documentation/kernel/sockaddr_ctl>
     #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-    pub struct SysControlAddr(pub libc::sockaddr_ctl);
+    #[repr(transparent)]
+    pub struct SysControlAddr(pub(in super::super) libc::sockaddr_ctl);
+
+    impl private::SockaddrLikePriv for SysControlAddr {}
+    impl SockaddrLike for SysControlAddr {
+        unsafe fn from_raw(addr: *const libc::sockaddr, len: Option<libc::socklen_t>)
+            -> Option<Self> where Self: Sized
+        {
+            if let Some(l) = len {
+                if l != mem::size_of::<libc::sockaddr_ctl>() as libc::socklen_t {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_SYSTEM {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
+        }
+    }
+
+    impl AsRef<libc::sockaddr_ctl> for SysControlAddr {
+        fn as_ref(&self) -> &libc::sockaddr_ctl {
+            &self.0
+        }
+    }
 
     impl SysControlAddr {
+        /// Construct a new `SysControlAddr` from its kernel unique identifier
+        /// and unit number.
         pub const fn new(id: u32, unit: u32) -> SysControlAddr {
             let addr = libc::sockaddr_ctl {
                 sc_len: mem::size_of::<libc::sockaddr_ctl>() as c_uchar,
@@ -1101,6 +2601,8 @@ pub mod sys_control {
             SysControlAddr(addr)
         }
 
+        /// Construct a new `SysControlAddr` from its human readable name and
+        /// unit number.
         pub fn from_name(sockfd: RawFd, name: &str, unit: u32) -> Result<SysControlAddr> {
             if name.len() > MAX_KCTL_NAME {
                 return Err(Errno::ENAMETOOLONG);
@@ -1115,10 +2617,12 @@ pub mod sys_control {
             Ok(SysControlAddr::new(info.ctl_id, unit))
         }
 
+        /// Return the kernel unique identifier
         pub const fn id(&self) -> u32 {
             self.0.sc_id
         }
 
+        /// Return the kernel controller private unit number.
         pub const fn unit(&self) -> u32 {
             self.0.sc_unit
         }
@@ -1130,23 +2634,21 @@ pub mod sys_control {
         }
     }
 }
-
+}
 
 #[cfg(any(target_os = "android", target_os = "linux", target_os = "fuchsia"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod datalink {
-    use super::{fmt, AddressFamily};
+    feature! {
+    #![feature = "net"]
+    use super::{fmt, mem, private, ptr, SockaddrLike};
 
     /// Hardware Address
     #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-    pub struct LinkAddr(pub libc::sockaddr_ll);
+    #[repr(transparent)]
+    pub struct LinkAddr(pub(in super::super) libc::sockaddr_ll);
 
     impl LinkAddr {
-        /// Always AF_PACKET
-        pub fn family(&self) -> AddressFamily {
-            assert_eq!(self.0.sll_family as i32, libc::AF_PACKET);
-            AddressFamily::Packet
-        }
-
         /// Physical-layer protocol
         pub fn protocol(&self) -> u16 {
             self.0.sll_protocol
@@ -1173,70 +2675,96 @@ mod datalink {
         }
 
         /// Physical-layer address (MAC)
-        pub fn addr(&self) -> [u8; 6] {
-            [
-                self.0.sll_addr[0] as u8,
-                self.0.sll_addr[1] as u8,
-                self.0.sll_addr[2] as u8,
-                self.0.sll_addr[3] as u8,
-                self.0.sll_addr[4] as u8,
-                self.0.sll_addr[5] as u8,
-            ]
+        // Returns an Option just for cross-platform compatibility
+        pub fn addr(&self) -> Option<[u8; 6]> {
+            Some([
+                self.0.sll_addr[0],
+                self.0.sll_addr[1],
+                self.0.sll_addr[2],
+                self.0.sll_addr[3],
+                self.0.sll_addr[4],
+                self.0.sll_addr[5],
+            ])
         }
     }
 
     impl fmt::Display for LinkAddr {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            let addr = self.addr();
-            write!(f, "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
-                addr[0],
-                addr[1],
-                addr[2],
-                addr[3],
-                addr[4],
-                addr[5])
+            if let Some(addr) = self.addr() {
+                write!(f, "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
+                    addr[0],
+                    addr[1],
+                    addr[2],
+                    addr[3],
+                    addr[4],
+                    addr[5])
+            } else {
+                Ok(())
+            }
+        }
+    }
+    impl private::SockaddrLikePriv for LinkAddr {}
+    impl SockaddrLike for LinkAddr {
+        unsafe fn from_raw(addr: *const libc::sockaddr,
+                           len: Option<libc::socklen_t>)
+            -> Option<Self> where Self: Sized
+        {
+            if let Some(l) = len {
+                if l != mem::size_of::<libc::sockaddr_ll>() as libc::socklen_t {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_PACKET {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
+        }
+    }
+
+    impl AsRef<libc::sockaddr_ll> for LinkAddr {
+        fn as_ref(&self) -> &libc::sockaddr_ll {
+            &self.0
         }
     }
+
+    }
 }
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "illumos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "illumos",
+    target_os = "netbsd",
+    target_os = "haiku",
+    target_os = "openbsd"
+))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 mod datalink {
-    use super::{fmt, AddressFamily};
+    feature! {
+    #![feature = "net"]
+    use super::{fmt, mem, private, ptr, SockaddrLike};
 
     /// Hardware Address
     #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-    pub struct LinkAddr(pub libc::sockaddr_dl);
+    #[repr(transparent)]
+    pub struct LinkAddr(pub(in super::super) libc::sockaddr_dl);
 
     impl LinkAddr {
-        /// Total length of sockaddr
-        #[cfg(not(target_os = "illumos"))]
-        pub fn len(&self) -> usize {
-            self.0.sdl_len as usize
-        }
-
-        /// always == AF_LINK
-        pub fn family(&self) -> AddressFamily {
-            assert_eq!(i32::from(self.0.sdl_family), libc::AF_LINK);
-            AddressFamily::Link
-        }
-
         /// interface index, if != 0, system given index for interface
+        #[cfg(not(target_os = "haiku"))]
         pub fn ifindex(&self) -> usize {
             self.0.sdl_index as usize
         }
 
         /// Datalink type
+        #[cfg(not(target_os = "haiku"))]
         pub fn datalink_type(&self) -> u8 {
             self.0.sdl_type
         }
 
-        // MAC address start position
+        /// MAC address start position
         pub fn nlen(&self) -> usize {
             self.0.sdl_nlen as usize
         }
@@ -1247,6 +2775,7 @@ mod datalink {
         }
 
         /// link layer selector length
+        #[cfg(not(target_os = "haiku"))]
         pub fn slen(&self) -> usize {
             self.0.sdl_slen as usize
         }
@@ -1262,52 +2791,119 @@ mod datalink {
         }
 
         /// Physical-layer address (MAC)
-        pub fn addr(&self) -> [u8; 6] {
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
+        pub fn addr(&self) -> Option<[u8; 6]> {
             let nlen = self.nlen();
             let data = self.0.sdl_data;
 
-            assert!(!self.is_empty());
-
-            [
-                data[nlen] as u8,
-                data[nlen + 1] as u8,
-                data[nlen + 2] as u8,
-                data[nlen + 3] as u8,
-                data[nlen + 4] as u8,
-                data[nlen + 5] as u8,
-            ]
+            if self.is_empty() {
+                None
+            } else {
+                Some([
+                    data[nlen] as u8,
+                    data[nlen + 1] as u8,
+                    data[nlen + 2] as u8,
+                    data[nlen + 3] as u8,
+                    data[nlen + 4] as u8,
+                    data[nlen + 5] as u8,
+                ])
+            }
         }
     }
 
     impl fmt::Display for LinkAddr {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            let addr = self.addr();
-            write!(f, "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
-                addr[0],
-                addr[1],
-                addr[2],
-                addr[3],
-                addr[4],
-                addr[5])
+            if let Some(addr) = self.addr() {
+                write!(f, "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
+                    addr[0],
+                    addr[1],
+                    addr[2],
+                    addr[3],
+                    addr[4],
+                    addr[5])
+            } else {
+                Ok(())
+            }
+        }
+    }
+    impl private::SockaddrLikePriv for LinkAddr {}
+    impl SockaddrLike for LinkAddr {
+        unsafe fn from_raw(addr: *const libc::sockaddr,
+                           len: Option<libc::socklen_t>)
+            -> Option<Self> where Self: Sized
+        {
+            if let Some(l) = len {
+                if l != mem::size_of::<libc::sockaddr_dl>() as libc::socklen_t {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_LINK {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
         }
     }
+
+    impl AsRef<libc::sockaddr_dl> for LinkAddr {
+        fn as_ref(&self) -> &libc::sockaddr_dl {
+            &self.0
+        }
+    }
+
+    }
 }
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub mod vsock {
+    use super::*;
     use crate::sys::socket::addr::AddressFamily;
     use libc::{sa_family_t, sockaddr_vm};
-    use std::{fmt, mem};
     use std::hash::{Hash, Hasher};
+    use std::{fmt, mem};
 
+    /// Socket address for VMWare VSockets protocol
+    ///
+    /// # References
+    ///
+    /// [vsock(7)](https://man7.org/linux/man-pages/man7/vsock.7.html)
     #[derive(Copy, Clone)]
-    pub struct VsockAddr(pub sockaddr_vm);
+    #[repr(transparent)]
+    pub struct VsockAddr(pub(in super::super) sockaddr_vm);
+
+    impl private::SockaddrLikePriv for VsockAddr {}
+    impl SockaddrLike for VsockAddr {
+        unsafe fn from_raw(
+            addr: *const libc::sockaddr,
+            len: Option<libc::socklen_t>,
+        ) -> Option<Self>
+        where
+            Self: Sized,
+        {
+            if let Some(l) = len {
+                if l != mem::size_of::<libc::sockaddr_vm>() as libc::socklen_t {
+                    return None;
+                }
+            }
+            if (*addr).sa_family as i32 != libc::AF_VSOCK {
+                return None;
+            }
+            Some(Self(ptr::read_unaligned(addr as *const _)))
+        }
+    }
+
+    impl AsRef<libc::sockaddr_vm> for VsockAddr {
+        fn as_ref(&self) -> &libc::sockaddr_vm {
+            &self.0
+        }
+    }
 
     impl PartialEq for VsockAddr {
         fn eq(&self, other: &Self) -> bool {
             let (inner, other) = (self.0, other.0);
-            (inner.svm_family, inner.svm_cid, inner.svm_port) ==
-            (other.svm_family, other.svm_cid, other.svm_port)
+            (inner.svm_family, inner.svm_cid, inner.svm_port)
+                == (other.svm_family, other.svm_cid, other.svm_port)
         }
     }
 
@@ -1325,6 +2921,7 @@ pub mod vsock {
     /// The address for AF_VSOCK socket is defined as a combination of a
     /// 32-bit Context Identifier (CID) and a 32-bit port number.
     impl VsockAddr {
+        /// Construct a `VsockAddr` from its raw fields.
         pub fn new(cid: u32, port: u32) -> VsockAddr {
             let mut addr: sockaddr_vm = unsafe { mem::zeroed() };
             addr.svm_family = AddressFamily::Vsock as sa_family_t;
@@ -1360,88 +2957,291 @@ pub mod vsock {
 
 #[cfg(test)]
 mod tests {
-    #[cfg(any(target_os = "android",
-              target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "linux",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "illumos",
-              target_os = "openbsd"))]
     use super::*;
 
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
-    #[test]
-    fn test_macos_loopback_datalink_addr() {
-        let bytes = [20i8, 18, 1, 0, 24, 3, 0, 0, 108, 111, 48, 0, 0, 0, 0, 0];
-        let sa = bytes.as_ptr() as *const libc::sockaddr;
-        let _sock_addr = unsafe { SockAddr::from_libc_sockaddr(sa) };
-        assert!(_sock_addr.is_none());
-    }
-
-    #[cfg(any(target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
-    #[test]
-    fn test_macos_tap_datalink_addr() {
-        let bytes = [20i8, 18, 7, 0, 6, 3, 6, 0, 101, 110, 48, 24, 101, -112, -35, 76, -80];
-        let ptr = bytes.as_ptr();
-        let sa = ptr as *const libc::sockaddr;
-        let _sock_addr = unsafe { SockAddr::from_libc_sockaddr(sa) };
-
-        assert!(_sock_addr.is_some());
-
-        let sock_addr = _sock_addr.unwrap();
-
-        assert_eq!(sock_addr.family(), AddressFamily::Link);
-
-        match sock_addr {
-            SockAddr::Link(ether_addr) => {
-                assert_eq!(ether_addr.addr(), [24u8, 101, 144, 221, 76, 176]);
-            },
-            _ => { unreachable!() }
-        };
+    mod types {
+        use super::*;
+
+        #[test]
+        fn test_ipv4addr_to_libc() {
+            let s = std::net::Ipv4Addr::new(1, 2, 3, 4);
+            let l = ipv4addr_to_libc(s);
+            assert_eq!(l.s_addr, u32::to_be(0x01020304));
+        }
+
+        #[test]
+        fn test_ipv6addr_to_libc() {
+            let s = std::net::Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8);
+            let l = ipv6addr_to_libc(&s);
+            assert_eq!(
+                l.s6_addr,
+                [0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8]
+            );
+        }
     }
 
-    #[cfg(target_os = "illumos")]
-    #[test]
-    fn test_illumos_tap_datalink_addr() {
-        let bytes = [25u8, 0, 0, 0, 6, 0, 6, 0, 24, 101, 144, 221, 76, 176];
-        let ptr = bytes.as_ptr();
-        let sa = ptr as *const libc::sockaddr;
-        let _sock_addr = unsafe { SockAddr::from_libc_sockaddr(sa) };
+    mod link {
+        #![allow(clippy::cast_ptr_alignment)]
+
+        #[cfg(any(
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "illumos"
+        ))]
+        use super::super::super::socklen_t;
+        use super::*;
+
+        /// Don't panic when trying to display an empty datalink address
+        #[cfg(any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "ios",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd"
+        ))]
+        #[test]
+        fn test_datalink_display() {
+            use super::super::LinkAddr;
+            use std::mem;
+
+            let la = LinkAddr(libc::sockaddr_dl {
+                sdl_len: 56,
+                sdl_family: 18,
+                sdl_index: 5,
+                sdl_type: 24,
+                sdl_nlen: 3,
+                sdl_alen: 0,
+                sdl_slen: 0,
+                ..unsafe { mem::zeroed() }
+            });
+            format!("{}", la);
+        }
 
-        assert!(_sock_addr.is_some());
+        #[cfg(all(
+            any(
+                target_os = "android",
+                target_os = "fuchsia",
+                target_os = "linux"
+            ),
+            target_endian = "little"
+        ))]
+        #[test]
+        fn linux_loopback() {
+            #[repr(align(2))]
+            struct Raw([u8; 20]);
+
+            let bytes = Raw([
+                17u8, 0, 0, 0, 1, 0, 0, 0, 4, 3, 0, 6, 1, 2, 3, 4, 5, 6, 0, 0,
+            ]);
+            let sa = bytes.0.as_ptr() as *const libc::sockaddr;
+            let len = None;
+            let sock_addr =
+                unsafe { SockaddrStorage::from_raw(sa, len) }.unwrap();
+            assert_eq!(sock_addr.family(), Some(AddressFamily::Packet));
+            match sock_addr.as_link_addr() {
+                Some(dl) => assert_eq!(dl.addr(), Some([1, 2, 3, 4, 5, 6])),
+                None => panic!("Can't unwrap sockaddr storage"),
+            }
+        }
 
-        let sock_addr = _sock_addr.unwrap();
+        #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[test]
+        fn macos_loopback() {
+            let bytes =
+                [20i8, 18, 1, 0, 24, 3, 0, 0, 108, 111, 48, 0, 0, 0, 0, 0];
+            let sa = bytes.as_ptr() as *const libc::sockaddr;
+            let len = Some(bytes.len() as socklen_t);
+            let sock_addr =
+                unsafe { SockaddrStorage::from_raw(sa, len) }.unwrap();
+            assert_eq!(sock_addr.family(), Some(AddressFamily::Link));
+            match sock_addr.as_link_addr() {
+                Some(dl) => {
+                    assert!(dl.addr().is_none());
+                }
+                None => panic!("Can't unwrap sockaddr storage"),
+            }
+        }
 
-        assert_eq!(sock_addr.family(), AddressFamily::Link);
+        #[cfg(any(target_os = "ios", target_os = "macos"))]
+        #[test]
+        fn macos_tap() {
+            let bytes = [
+                20i8, 18, 7, 0, 6, 3, 6, 0, 101, 110, 48, 24, 101, -112, -35,
+                76, -80,
+            ];
+            let ptr = bytes.as_ptr();
+            let sa = ptr as *const libc::sockaddr;
+            let len = Some(bytes.len() as socklen_t);
+
+            let sock_addr =
+                unsafe { SockaddrStorage::from_raw(sa, len).unwrap() };
+            assert_eq!(sock_addr.family(), Some(AddressFamily::Link));
+            match sock_addr.as_link_addr() {
+                Some(dl) => {
+                    assert_eq!(dl.addr(), Some([24u8, 101, 144, 221, 76, 176]))
+                }
+                None => panic!("Can't unwrap sockaddr storage"),
+            }
+        }
 
-        match sock_addr {
-            SockAddr::Link(ether_addr) => {
-                assert_eq!(ether_addr.addr(), [24u8, 101, 144, 221, 76, 176]);
-            },
-            _ => { unreachable!() }
-        };
+        #[cfg(target_os = "illumos")]
+        #[test]
+        fn illumos_tap() {
+            let bytes = [25u8, 0, 0, 0, 6, 0, 6, 0, 24, 101, 144, 221, 76, 176];
+            let ptr = bytes.as_ptr();
+            let sa = ptr as *const libc::sockaddr;
+            let len = Some(bytes.len() as socklen_t);
+            let _sock_addr = unsafe { SockaddrStorage::from_raw(sa, len) };
+
+            assert!(_sock_addr.is_some());
+
+            let sock_addr = _sock_addr.unwrap();
+
+            assert_eq!(sock_addr.family().unwrap(), AddressFamily::Link);
+
+            assert_eq!(
+                sock_addr.as_link_addr().unwrap().addr(),
+                Some([24u8, 101, 144, 221, 76, 176])
+            );
+        }
+
+        #[test]
+        fn size() {
+            #[cfg(any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "ios",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "illumos",
+                target_os = "openbsd",
+                target_os = "haiku"
+            ))]
+            let l = mem::size_of::<libc::sockaddr_dl>();
+            #[cfg(any(
+                target_os = "android",
+                target_os = "fuchsia",
+                target_os = "linux"
+            ))]
+            let l = mem::size_of::<libc::sockaddr_ll>();
+            assert_eq!(LinkAddr::size() as usize, l);
+        }
     }
 
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[test]
-    fn test_abstract_sun_path() {
-        let name = String::from("nix\0abstract\0test");
-        let addr = UnixAddr::new_abstract(name.as_bytes()).unwrap();
-
-        let sun_path1 = unsafe { &(*addr.as_ptr()).sun_path[..addr.path_len()] };
-        let sun_path2 = [0, 110, 105, 120, 0, 97, 98, 115, 116, 114, 97, 99, 116, 0, 116, 101, 115, 116];
-        assert_eq!(sun_path1, sun_path2);
+    mod sockaddr_in {
+        use super::*;
+        use std::str::FromStr;
+
+        #[test]
+        fn display() {
+            let s = "127.0.0.1:8080";
+            let addr = SockaddrIn::from_str(s).unwrap();
+            assert_eq!(s, format!("{}", addr));
+        }
+
+        #[test]
+        fn size() {
+            assert_eq!(
+                mem::size_of::<libc::sockaddr_in>(),
+                SockaddrIn::size() as usize
+            );
+        }
+    }
+
+    mod sockaddr_in6 {
+        use super::*;
+        use std::str::FromStr;
+
+        #[test]
+        fn display() {
+            let s = "[1234:5678:90ab:cdef::1111:2222]:8080";
+            let addr = SockaddrIn6::from_str(s).unwrap();
+            assert_eq!(s, format!("{}", addr));
+        }
+
+        #[test]
+        fn size() {
+            assert_eq!(
+                mem::size_of::<libc::sockaddr_in6>(),
+                SockaddrIn6::size() as usize
+            );
+        }
+
+        #[test]
+        // Ensure that we can convert to-and-from std::net variants without change.
+        fn to_and_from() {
+            let s = "[1234:5678:90ab:cdef::1111:2222]:8080";
+            let mut nix_sin6 = SockaddrIn6::from_str(s).unwrap();
+            nix_sin6.0.sin6_flowinfo = 0x12345678;
+            nix_sin6.0.sin6_scope_id = 0x9abcdef0;
+
+            let std_sin6 : std::net::SocketAddrV6 = nix_sin6.into();
+            assert_eq!(nix_sin6, std_sin6.into());
+        }
+    }
+
+    mod sockaddr_storage {
+        use super::*;
+
+        #[test]
+        fn from_sockaddr_un_named() {
+            let ua = UnixAddr::new("/var/run/mysock").unwrap();
+            let ptr = ua.as_ptr() as *const libc::sockaddr;
+            let ss = unsafe {
+                SockaddrStorage::from_raw(ptr, Some(ua.len()))
+            }.unwrap();
+            assert_eq!(ss.len(), ua.len());
+        }
+
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[test]
+        fn from_sockaddr_un_abstract_named() {
+            let name = String::from("nix\0abstract\0test");
+            let ua = UnixAddr::new_abstract(name.as_bytes()).unwrap();
+            let ptr = ua.as_ptr() as *const libc::sockaddr;
+            let ss = unsafe {
+                SockaddrStorage::from_raw(ptr, Some(ua.len()))
+            }.unwrap();
+            assert_eq!(ss.len(), ua.len());
+        }
+
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[test]
+        fn from_sockaddr_un_abstract_unnamed() {
+            let ua = UnixAddr::new_unnamed();
+            let ptr = ua.as_ptr() as *const libc::sockaddr;
+            let ss = unsafe {
+                SockaddrStorage::from_raw(ptr, Some(ua.len()))
+            }.unwrap();
+            assert_eq!(ss.len(), ua.len());
+        }
+    }
+
+    mod unixaddr {
+        use super::*;
+
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[test]
+        fn abstract_sun_path() {
+            let name = String::from("nix\0abstract\0test");
+            let addr = UnixAddr::new_abstract(name.as_bytes()).unwrap();
+
+            let sun_path1 =
+                unsafe { &(*addr.as_ptr()).sun_path[..addr.path_len()] };
+            let sun_path2 = [
+                0, 110, 105, 120, 0, 97, 98, 115, 116, 114, 97, 99, 116, 0,
+                116, 101, 115, 116,
+            ];
+            assert_eq!(sun_path1, sun_path2);
+        }
+
+        #[test]
+        fn size() {
+            assert_eq!(
+                mem::size_of::<libc::sockaddr_un>(),
+                UnixAddr::size() as usize
+            );
+        }
     }
 }
diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs
index 97eea3d..8513b6f 100644
--- a/src/sys/socket/mod.rs
+++ b/src/sys/socket/mod.rs
@@ -1,18 +1,25 @@
 //! Socket interface functions
 //!
 //! [Further reading](https://man7.org/linux/man-pages/man7/socket.7.html)
-use cfg_if::cfg_if;
-use crate::{Result, errno::Errno};
-use libc::{self, c_void, c_int, iovec, socklen_t, size_t,
-        CMSG_FIRSTHDR, CMSG_NXTHDR, CMSG_DATA, CMSG_LEN};
-use memoffset::offset_of;
-use std::{mem, ptr, slice};
-use std::os::unix::io::RawFd;
-#[cfg(all(target_os = "linux"))]
+#[cfg(target_os = "linux")]
+#[cfg(feature = "uio")]
 use crate::sys::time::TimeSpec;
+#[cfg(feature = "uio")]
 use crate::sys::time::TimeVal;
-use crate::sys::uio::IoVec;
+use crate::{errno::Errno, Result};
+use cfg_if::cfg_if;
+use libc::{
+    self, c_int, c_void, iovec, size_t, socklen_t, CMSG_DATA, CMSG_FIRSTHDR,
+    CMSG_LEN, CMSG_NXTHDR,
+};
+use std::convert::{TryFrom, TryInto};
+use std::io::{IoSlice, IoSliceMut};
+#[cfg(feature = "net")]
+use std::net;
+use std::os::unix::io::RawFd;
+use std::{mem, ptr, slice};
 
+#[deny(missing_docs)]
 mod addr;
 #[deny(missing_docs)]
 pub mod sockopt;
@@ -23,50 +30,58 @@ pub mod sockopt;
  *
  */
 
+pub use self::addr::{SockaddrLike, SockaddrStorage};
+
 #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
+#[allow(deprecated)]
+pub use self::addr::{AddressFamily, SockAddr, UnixAddr};
+#[cfg(any(target_os = "illumos", target_os = "solaris"))]
+#[allow(deprecated)]
+pub use self::addr::{AddressFamily, SockAddr, UnixAddr};
+#[allow(deprecated)]
+#[cfg(not(any(
+    target_os = "illumos",
+    target_os = "solaris",
+    target_os = "haiku"
+)))]
+#[cfg(feature = "net")]
 pub use self::addr::{
-    AddressFamily,
-    SockAddr,
-    InetAddr,
-    UnixAddr,
-    IpAddr,
-    Ipv4Addr,
-    Ipv6Addr,
-    LinkAddr,
+    InetAddr, IpAddr, Ipv4Addr, Ipv6Addr, LinkAddr, SockaddrIn, SockaddrIn6,
 };
-#[cfg(any(target_os = "illumos", target_os = "solaris"))]
+#[allow(deprecated)]
+#[cfg(any(
+    target_os = "illumos",
+    target_os = "solaris",
+    target_os = "haiku"
+))]
+#[cfg(feature = "net")]
 pub use self::addr::{
-    AddressFamily,
-    SockAddr,
-    InetAddr,
-    UnixAddr,
-    IpAddr,
-    Ipv4Addr,
-    Ipv6Addr,
+    InetAddr, IpAddr, Ipv4Addr, Ipv6Addr, SockaddrIn, SockaddrIn6,
 };
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
-pub use crate::sys::socket::addr::netlink::NetlinkAddr;
-#[cfg(any(target_os = "android", target_os = "linux"))]
 pub use crate::sys::socket::addr::alg::AlgAddr;
 #[cfg(any(target_os = "android", target_os = "linux"))]
+pub use crate::sys::socket::addr::netlink::NetlinkAddr;
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+#[cfg(feature = "ioctl")]
+pub use crate::sys::socket::addr::sys_control::SysControlAddr;
+#[cfg(any(target_os = "android", target_os = "linux"))]
 pub use crate::sys::socket::addr::vsock::VsockAddr;
 
-pub use libc::{
-    cmsghdr,
-    msghdr,
-    sa_family_t,
-    sockaddr,
-    sockaddr_in,
-    sockaddr_in6,
-    sockaddr_storage,
-    sockaddr_un,
-};
+#[cfg(feature = "uio")]
+pub use libc::{cmsghdr, msghdr};
+pub use libc::{sa_family_t, sockaddr, sockaddr_storage, sockaddr_un};
+#[cfg(feature = "net")]
+pub use libc::{sockaddr_in, sockaddr_in6};
 
 // Needed by the cmsg_space macro
 #[doc(hidden)]
 pub use libc::{c_uint, CMSG_SPACE};
 
+#[cfg(feature = "net")]
+use crate::sys::socket::addr::{ipv4addr_to_libc, ipv6addr_to_libc};
+
 /// These constants are used to specify the communication semantics
 /// when creating a socket with [`socket()`](fn.socket.html)
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -89,8 +104,27 @@ pub enum SockType {
     Raw = libc::SOCK_RAW,
     /// Provides a reliable datagram layer that does not
     /// guarantee ordering.
+    #[cfg(not(any(target_os = "haiku")))]
     Rdm = libc::SOCK_RDM,
 }
+// The TryFrom impl could've been derived using libc_enum!.  But for
+// backwards-compatibility with Nix-0.25.0 we manually implement it, so as to
+// keep the old variant names.
+impl TryFrom<i32> for SockType {
+    type Error = crate::Error;
+
+    fn try_from(x: i32) -> Result<Self> {
+        match x {
+            libc::SOCK_STREAM => Ok(Self::Stream),
+            libc::SOCK_DGRAM => Ok(Self::Datagram),
+            libc::SOCK_SEQPACKET => Ok(Self::SeqPacket),
+            libc::SOCK_RAW => Ok(Self::Raw),
+            #[cfg(not(any(target_os = "haiku")))]
+            libc::SOCK_RDM => Ok(Self::Rdm),
+            _ => Err(Errno::EINVAL)
+        }
+    }
+}
 
 /// Constants used in [`socket`](fn.socket.html) and [`socketpair`](fn.socketpair.html)
 /// to specify the protocol to use.
@@ -102,75 +136,122 @@ pub enum SockProtocol {
     Tcp = libc::IPPROTO_TCP,
     /// UDP protocol ([ip(7)](https://man7.org/linux/man-pages/man7/ip.7.html))
     Udp = libc::IPPROTO_UDP,
+    /// Raw sockets ([raw(7)](https://man7.org/linux/man-pages/man7/raw.7.html))
+    Raw = libc::IPPROTO_RAW,
     /// Allows applications and other KEXTs to be notified when certain kernel events occur
     /// ([ref](https://developer.apple.com/library/content/documentation/Darwin/Conceptual/NKEConceptual/control/control.html))
     #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     KextEvent = libc::SYSPROTO_EVENT,
     /// Allows applications to configure and control a KEXT
     /// ([ref](https://developer.apple.com/library/content/documentation/Darwin/Conceptual/NKEConceptual/control/control.html))
     #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     KextControl = libc::SYSPROTO_CONTROL,
     /// Receives routing and link updates and may be used to modify the routing tables (both IPv4 and IPv6), IP addresses, link
     // parameters, neighbor setups, queueing disciplines, traffic classes and packet classifiers
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkRoute = libc::NETLINK_ROUTE,
     /// Reserved for user-mode socket protocols
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkUserSock = libc::NETLINK_USERSOCK,
     /// Query information about sockets of various protocol families from the kernel
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkSockDiag = libc::NETLINK_SOCK_DIAG,
     /// SELinux event notifications.
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkSELinux = libc::NETLINK_SELINUX,
     /// Open-iSCSI
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkISCSI = libc::NETLINK_ISCSI,
     /// Auditing
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkAudit = libc::NETLINK_AUDIT,
     /// Access to FIB lookup from user space
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkFIBLookup = libc::NETLINK_FIB_LOOKUP,
     /// Netfilter subsystem
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkNetFilter = libc::NETLINK_NETFILTER,
     /// SCSI Transports
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkSCSITransport = libc::NETLINK_SCSITRANSPORT,
     /// Infiniband RDMA
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkRDMA = libc::NETLINK_RDMA,
     /// Transport IPv6 packets from netfilter to user space.  Used by ip6_queue kernel module.
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkIPv6Firewall = libc::NETLINK_IP6_FW,
     /// DECnet routing messages
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkDECNetRoutingMessage = libc::NETLINK_DNRTMSG,
     /// Kernel messages to user space
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkKObjectUEvent = libc::NETLINK_KOBJECT_UEVENT,
     /// Netlink interface to request information about ciphers registered with the kernel crypto API as well as allow
     /// configuration of the kernel crypto API.
     /// ([ref](https://www.man7.org/linux/man-pages/man7/netlink.7.html))
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     NetlinkCrypto = libc::NETLINK_CRYPTO,
+    /// Non-DIX type protocol number defined for the Ethernet IEEE 802.3 interface that allows packets of all protocols
+    /// defined in the interface to be received.
+    /// ([ref](https://man7.org/linux/man-pages/man7/packet.7.html))
+    // The protocol number is fed into the socket syscall in network byte order.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    EthAll = libc::ETH_P_ALL.to_be(),
+}
+
+#[cfg(any(target_os = "linux"))]
+libc_bitflags! {
+    /// Configuration flags for `SO_TIMESTAMPING` interface
+    ///
+    /// For use with [`Timestamping`][sockopt::Timestamping].
+    /// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)
+    pub struct TimestampingFlag: c_uint {
+        /// Report any software timestamps when available.
+        SOF_TIMESTAMPING_SOFTWARE;
+        /// Report hardware timestamps as generated by SOF_TIMESTAMPING_TX_HARDWARE when available.
+        SOF_TIMESTAMPING_RAW_HARDWARE;
+        /// Collect transmiting timestamps as reported by hardware
+        SOF_TIMESTAMPING_TX_HARDWARE;
+        /// Collect transmiting timestamps as reported by software
+        SOF_TIMESTAMPING_TX_SOFTWARE;
+        /// Collect receiving timestamps as reported by hardware
+        SOF_TIMESTAMPING_RX_HARDWARE;
+        /// Collect receiving timestamps as reported by software
+        SOF_TIMESTAMPING_RX_SOFTWARE;
+    }
 }
 
-libc_bitflags!{
+libc_bitflags! {
     /// Additional socket options
     pub struct SockFlag: c_int {
         /// Set non-blocking mode on the new socket
@@ -181,6 +262,7 @@ libc_bitflags!{
                   target_os = "linux",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         SOCK_NONBLOCK;
         /// Set close-on-exec on the new descriptor
         #[cfg(any(target_os = "android",
@@ -190,31 +272,37 @@ libc_bitflags!{
                   target_os = "linux",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         SOCK_CLOEXEC;
         /// Return `EPIPE` instead of raising `SIGPIPE`
         #[cfg(target_os = "netbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         SOCK_NOSIGPIPE;
         /// For domains `AF_INET(6)`, only allow `connect(2)`, `sendto(2)`, or `sendmsg(2)`
         /// to the DNS port (typically 53)
         #[cfg(target_os = "openbsd")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         SOCK_DNS;
     }
 }
 
-libc_bitflags!{
+libc_bitflags! {
     /// Flags for send/recv and their relatives
     pub struct MsgFlags: c_int {
         /// Sends or requests out-of-band data on sockets that support this notion
         /// (e.g., of type [`Stream`](enum.SockType.html)); the underlying protocol must also
         /// support out-of-band data.
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_OOB;
         /// Peeks at an incoming message. The data is treated as unread and the next
         /// [`recv()`](fn.recv.html)
         /// or similar function shall still return this data.
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_PEEK;
         /// Receive operation blocks until the full amount of data can be
         /// returned. The function may return smaller amount of data if a signal
         /// is caught, an error or disconnect occurs.
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_WAITALL;
         /// Enables nonblocking operation; if the operation would block,
         /// `EAGAIN` or `EWOULDBLOCK` is returned.  This provides similar
@@ -226,8 +314,10 @@ libc_bitflags!{
         /// which will affect all threads in
         /// the calling process and as well as other processes that hold
         /// file descriptors referring to the same open file description.
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_DONTWAIT;
         /// Receive flags: Control Data was discarded (buffer too small)
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_CTRUNC;
         /// For raw ([`Packet`](addr/enum.AddressFamily.html)), Internet datagram
         /// (since Linux 2.4.27/2.6.8),
@@ -237,14 +327,18 @@ libc_bitflags!{
         /// domain ([unix(7)](https://linux.die.net/man/7/unix)) sockets.
         ///
         /// For use with Internet stream sockets, see [tcp(7)](https://linux.die.net/man/7/tcp).
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_TRUNC;
         /// Terminates a record (when this notion is supported, as for
         /// sockets of type [`SeqPacket`](enum.SockType.html)).
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_EOR;
         /// This flag specifies that queued errors should be received from
         /// the socket error queue. (For more details, see
         /// [recvfrom(2)](https://linux.die.net/man/2/recvfrom))
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_ERRQUEUE;
         /// Set the `close-on-exec` flag for the file descriptor received via a UNIX domain
         /// file descriptor using the `SCM_RIGHTS` operation (described in
@@ -259,7 +353,24 @@ libc_bitflags!{
                   target_os = "linux",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
         MSG_CMSG_CLOEXEC;
+        /// Requests not to send `SIGPIPE` errors when the other end breaks the connection.
+        /// (For more details, see [send(2)](https://linux.die.net/man/2/send)).
+        #[cfg(any(target_os = "android",
+                  target_os = "dragonfly",
+                  target_os = "freebsd",
+                  target_os = "fuchsia",
+                  target_os = "haiku",
+                  target_os = "illumos",
+                  target_os = "linux",
+                  target_os = "netbsd",
+                  target_os = "openbsd",
+                  target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
+        #[allow(deprecated)]    // Suppress useless warnings from libc PR 2963
+        MSG_NOSIGNAL;
     }
 }
 
@@ -276,11 +387,14 @@ cfg_if! {
         impl UnixCredentials {
             /// Creates a new instance with the credentials of the current process
             pub fn new() -> Self {
-                UnixCredentials(libc::ucred {
-                    pid: crate::unistd::getpid().as_raw(),
-                    uid: crate::unistd::getuid().as_raw(),
-                    gid: crate::unistd::getgid().as_raw(),
-                })
+                // Safe because these FFI functions are inherently safe
+                unsafe {
+                    UnixCredentials(libc::ucred {
+                        pid: libc::getpid(),
+                        uid: libc::getuid(),
+                        gid: libc::getgid()
+                    })
+                }
             }
 
             /// Returns the process identifier
@@ -347,7 +461,12 @@ cfg_if! {
 
             /// Returns a list group identifiers (the first one being the effective GID)
             pub fn groups(&self) -> &[libc::gid_t] {
-                unsafe { slice::from_raw_parts(self.0.cmcred_groups.as_ptr() as *const libc::gid_t, self.0.cmcred_ngroups as _) }
+                unsafe {
+                    slice::from_raw_parts(
+                        self.0.cmcred_groups.as_ptr() as *const libc::gid_t,
+                        self.0.cmcred_ngroups as _
+                    )
+                }
             }
         }
 
@@ -359,7 +478,7 @@ cfg_if! {
     }
 }
 
-cfg_if!{
+cfg_if! {
     if #[cfg(any(
                 target_os = "dragonfly",
                 target_os = "freebsd",
@@ -391,6 +510,8 @@ cfg_if!{
     }
 }
 
+feature! {
+#![feature = "net"]
 /// Request for multicast socket operations
 ///
 /// This is a wrapper type around `ip_mreq`.
@@ -402,10 +523,16 @@ impl IpMembershipRequest {
     /// Instantiate a new `IpMembershipRequest`
     ///
     /// If `interface` is `None`, then `Ipv4Addr::any()` will be used for the interface.
-    pub fn new(group: Ipv4Addr, interface: Option<Ipv4Addr>) -> Self {
+    pub fn new(group: net::Ipv4Addr, interface: Option<net::Ipv4Addr>)
+        -> Self
+    {
+        let imr_addr = match interface {
+            None => net::Ipv4Addr::UNSPECIFIED,
+            Some(addr) => addr
+        };
         IpMembershipRequest(libc::ip_mreq {
-            imr_multiaddr: group.0,
-            imr_interface: interface.unwrap_or_else(Ipv4Addr::any).0,
+            imr_multiaddr: ipv4addr_to_libc(group),
+            imr_interface: ipv4addr_to_libc(imr_addr)
         })
     }
 }
@@ -419,13 +546,17 @@ pub struct Ipv6MembershipRequest(libc::ipv6_mreq);
 
 impl Ipv6MembershipRequest {
     /// Instantiate a new `Ipv6MembershipRequest`
-    pub const fn new(group: Ipv6Addr) -> Self {
+    pub const fn new(group: net::Ipv6Addr) -> Self {
         Ipv6MembershipRequest(libc::ipv6_mreq {
-            ipv6mr_multiaddr: group.0,
+            ipv6mr_multiaddr: ipv6addr_to_libc(&group),
             ipv6mr_interface: 0,
         })
     }
 }
+}
+
+feature! {
+#![feature = "uio"]
 
 /// Create a buffer large enough for storing some control messages as returned
 /// by [`recvmsg`](fn.recvmsg.html).
@@ -466,15 +597,20 @@ macro_rules! cmsg_space {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct RecvMsg<'a> {
+/// Contains outcome of sending or receiving a message
+///
+/// Use [`cmsgs`][RecvMsg::cmsgs] to access all the control messages present, and
+/// [`iovs`][RecvMsg::iovs`] to access underlying io slices.
+pub struct RecvMsg<'a, 's, S> {
     pub bytes: usize,
     cmsghdr: Option<&'a cmsghdr>,
-    pub address: Option<SockAddr>,
+    pub address: Option<S>,
     pub flags: MsgFlags,
+    iobufs: std::marker::PhantomData<& 's()>,
     mhdr: msghdr,
 }
 
-impl<'a> RecvMsg<'a> {
+impl<'a, S> RecvMsg<'a, '_, S> {
     /// Iterate over the valid control messages pointed to by this
     /// msghdr.
     pub fn cmsgs(&self) -> CmsgIterator {
@@ -531,9 +667,11 @@ pub enum ControlMessageOwned {
     ScmRights(Vec<RawFd>),
     /// Received version of [`ControlMessage::ScmCredentials`]
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ScmCredentials(UnixCredentials),
     /// Received version of [`ControlMessage::ScmCreds`]
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ScmCreds(UnixCredentials),
     /// A message of type `SCM_TIMESTAMP`, containing the time the
     /// packet was received by the kernel.
@@ -546,9 +684,10 @@ pub enum ControlMessageOwned {
     /// ```
     /// # #[macro_use] extern crate nix;
     /// # use nix::sys::socket::*;
-    /// # use nix::sys::uio::IoVec;
     /// # use nix::sys::time::*;
+    /// # use std::io::{IoSlice, IoSliceMut};
     /// # use std::time::*;
+    /// # use std::str::FromStr;
     /// # fn main() {
     /// // Set up
     /// let message = "Ohayō!".as_bytes();
@@ -558,21 +697,22 @@ pub enum ControlMessageOwned {
     ///     SockFlag::empty(),
     ///     None).unwrap();
     /// setsockopt(in_socket, sockopt::ReceiveTimestamp, &true).unwrap();
-    /// let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
-    /// bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
-    /// let address = getsockname(in_socket).unwrap();
+    /// let localhost = SockaddrIn::from_str("127.0.0.1:0").unwrap();
+    /// bind(in_socket, &localhost).unwrap();
+    /// let address: SockaddrIn = getsockname(in_socket).unwrap();
     /// // Get initial time
     /// let time0 = SystemTime::now();
     /// // Send the message
-    /// let iov = [IoVec::from_slice(message)];
+    /// let iov = [IoSlice::new(message)];
     /// let flags = MsgFlags::empty();
     /// let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();
     /// assert_eq!(message.len(), l);
     /// // Receive the message
     /// let mut buffer = vec![0u8; message.len()];
     /// let mut cmsgspace = cmsg_space!(TimeVal);
-    /// let iov = [IoVec::from_mut_slice(&mut buffer)];
-    /// let r = recvmsg(in_socket, &iov, Some(&mut cmsgspace), flags).unwrap();
+    /// let mut iov = [IoSliceMut::new(&mut buffer)];
+    /// let r = recvmsg::<SockaddrIn>(in_socket, &mut iov, Some(&mut cmsgspace), flags)
+    ///     .unwrap();
     /// let rtime = match r.cmsgs().next() {
     ///     Some(ControlMessageOwned::ScmTimestamp(rtime)) => rtime,
     ///     Some(_) => panic!("Unexpected control message"),
@@ -591,10 +731,16 @@ pub enum ControlMessageOwned {
     /// # }
     /// ```
     ScmTimestamp(TimeVal),
+    /// A set of nanosecond resolution timestamps
+    ///
+    /// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)
+    #[cfg(all(target_os = "linux"))]
+    ScmTimestampsns(Timestamps),
     /// Nanoseconds resolution timestamp
     ///
     /// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)
     #[cfg(all(target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ScmTimestampns(TimeSpec),
     #[cfg(any(
         target_os = "android",
@@ -603,6 +749,8 @@ pub enum ControlMessageOwned {
         target_os = "macos",
         target_os = "netbsd",
     ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv4PacketInfo(libc::in_pktinfo),
     #[cfg(any(
         target_os = "android",
@@ -614,6 +762,8 @@ pub enum ControlMessageOwned {
         target_os = "openbsd",
         target_os = "netbsd",
     ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv6PacketInfo(libc::in6_pktinfo),
     #[cfg(any(
         target_os = "freebsd",
@@ -622,6 +772,8 @@ pub enum ControlMessageOwned {
         target_os = "netbsd",
         target_os = "openbsd",
     ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv4RecvIf(libc::sockaddr_dl),
     #[cfg(any(
         target_os = "freebsd",
@@ -630,7 +782,17 @@ pub enum ControlMessageOwned {
         target_os = "netbsd",
         target_os = "openbsd",
     ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv4RecvDstAddr(libc::in_addr),
+    #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    Ipv4OrigDstAddr(libc::sockaddr_in),
+    #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    Ipv6OrigDstAddr(libc::sockaddr_in6),
 
     /// UDP Generic Receive Offload (GRO) allows receiving multiple UDP
     /// packets from a single sender.
@@ -641,6 +803,8 @@ pub enum ControlMessageOwned {
     /// `UdpGroSegment` socket option should be enabled on a socket
     /// to allow receiving GRO packets.
     #[cfg(target_os = "linux")]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     UdpGroSegments(u16),
 
     /// SO_RXQ_OVFL indicates that an unsigned 32 bit value
@@ -652,13 +816,18 @@ pub enum ControlMessageOwned {
     /// `RxqOvfl` socket option should be enabled on a socket
     /// to allow receiving the drop counter.
     #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     RxqOvfl(u32),
 
     /// Socket error queue control messages read with the `MSG_ERRQUEUE` flag.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv4RecvErr(libc::sock_extended_err, Option<sockaddr_in>),
     /// Socket error queue control messages read with the `MSG_ERRQUEUE` flag.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv6RecvErr(libc::sock_extended_err, Option<sockaddr_in6>),
 
     /// Catch-all variant for unimplemented cmsg types.
@@ -666,6 +835,18 @@ pub enum ControlMessageOwned {
     Unknown(UnknownCmsg),
 }
 
+/// For representing packet timestamps via `SO_TIMESTAMPING` interface
+#[cfg(all(target_os = "linux"))]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Timestamps {
+    /// software based timestamp, usually one containing data
+    pub system: TimeSpec,
+    /// legacy timestamp, usually empty
+    pub hw_trans: TimeSpec,
+    /// hardware based timestamp
+    pub hw_raw: TimeSpec,
+}
+
 impl ControlMessageOwned {
     /// Decodes a `ControlMessageOwned` from raw bytes.
     ///
@@ -679,6 +860,8 @@ impl ControlMessageOwned {
     unsafe fn decode_from(header: &cmsghdr) -> ControlMessageOwned
     {
         let p = CMSG_DATA(header);
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         let len = header as *const _ as usize + header.cmsg_len as usize
             - p as usize;
         match (header.cmsg_level, header.cmsg_type) {
@@ -701,6 +884,7 @@ impl ControlMessageOwned {
                 let cred: libc::cmsgcred = ptr::read_unaligned(p as *const _);
                 ControlMessageOwned::ScmCreds(cred.into())
             }
+            #[cfg(not(target_os = "haiku"))]
             (libc::SOL_SOCKET, libc::SCM_TIMESTAMP) => {
                 let tv: libc::timeval = ptr::read_unaligned(p as *const _);
                 ControlMessageOwned::ScmTimestamp(TimeVal::from(tv))
@@ -710,6 +894,18 @@ impl ControlMessageOwned {
                 let ts: libc::timespec = ptr::read_unaligned(p as *const _);
                 ControlMessageOwned::ScmTimestampns(TimeSpec::from(ts))
             }
+            #[cfg(all(target_os = "linux"))]
+            (libc::SOL_SOCKET, libc::SCM_TIMESTAMPING) => {
+                let tp = p as *const libc::timespec;
+                let ts: libc::timespec = ptr::read_unaligned(tp);
+                let system = TimeSpec::from(ts);
+                let ts: libc::timespec = ptr::read_unaligned(tp.add(1));
+                let hw_trans = TimeSpec::from(ts);
+                let ts: libc::timespec = ptr::read_unaligned(tp.add(2));
+                let hw_raw = TimeSpec::from(ts);
+                let timestamping = Timestamps { system, hw_trans, hw_raw };
+                ControlMessageOwned::ScmTimestampsns(timestamping)
+            }
             #[cfg(any(
                 target_os = "android",
                 target_os = "freebsd",
@@ -717,6 +913,7 @@ impl ControlMessageOwned {
                 target_os = "linux",
                 target_os = "macos"
             ))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IPV6, libc::IPV6_PKTINFO) => {
                 let info = ptr::read_unaligned(p as *const libc::in6_pktinfo);
                 ControlMessageOwned::Ipv6PacketInfo(info)
@@ -728,6 +925,7 @@ impl ControlMessageOwned {
                 target_os = "macos",
                 target_os = "netbsd",
             ))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IP, libc::IP_PKTINFO) => {
                 let info = ptr::read_unaligned(p as *const libc::in_pktinfo);
                 ControlMessageOwned::Ipv4PacketInfo(info)
@@ -739,6 +937,7 @@ impl ControlMessageOwned {
                 target_os = "netbsd",
                 target_os = "openbsd",
             ))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IP, libc::IP_RECVIF) => {
                 let dl = ptr::read_unaligned(p as *const libc::sockaddr_dl);
                 ControlMessageOwned::Ipv4RecvIf(dl)
@@ -750,11 +949,19 @@ impl ControlMessageOwned {
                 target_os = "netbsd",
                 target_os = "openbsd",
             ))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IP, libc::IP_RECVDSTADDR) => {
                 let dl = ptr::read_unaligned(p as *const libc::in_addr);
                 ControlMessageOwned::Ipv4RecvDstAddr(dl)
             },
+            #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+            #[cfg(feature = "net")]
+            (libc::IPPROTO_IP, libc::IP_ORIGDSTADDR) => {
+                let dl = ptr::read_unaligned(p as *const libc::sockaddr_in);
+                ControlMessageOwned::Ipv4OrigDstAddr(dl)
+            },
             #[cfg(target_os = "linux")]
+            #[cfg(feature = "net")]
             (libc::SOL_UDP, libc::UDP_GRO) => {
                 let gso_size: u16 = ptr::read_unaligned(p as *const _);
                 ControlMessageOwned::UdpGroSegments(gso_size)
@@ -765,15 +972,23 @@ impl ControlMessageOwned {
                 ControlMessageOwned::RxqOvfl(drop_counter)
             },
             #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IP, libc::IP_RECVERR) => {
                 let (err, addr) = Self::recv_err_helper::<sockaddr_in>(p, len);
                 ControlMessageOwned::Ipv4RecvErr(err, addr)
             },
             #[cfg(any(target_os = "android", target_os = "linux"))]
+            #[cfg(feature = "net")]
             (libc::IPPROTO_IPV6, libc::IPV6_RECVERR) => {
                 let (err, addr) = Self::recv_err_helper::<sockaddr_in6>(p, len);
                 ControlMessageOwned::Ipv6RecvErr(err, addr)
             },
+            #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+            #[cfg(feature = "net")]
+            (libc::IPPROTO_IPV6, libc::IPV6_ORIGDSTADDR) => {
+                let dl = ptr::read_unaligned(p as *const libc::sockaddr_in6);
+                ControlMessageOwned::Ipv6OrigDstAddr(dl)
+            },
             (_, _) => {
                 let sl = slice::from_raw_parts(p, len);
                 let ucmsg = UnknownCmsg(*header, Vec::<u8>::from(sl));
@@ -783,6 +998,8 @@ impl ControlMessageOwned {
     }
 
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg(feature = "net")]
+    #[allow(clippy::cast_ptr_alignment)]    // False positive
     unsafe fn recv_err_helper<T>(p: *mut libc::c_uchar, len: usize) -> (libc::sock_extended_err, Option<T>) {
         let ee = p as *const libc::sock_extended_err;
         let err = ptr::read_unaligned(ee);
@@ -832,6 +1049,7 @@ pub enum ControlMessage<'a> {
     /// For further information, please refer to the
     /// [`unix(7)`](https://man7.org/linux/man-pages/man7/unix.7.html) man page.
     #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ScmCredentials(&'a UnixCredentials),
     /// A message of type `SCM_CREDS`, containing the pid, uid, euid, gid and groups of
     /// a process connected to the socket.
@@ -846,6 +1064,7 @@ pub enum ControlMessage<'a> {
     /// For further information, please refer to the
     /// [`unix(4)`](https://www.freebsd.org/cgi/man.cgi?query=unix) man page.
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ScmCreds,
 
     /// Set IV for `AF_ALG` crypto API.
@@ -856,6 +1075,7 @@ pub enum ControlMessage<'a> {
         target_os = "android",
         target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AlgSetIv(&'a [u8]),
     /// Set crypto operation for `AF_ALG` crypto API. It may be one of
     /// `ALG_OP_ENCRYPT` or `ALG_OP_DECRYPT`
@@ -866,6 +1086,7 @@ pub enum ControlMessage<'a> {
         target_os = "android",
         target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AlgSetOp(&'a libc::c_int),
     /// Set the length of associated authentication data (AAD) (applicable only to AEAD algorithms)
     /// for `AF_ALG` crypto API.
@@ -876,6 +1097,7 @@ pub enum ControlMessage<'a> {
         target_os = "android",
         target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AlgSetAeadAssoclen(&'a u32),
 
     /// UDP GSO makes it possible for applications to generate network packets
@@ -887,6 +1109,8 @@ pub enum ControlMessage<'a> {
     /// Send buffer should consist of multiple fixed-size wire payloads
     /// following one by one, and the last, possibly smaller one.
     #[cfg(target_os = "linux")]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     UdpGsoSegments(&'a u16),
 
     /// Configure the sending addressing and interface for v4
@@ -898,6 +1122,8 @@ pub enum ControlMessage<'a> {
               target_os = "netbsd",
               target_os = "android",
               target_os = "ios",))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv4PacketInfo(&'a libc::in_pktinfo),
 
     /// Configure the sending addressing and interface for v6
@@ -910,15 +1136,37 @@ pub enum ControlMessage<'a> {
               target_os = "freebsd",
               target_os = "android",
               target_os = "ios",))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     Ipv6PacketInfo(&'a libc::in6_pktinfo),
 
+    /// Configure the IPv4 source address with `IP_SENDSRCADDR`.
+    #[cfg(any(
+        target_os = "netbsd",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "dragonfly",
+    ))]
+    #[cfg(feature = "net")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    Ipv4SendSrcAddr(&'a libc::in_addr),
+
     /// SO_RXQ_OVFL indicates that an unsigned 32 bit value
     /// ancilliary msg (cmsg) should be attached to recieved
     /// skbs indicating the number of packets dropped by the
     /// socket between the last recieved packet and this
     /// received packet.
     #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     RxqOvfl(&'a u32),
+
+    /// Configure the transmission time of packets.
+    ///
+    /// For further information, please refer to the
+    /// [`tc-etf(8)`](https://man7.org/linux/man-pages/man8/tc-etf.8.html) man
+    /// page.
+    #[cfg(target_os = "linux")]
+    TxTime(&'a u64),
 }
 
 // An opaque structure used to prevent cmsghdr from being a public type
@@ -998,21 +1246,32 @@ impl<'a> ControlMessage<'a> {
                 len as *const _ as *const u8
             },
             #[cfg(target_os = "linux")]
+            #[cfg(feature = "net")]
             ControlMessage::UdpGsoSegments(gso_size) => {
                 gso_size as *const _ as *const u8
             },
             #[cfg(any(target_os = "linux", target_os = "macos",
                       target_os = "netbsd", target_os = "android",
                       target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv4PacketInfo(info) => info as *const _ as *const u8,
             #[cfg(any(target_os = "linux", target_os = "macos",
                       target_os = "netbsd", target_os = "freebsd",
                       target_os = "android", target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv6PacketInfo(info) => info as *const _ as *const u8,
+            #[cfg(any(target_os = "netbsd", target_os = "freebsd",
+                      target_os = "openbsd", target_os = "dragonfly"))]
+            #[cfg(feature = "net")]
+            ControlMessage::Ipv4SendSrcAddr(addr) => addr as *const _ as *const u8,
             #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
             ControlMessage::RxqOvfl(drop_count) => {
                 drop_count as *const _ as *const u8
             },
+            #[cfg(target_os = "linux")]
+            ControlMessage::TxTime(tx_time) => {
+                tx_time as *const _ as *const u8
+            },
         };
         unsafe {
             ptr::copy_nonoverlapping(
@@ -1039,7 +1298,7 @@ impl<'a> ControlMessage<'a> {
             }
             #[cfg(any(target_os = "android", target_os = "linux"))]
             ControlMessage::AlgSetIv(iv) => {
-                mem::size_of_val(&iv) + iv.len()
+                mem::size_of::<&[u8]>() + iv.len()
             },
             #[cfg(any(target_os = "android", target_os = "linux"))]
             ControlMessage::AlgSetOp(op) => {
@@ -1050,21 +1309,32 @@ impl<'a> ControlMessage<'a> {
                 mem::size_of_val(len)
             },
             #[cfg(target_os = "linux")]
+            #[cfg(feature = "net")]
             ControlMessage::UdpGsoSegments(gso_size) => {
                 mem::size_of_val(gso_size)
             },
             #[cfg(any(target_os = "linux", target_os = "macos",
               target_os = "netbsd", target_os = "android",
               target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv4PacketInfo(info) => mem::size_of_val(info),
             #[cfg(any(target_os = "linux", target_os = "macos",
               target_os = "netbsd", target_os = "freebsd",
               target_os = "android", target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv6PacketInfo(info) => mem::size_of_val(info),
+            #[cfg(any(target_os = "netbsd", target_os = "freebsd",
+                      target_os = "openbsd", target_os = "dragonfly"))]
+            #[cfg(feature = "net")]
+            ControlMessage::Ipv4SendSrcAddr(addr) => mem::size_of_val(addr),
             #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
             ControlMessage::RxqOvfl(drop_count) => {
                 mem::size_of_val(drop_count)
             },
+            #[cfg(target_os = "linux")]
+            ControlMessage::TxTime(tx_time) => {
+                mem::size_of_val(tx_time)
+            },
         }
     }
 
@@ -1080,17 +1350,26 @@ impl<'a> ControlMessage<'a> {
             ControlMessage::AlgSetIv(_) | ControlMessage::AlgSetOp(_) |
                 ControlMessage::AlgSetAeadAssoclen(_) => libc::SOL_ALG,
             #[cfg(target_os = "linux")]
+            #[cfg(feature = "net")]
             ControlMessage::UdpGsoSegments(_) => libc::SOL_UDP,
             #[cfg(any(target_os = "linux", target_os = "macos",
                       target_os = "netbsd", target_os = "android",
                       target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv4PacketInfo(_) => libc::IPPROTO_IP,
             #[cfg(any(target_os = "linux", target_os = "macos",
               target_os = "netbsd", target_os = "freebsd",
               target_os = "android", target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv6PacketInfo(_) => libc::IPPROTO_IPV6,
+            #[cfg(any(target_os = "netbsd", target_os = "freebsd",
+                      target_os = "openbsd", target_os = "dragonfly"))]
+            #[cfg(feature = "net")]
+            ControlMessage::Ipv4SendSrcAddr(_) => libc::IPPROTO_IP,
             #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
             ControlMessage::RxqOvfl(_) => libc::SOL_SOCKET,
+            #[cfg(target_os = "linux")]
+            ControlMessage::TxTime(_) => libc::SOL_SOCKET,
         }
     }
 
@@ -1115,21 +1394,32 @@ impl<'a> ControlMessage<'a> {
                 libc::ALG_SET_AEAD_ASSOCLEN
             },
             #[cfg(target_os = "linux")]
+            #[cfg(feature = "net")]
             ControlMessage::UdpGsoSegments(_) => {
                 libc::UDP_SEGMENT
             },
             #[cfg(any(target_os = "linux", target_os = "macos",
                       target_os = "netbsd", target_os = "android",
                       target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv4PacketInfo(_) => libc::IP_PKTINFO,
             #[cfg(any(target_os = "linux", target_os = "macos",
                       target_os = "netbsd", target_os = "freebsd",
                       target_os = "android", target_os = "ios",))]
+            #[cfg(feature = "net")]
             ControlMessage::Ipv6PacketInfo(_) => libc::IPV6_PKTINFO,
+            #[cfg(any(target_os = "netbsd", target_os = "freebsd",
+                      target_os = "openbsd", target_os = "dragonfly"))]
+            #[cfg(feature = "net")]
+            ControlMessage::Ipv4SendSrcAddr(_) => libc::IP_SENDSRCADDR,
             #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
             ControlMessage::RxqOvfl(_) => {
                 libc::SO_RXQ_OVFL
             },
+            #[cfg(target_os = "linux")]
+            ControlMessage::TxTime(_) => {
+                libc::SCM_TXTIME
+            },
         }
     }
 
@@ -1149,8 +1439,42 @@ impl<'a> ControlMessage<'a> {
 /// as with sendto.
 ///
 /// Allocates if cmsgs is nonempty.
-pub fn sendmsg(fd: RawFd, iov: &[IoVec<&[u8]>], cmsgs: &[ControlMessage],
-               flags: MsgFlags, addr: Option<&SockAddr>) -> Result<usize>
+///
+/// # Examples
+/// When not directing to any specific address, use `()` for the generic type
+/// ```
+/// # use nix::sys::socket::*;
+/// # use nix::unistd::pipe;
+/// # use std::io::IoSlice;
+/// let (fd1, fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None,
+///     SockFlag::empty())
+///     .unwrap();
+/// let (r, w) = pipe().unwrap();
+///
+/// let iov = [IoSlice::new(b"hello")];
+/// let fds = [r];
+/// let cmsg = ControlMessage::ScmRights(&fds);
+/// sendmsg::<()>(fd1, &iov, &[cmsg], MsgFlags::empty(), None).unwrap();
+/// ```
+/// When directing to a specific address, the generic type will be inferred.
+/// ```
+/// # use nix::sys::socket::*;
+/// # use nix::unistd::pipe;
+/// # use std::io::IoSlice;
+/// # use std::str::FromStr;
+/// let localhost = SockaddrIn::from_str("1.2.3.4:8080").unwrap();
+/// let fd = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(),
+///     None).unwrap();
+/// let (r, w) = pipe().unwrap();
+///
+/// let iov = [IoSlice::new(b"hello")];
+/// let fds = [r];
+/// let cmsg = ControlMessage::ScmRights(&fds);
+/// sendmsg(fd, &iov, &[cmsg], MsgFlags::empty(), Some(&localhost)).unwrap();
+/// ```
+pub fn sendmsg<S>(fd: RawFd, iov: &[IoSlice<'_>], cmsgs: &[ControlMessage],
+               flags: MsgFlags, addr: Option<&S>) -> Result<usize>
+    where S: SockaddrLike
 {
     let capacity = cmsgs.iter().map(|c| c.space()).sum();
 
@@ -1158,30 +1482,13 @@ pub fn sendmsg(fd: RawFd, iov: &[IoVec<&[u8]>], cmsgs: &[ControlMessage],
     // because subsequent code will not clear the padding bytes.
     let mut cmsg_buffer = vec![0u8; capacity];
 
-    let mhdr = pack_mhdr_to_send(&mut cmsg_buffer[..], &iov, &cmsgs, addr);
+    let mhdr = pack_mhdr_to_send(&mut cmsg_buffer[..], iov, cmsgs, addr);
 
     let ret = unsafe { libc::sendmsg(fd, &mhdr, flags.bits()) };
 
     Errno::result(ret).map(|r| r as usize)
 }
 
-#[cfg(any(
-    target_os = "linux",
-    target_os = "android",
-    target_os = "freebsd",
-    target_os = "netbsd",
-))]
-#[derive(Debug)]
-pub struct SendMmsgData<'a, I, C>
-    where
-        I: AsRef<[IoVec<&'a [u8]>]>,
-        C: AsRef<[ControlMessage<'a>]>
-{
-    pub iov: I,
-    pub cmsgs: C,
-    pub addr: Option<SockAddr>,
-    pub _lt: std::marker::PhantomData<&'a I>,
-}
 
 /// An extension of `sendmsg` that allows the caller to transmit multiple
 /// messages on a socket using a single system call. This has performance
@@ -1206,50 +1513,66 @@ pub struct SendMmsgData<'a, I, C>
     target_os = "freebsd",
     target_os = "netbsd",
 ))]
-pub fn sendmmsg<'a, I, C>(
+pub fn sendmmsg<'a, XS, AS, C, I, S>(
     fd: RawFd,
-    data: impl std::iter::IntoIterator<Item=&'a SendMmsgData<'a, I, C>>,
+    data: &'a mut MultiHeaders<S>,
+    slices: XS,
+    // one address per group of slices
+    addrs: AS,
+    // shared across all the messages
+    cmsgs: C,
     flags: MsgFlags
-) -> Result<Vec<usize>>
+) -> crate::Result<MultiResults<'a, S>>
     where
-        I: AsRef<[IoVec<&'a [u8]>]> + 'a,
+        XS: IntoIterator<Item = &'a I>,
+        AS: AsRef<[Option<S>]>,
+        I: AsRef<[IoSlice<'a>]> + 'a,
         C: AsRef<[ControlMessage<'a>]> + 'a,
+        S: SockaddrLike + 'a
 {
-    let iter = data.into_iter();
-
-    let size_hint = iter.size_hint();
-    let reserve_items = size_hint.1.unwrap_or(size_hint.0);
-
-    let mut output = Vec::<libc::mmsghdr>::with_capacity(reserve_items);
 
-    let mut cmsgs_buffers = Vec::<Vec<u8>>::with_capacity(reserve_items);
+    let mut count = 0;
 
-    for d in iter {
-        let capacity: usize = d.cmsgs.as_ref().iter().map(|c| c.space()).sum();
-        let mut cmsgs_buffer = vec![0u8; capacity];
 
-        output.push(libc::mmsghdr {
-            msg_hdr: pack_mhdr_to_send(
-                &mut cmsgs_buffer,
-                &d.iov,
-                &d.cmsgs,
-                d.addr.as_ref()
-            ),
-            msg_len: 0,
-        });
-        cmsgs_buffers.push(cmsgs_buffer);
-    };
+    for (i, ((slice, addr), mmsghdr)) in slices.into_iter().zip(addrs.as_ref()).zip(data.items.iter_mut() ).enumerate() {
+        let mut p = &mut mmsghdr.msg_hdr;
+        p.msg_iov = slice.as_ref().as_ptr() as *mut libc::iovec;
+        p.msg_iovlen = slice.as_ref().len() as _;
 
-    let ret = unsafe { libc::sendmmsg(fd, output.as_mut_ptr(), output.len() as _, flags.bits() as _) };
+        p.msg_namelen = addr.as_ref().map_or(0, S::len);
+        p.msg_name = addr.as_ref().map_or(ptr::null(), S::as_ptr) as _;
 
-    let sent_messages = Errno::result(ret)? as usize;
-    let mut sent_bytes = Vec::with_capacity(sent_messages);
+        // Encode each cmsg.  This must happen after initializing the header because
+        // CMSG_NEXT_HDR and friends read the msg_control and msg_controllen fields.
+        // CMSG_FIRSTHDR is always safe
+        let mut pmhdr: *mut cmsghdr = unsafe { CMSG_FIRSTHDR(p) };
+        for cmsg in cmsgs.as_ref() {
+            assert_ne!(pmhdr, ptr::null_mut());
+            // Safe because we know that pmhdr is valid, and we initialized it with
+            // sufficient space
+            unsafe { cmsg.encode_into(pmhdr) };
+            // Safe because mhdr is valid
+            pmhdr = unsafe { CMSG_NXTHDR(p, pmhdr) };
+        }
 
-    for item in &output {
-        sent_bytes.push(item.msg_len as usize);
+        count = i+1;
     }
 
-    Ok(sent_bytes)
+    let sent = Errno::result(unsafe {
+        libc::sendmmsg(
+            fd,
+            data.items.as_mut_ptr(),
+            count as _,
+            flags.bits() as _
+        )
+    })? as usize;
+
+    Ok(MultiResults {
+        rmm: data,
+        current_index: 0,
+        received: sent
+    })
+
 }
 
 
@@ -1260,131 +1583,347 @@ pub fn sendmmsg<'a, I, C>(
     target_os = "netbsd",
 ))]
 #[derive(Debug)]
-pub struct RecvMmsgData<'a, I>
+/// Preallocated structures needed for [`recvmmsg`] and [`sendmmsg`] functions
+pub struct MultiHeaders<S> {
+    // preallocated boxed slice of mmsghdr
+    items: Box<[libc::mmsghdr]>,
+    addresses: Box<[mem::MaybeUninit<S>]>,
+    // while we are not using it directly - this is used to store control messages
+    // and we retain pointers to them inside items array
+    #[allow(dead_code)]
+    cmsg_buffers: Option<Box<[u8]>>,
+    msg_controllen: usize,
+}
+
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "netbsd",
+))]
+impl<S> MultiHeaders<S> {
+    /// Preallocate structure used by [`recvmmsg`] and [`sendmmsg`] takes number of headers to preallocate
+    ///
+    /// `cmsg_buffer` should be created with [`cmsg_space!`] if needed
+    pub fn preallocate(num_slices: usize, cmsg_buffer: Option<Vec<u8>>) -> Self
     where
-        I: AsRef<[IoVec<&'a mut [u8]>]> + 'a,
-{
-    pub iov: I,
-    pub cmsg_buffer: Option<&'a mut Vec<u8>>,
+        S: Copy + SockaddrLike,
+    {
+        // we will be storing pointers to addresses inside mhdr - convert it into boxed
+        // slice so it can'be changed later by pushing anything into self.addresses
+        let mut addresses = vec![std::mem::MaybeUninit::uninit(); num_slices].into_boxed_slice();
+
+        let msg_controllen = cmsg_buffer.as_ref().map_or(0, |v| v.capacity());
+
+        // we'll need a cmsg_buffer for each slice, we preallocate a vector and split
+        // it into "slices" parts
+        let cmsg_buffers =
+            cmsg_buffer.map(|v| vec![0u8; v.capacity() * num_slices].into_boxed_slice());
+
+        let items = addresses
+            .iter_mut()
+            .enumerate()
+            .map(|(ix, address)| {
+                let (ptr, cap) = match &cmsg_buffers {
+                    Some(v) => ((&v[ix * msg_controllen] as *const u8), msg_controllen),
+                    None => (std::ptr::null(), 0),
+                };
+                let msg_hdr = unsafe { pack_mhdr_to_receive(std::ptr::null(), 0, ptr, cap, address.as_mut_ptr()) };
+                libc::mmsghdr {
+                    msg_hdr,
+                    msg_len: 0,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        Self {
+            items: items.into_boxed_slice(),
+            addresses,
+            cmsg_buffers,
+            msg_controllen,
+        }
+    }
 }
 
-/// An extension of `recvmsg` that allows the caller to receive multiple
-/// messages from a socket using a single system call. This has
-/// performance benefits for some applications.
-///
-/// `iov` and `cmsg_buffer` should be constructed similarly to `recvmsg`
-///
-/// Multiple allocations are performed
-///
-/// # Arguments
+/// An extension of recvmsg that allows the caller to receive multiple messages from a socket using a single system call.
 ///
-/// * `fd`:             Socket file descriptor
-/// * `data`:           Struct that implements `IntoIterator` with `RecvMmsgData` items
-/// * `flags`:          Optional flags passed directly to the operating system.
+/// This has performance benefits for some applications.
 ///
-/// # RecvMmsgData
+/// This method performs no allocations.
 ///
-/// * `iov`:            Scatter-gather list of buffers to receive the message
-/// * `cmsg_buffer`:    Space to receive ancillary data.  Should be created by
-///                     [`cmsg_space!`](macro.cmsg_space.html)
+/// Returns an iterator producing [`RecvMsg`], one per received messages. Each `RecvMsg` can produce
+/// iterators over [`IoSlice`] with [`iovs`][RecvMsg::iovs`] and
+/// `ControlMessageOwned` with [`cmsgs`][RecvMsg::cmsgs].
 ///
-/// # Returns
-/// A `Vec` with multiple `RecvMsg`, one per received message
+/// # Bugs (in underlying implementation, at least in Linux)
+/// The timeout argument does not work as intended. The timeout is checked only after the receipt
+/// of each datagram, so that if up to `vlen`-1 datagrams are received before the timeout expires,
+/// but then no further datagrams are received, the call will block forever.
 ///
-/// # References
-/// - [`recvmsg`](fn.recvmsg.html)
-/// - [`RecvMsg`](struct.RecvMsg.html)
+/// If an error occurs after at least one message has been received, the call succeeds, and returns
+/// the number of messages received. The error code is expected to be returned on a subsequent
+/// call to recvmmsg(). In the current implementation, however, the error code can be
+/// overwritten in the meantime by an unrelated network event on a socket, for example an
+/// incoming ICMP packet.
+
+// On aarch64 linux using recvmmsg and trying to get hardware/kernel timestamps might not
+// always produce the desired results - see https://github.com/nix-rust/nix/pull/1744 for more
+// details
+
 #[cfg(any(
     target_os = "linux",
     target_os = "android",
     target_os = "freebsd",
     target_os = "netbsd",
 ))]
-#[allow(clippy::needless_collect)]  // Complicated false positive
-pub fn recvmmsg<'a, I>(
+pub fn recvmmsg<'a, XS, S, I>(
     fd: RawFd,
-    data: impl std::iter::IntoIterator<Item=&'a mut RecvMmsgData<'a, I>,
-        IntoIter=impl ExactSizeIterator + Iterator<Item=&'a mut RecvMmsgData<'a, I>>>,
+    data: &'a mut MultiHeaders<S>,
+    slices: XS,
     flags: MsgFlags,
-    timeout: Option<crate::sys::time::TimeSpec>
-) -> Result<Vec<RecvMsg<'a>>>
-    where
-        I: AsRef<[IoVec<&'a mut [u8]>]> + 'a,
+    mut timeout: Option<crate::sys::time::TimeSpec>,
+) -> crate::Result<MultiResults<'a, S>>
+where
+    XS: IntoIterator<Item = &'a I>,
+    I: AsRef<[IoSliceMut<'a>]> + 'a,
 {
-    let iter = data.into_iter();
+    let mut count = 0;
+    for (i, (slice, mmsghdr)) in slices.into_iter().zip(data.items.iter_mut()).enumerate() {
+        let mut p = &mut mmsghdr.msg_hdr;
+        p.msg_iov = slice.as_ref().as_ptr() as *mut libc::iovec;
+        p.msg_iovlen = slice.as_ref().len() as _;
+        count = i + 1;
+    }
 
-    let num_messages = iter.len();
+    let timeout_ptr = timeout
+        .as_mut()
+        .map_or_else(std::ptr::null_mut, |t| t as *mut _ as *mut libc::timespec);
 
-    let mut output: Vec<libc::mmsghdr> = Vec::with_capacity(num_messages);
+    let received = Errno::result(unsafe {
+        libc::recvmmsg(
+            fd,
+            data.items.as_mut_ptr(),
+            count as _,
+            flags.bits() as _,
+            timeout_ptr,
+        )
+    })? as usize;
+
+    Ok(MultiResults {
+        rmm: data,
+        current_index: 0,
+        received,
+    })
+}
 
-    // Addresses should be pre-allocated.  pack_mhdr_to_receive will store them
-    // as raw pointers, so we may not move them.  Turn the vec into a boxed
-    // slice so we won't inadvertently reallocate the vec.
-    let mut addresses = vec![mem::MaybeUninit::uninit(); num_messages]
-        .into_boxed_slice();
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "netbsd",
+))]
+#[derive(Debug)]
+/// Iterator over results of [`recvmmsg`]/[`sendmmsg`]
+///
+///
+pub struct MultiResults<'a, S> {
+    // preallocated structures
+    rmm: &'a MultiHeaders<S>,
+    current_index: usize,
+    received: usize,
+}
 
-    let results: Vec<_> = iter.enumerate().map(|(i, d)| {
-        let (msg_controllen, mhdr) = unsafe {
-            pack_mhdr_to_receive(
-                d.iov.as_ref(),
-                &mut d.cmsg_buffer,
-                addresses[i].as_mut_ptr(),
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "netbsd",
+))]
+impl<'a, S> Iterator for MultiResults<'a, S>
+where
+    S: Copy + SockaddrLike,
+{
+    type Item = RecvMsg<'a, 'a, S>;
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current_index >= self.received {
+            return None;
+        }
+        let mmsghdr = self.rmm.items[self.current_index];
+
+        // as long as we are not reading past the index writen by recvmmsg - address
+        // will be initialized
+        let address = unsafe { self.rmm.addresses[self.current_index].assume_init() };
+
+        self.current_index += 1;
+        Some(unsafe {
+            read_mhdr(
+                mmsghdr.msg_hdr,
+                mmsghdr.msg_len as isize,
+                self.rmm.msg_controllen,
+                address,
             )
+        })
+    }
+}
+
+impl<'a, S> RecvMsg<'_, 'a, S> {
+    /// Iterate over the filled io slices pointed by this msghdr
+    pub fn iovs(&self) -> IoSliceIterator<'a> {
+        IoSliceIterator {
+            index: 0,
+            remaining: self.bytes,
+            slices: unsafe {
+                // safe for as long as mgdr is properly initialized and references are valid.
+                // for multi messages API we initialize it with an empty
+                // slice and replace with a concrete buffer
+                // for single message API we hold a lifetime reference to ioslices
+                std::slice::from_raw_parts(self.mhdr.msg_iov as *const _, self.mhdr.msg_iovlen as _)
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct IoSliceIterator<'a> {
+    index: usize,
+    remaining: usize,
+    slices: &'a [IoSlice<'a>],
+}
+
+impl<'a> Iterator for IoSliceIterator<'a> {
+    type Item = &'a [u8];
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index >= self.slices.len() {
+            return None;
+        }
+        let slice = &self.slices[self.index][..self.remaining.min(self.slices[self.index].len())];
+        self.remaining -= slice.len();
+        self.index += 1;
+        if slice.is_empty() {
+            return None;
+        }
+
+        Some(slice)
+    }
+}
+
+// test contains both recvmmsg and timestaping which is linux only
+// there are existing tests for recvmmsg only in tests/
+#[cfg(target_os = "linux")]
+#[cfg(test)]
+mod test {
+    use crate::sys::socket::{AddressFamily, ControlMessageOwned};
+    use crate::*;
+    use std::str::FromStr;
+
+    #[cfg_attr(qemu, ignore)]
+    #[test]
+    fn test_recvmm2() -> crate::Result<()> {
+        use crate::sys::socket::{
+            sendmsg, setsockopt, socket, sockopt::Timestamping, MsgFlags, SockFlag, SockType,
+            SockaddrIn, TimestampingFlag,
         };
+        use std::io::{IoSlice, IoSliceMut};
 
-        output.push(
-            libc::mmsghdr {
-                msg_hdr: mhdr,
-                msg_len: 0,
-            }
-        );
+        let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap();
 
-        (msg_controllen as usize, &mut d.cmsg_buffer)
-    }).collect();
+        let ssock = socket(
+            AddressFamily::Inet,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )?;
 
-    let timeout = if let Some(mut t) = timeout {
-        t.as_mut() as *mut libc::timespec
-    } else {
-        ptr::null_mut()
-    };
+        let rsock = socket(
+            AddressFamily::Inet,
+            SockType::Datagram,
+            SockFlag::SOCK_NONBLOCK,
+            None,
+        )?;
+
+        crate::sys::socket::bind(rsock, &sock_addr)?;
+
+        setsockopt(rsock, Timestamping, &TimestampingFlag::all())?;
 
-    let ret = unsafe { libc::recvmmsg(fd, output.as_mut_ptr(), output.len() as _, flags.bits() as _, timeout) };
-
-    let _ = Errno::result(ret)?;
-
-    Ok(output
-        .into_iter()
-        .take(ret as usize)
-        .zip(addresses.iter().map(|addr| unsafe{addr.assume_init()}))
-        .zip(results.into_iter())
-        .map(|((mmsghdr, address), (msg_controllen, cmsg_buffer))| {
-            unsafe {
-                read_mhdr(
-                    mmsghdr.msg_hdr,
-                    mmsghdr.msg_len as isize,
-                    msg_controllen,
-                    address,
-                    cmsg_buffer
-                )
+        let sbuf = (0..400).map(|i| i as u8).collect::<Vec<_>>();
+
+        let mut recv_buf = vec![0; 1024];
+
+        let mut recv_iovs = Vec::new();
+        let mut pkt_iovs = Vec::new();
+
+        for (ix, chunk) in recv_buf.chunks_mut(256).enumerate() {
+            pkt_iovs.push(IoSliceMut::new(chunk));
+            if ix % 2 == 1 {
+                recv_iovs.push(pkt_iovs);
+                pkt_iovs = Vec::new();
+            }
+        }
+        drop(pkt_iovs);
+
+        let flags = MsgFlags::empty();
+        let iov1 = [IoSlice::new(&sbuf)];
+
+        let cmsg = cmsg_space!(crate::sys::socket::Timestamps);
+        sendmsg(ssock, &iov1, &[], flags, Some(&sock_addr)).unwrap();
+
+        let mut data = super::MultiHeaders::<()>::preallocate(recv_iovs.len(), Some(cmsg));
+
+        let t = sys::time::TimeSpec::from_duration(std::time::Duration::from_secs(10));
+
+        let recv = super::recvmmsg(rsock, &mut data, recv_iovs.iter(), flags, Some(t))?;
+
+        for rmsg in recv {
+            #[cfg(not(any(qemu, target_arch = "aarch64")))]
+            let mut saw_time = false;
+            let mut recvd = 0;
+            for cmsg in rmsg.cmsgs() {
+                if let ControlMessageOwned::ScmTimestampsns(timestamps) = cmsg {
+                    let ts = timestamps.system;
+
+                    let sys_time =
+                        crate::time::clock_gettime(crate::time::ClockId::CLOCK_REALTIME)?;
+                    let diff = if ts > sys_time {
+                        ts - sys_time
+                    } else {
+                        sys_time - ts
+                    };
+                    assert!(std::time::Duration::from(diff).as_secs() < 60);
+                    #[cfg(not(any(qemu, target_arch = "aarch64")))]
+                    {
+                        saw_time = true;
+                    }
+                }
             }
-        })
-        .collect())
-}
 
-unsafe fn read_mhdr<'a, 'b>(
+            #[cfg(not(any(qemu, target_arch = "aarch64")))]
+            assert!(saw_time);
+
+            for iov in rmsg.iovs() {
+                recvd += iov.len();
+            }
+            assert_eq!(recvd, 400);
+        }
+
+        Ok(())
+    }
+}
+unsafe fn read_mhdr<'a, 'i, S>(
     mhdr: msghdr,
     r: isize,
     msg_controllen: usize,
-    address: sockaddr_storage,
-    cmsg_buffer: &'a mut Option<&'b mut Vec<u8>>
-) -> RecvMsg<'b> {
+    address: S,
+) -> RecvMsg<'a, 'i, S>
+    where S: SockaddrLike
+{
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     let cmsghdr = {
         if mhdr.msg_controllen > 0 {
-            // got control message(s)
-            cmsg_buffer
-                .as_mut()
-                .unwrap()
-                .set_len(mhdr.msg_controllen as usize);
             debug_assert!(!mhdr.msg_control.is_null());
             debug_assert!(msg_controllen >= mhdr.msg_controllen as usize);
             CMSG_FIRSTHDR(&mhdr as *const msghdr)
@@ -1393,71 +1932,64 @@ unsafe fn read_mhdr<'a, 'b>(
         }.as_ref()
     };
 
-    let address = sockaddr_storage_to_addr(
-        &address ,
-         mhdr.msg_namelen as usize
-    ).ok();
-
     RecvMsg {
         bytes: r as usize,
         cmsghdr,
-        address,
+        address: Some(address),
         flags: MsgFlags::from_bits_truncate(mhdr.msg_flags),
         mhdr,
+        iobufs: std::marker::PhantomData,
     }
 }
 
-unsafe fn pack_mhdr_to_receive<'a, I>(
-    iov: I,
-    cmsg_buffer: &mut Option<&mut Vec<u8>>,
-    address: *mut sockaddr_storage,
-) -> (usize, msghdr)
+/// Pack pointers to various structures into into msghdr
+///
+/// # Safety
+/// `iov_buffer` and `iov_buffer_len` must point to a slice
+/// of `IoSliceMut` and number of available elements or be a null pointer and 0
+///
+/// `cmsg_buffer` and `cmsg_capacity` must point to a byte buffer used
+/// to store control headers later or be a null pointer and 0 if control
+/// headers are not used
+///
+/// Buffers must remain valid for the whole lifetime of msghdr
+unsafe fn pack_mhdr_to_receive<S>(
+    iov_buffer: *const IoSliceMut,
+    iov_buffer_len: usize,
+    cmsg_buffer: *const u8,
+    cmsg_capacity: usize,
+    address: *mut S,
+) -> msghdr
     where
-        I: AsRef<[IoVec<&'a mut [u8]>]> + 'a,
+        S: SockaddrLike
 {
-    let (msg_control, msg_controllen) = cmsg_buffer.as_mut()
-        .map(|v| (v.as_mut_ptr(), v.capacity()))
-        .unwrap_or((ptr::null_mut(), 0));
-
-    let mhdr = {
-        // Musl's msghdr has private fields, so this is the only way to
-        // initialize it.
-        let mut mhdr = mem::MaybeUninit::<msghdr>::zeroed();
-        let p = mhdr.as_mut_ptr();
-        (*p).msg_name = address as *mut c_void;
-        (*p).msg_namelen = mem::size_of::<sockaddr_storage>() as socklen_t;
-        (*p).msg_iov = iov.as_ref().as_ptr() as *mut iovec;
-        (*p).msg_iovlen = iov.as_ref().len() as _;
-        (*p).msg_control = msg_control as *mut c_void;
-        (*p).msg_controllen = msg_controllen as _;
-        (*p).msg_flags = 0;
-        mhdr.assume_init()
-    };
-
-    (msg_controllen, mhdr)
+    // Musl's msghdr has private fields, so this is the only way to
+    // initialize it.
+    let mut mhdr = mem::MaybeUninit::<msghdr>::zeroed();
+    let p = mhdr.as_mut_ptr();
+    (*p).msg_name = (*address).as_mut_ptr() as *mut c_void;
+    (*p).msg_namelen = S::size();
+    (*p).msg_iov = iov_buffer as *mut iovec;
+    (*p).msg_iovlen = iov_buffer_len as _;
+    (*p).msg_control = cmsg_buffer as *mut c_void;
+    (*p).msg_controllen = cmsg_capacity as _;
+    (*p).msg_flags = 0;
+    mhdr.assume_init()
 }
 
-fn pack_mhdr_to_send<'a, I, C>(
+fn pack_mhdr_to_send<'a, I, C, S>(
     cmsg_buffer: &mut [u8],
     iov: I,
     cmsgs: C,
-    addr: Option<&SockAddr>
+    addr: Option<&S>
 ) -> msghdr
     where
-        I: AsRef<[IoVec<&'a [u8]>]>,
-        C: AsRef<[ControlMessage<'a>]>
+        I: AsRef<[IoSlice<'a>]>,
+        C: AsRef<[ControlMessage<'a>]>,
+        S: SockaddrLike + 'a
 {
     let capacity = cmsg_buffer.len();
 
-    // Next encode the sending address, if provided
-    let (name, namelen) = match addr {
-        Some(addr) => {
-            let (x, y) = addr.as_ffi_pair();
-            (x as *const _, y)
-        },
-        None => (ptr::null(), 0),
-    };
-
     // The message header must be initialized before the individual cmsgs.
     let cmsg_ptr = if capacity > 0 {
         cmsg_buffer.as_ptr() as *mut c_void
@@ -1470,8 +2002,8 @@ fn pack_mhdr_to_send<'a, I, C>(
         // initialize it.
         let mut mhdr = mem::MaybeUninit::<msghdr>::zeroed();
         let p = mhdr.as_mut_ptr();
-        (*p).msg_name = name as *mut _;
-        (*p).msg_namelen = namelen;
+        (*p).msg_name = addr.map(S::as_ptr).unwrap_or(ptr::null()) as *mut _;
+        (*p).msg_namelen = addr.map(S::len).unwrap_or(0);
         // transmute iov into a mutable pointer.  sendmsg doesn't really mutate
         // the buffer, but the standard says that it takes a mutable pointer
         (*p).msg_iov = iov.as_ref().as_ptr() as *mut _;
@@ -1507,28 +2039,33 @@ fn pack_mhdr_to_send<'a, I, C>(
 /// * `fd`:             Socket file descriptor
 /// * `iov`:            Scatter-gather list of buffers to receive the message
 /// * `cmsg_buffer`:    Space to receive ancillary data.  Should be created by
-///                     [`cmsg_space!`](macro.cmsg_space.html)
+///                     [`cmsg_space!`](../../macro.cmsg_space.html)
 /// * `flags`:          Optional flags passed directly to the operating system.
 ///
 /// # References
 /// [recvmsg(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html)
-pub fn recvmsg<'a>(fd: RawFd, iov: &[IoVec<&mut [u8]>],
+pub fn recvmsg<'a, 'outer, 'inner, S>(fd: RawFd, iov: &'outer mut [IoSliceMut<'inner>],
                    mut cmsg_buffer: Option<&'a mut Vec<u8>>,
-                   flags: MsgFlags) -> Result<RecvMsg<'a>>
+                   flags: MsgFlags) -> Result<RecvMsg<'a, 'inner, S>>
+    where S: SockaddrLike + 'a,
+    'inner: 'outer
 {
     let mut address = mem::MaybeUninit::uninit();
 
-    let (msg_controllen, mut mhdr) = unsafe {
-        pack_mhdr_to_receive(&iov, &mut cmsg_buffer, address.as_mut_ptr())
+    let (msg_control, msg_controllen) = cmsg_buffer.as_mut()
+        .map(|v| (v.as_mut_ptr(), v.capacity()))
+        .unwrap_or((ptr::null_mut(), 0));
+    let mut mhdr = unsafe {
+        pack_mhdr_to_receive(iov.as_ref().as_ptr(), iov.len(), msg_control, msg_controllen, address.as_mut_ptr())
     };
 
     let ret = unsafe { libc::recvmsg(fd, &mut mhdr, flags.bits()) };
 
     let r = Errno::result(ret)?;
 
-    Ok(unsafe { read_mhdr(mhdr, r, msg_controllen, address.assume_init(), &mut cmsg_buffer) })
+    Ok(unsafe { read_mhdr(mhdr, r, msg_controllen, address.assume_init()) })
+}
 }
-
 
 /// Create an endpoint for communication
 ///
@@ -1540,7 +2077,12 @@ pub fn recvmsg<'a>(fd: RawFd, iov: &[IoVec<&mut [u8]>],
 /// specified in this manner.
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html)
-pub fn socket<T: Into<Option<SockProtocol>>>(domain: AddressFamily, ty: SockType, flags: SockFlag, protocol: T) -> Result<RawFd> {
+pub fn socket<T: Into<Option<SockProtocol>>>(
+    domain: AddressFamily,
+    ty: SockType,
+    flags: SockFlag,
+    protocol: T,
+) -> Result<RawFd> {
     let protocol = match protocol.into() {
         None => 0,
         Some(p) => p as c_int,
@@ -1560,8 +2102,12 @@ pub fn socket<T: Into<Option<SockProtocol>>>(domain: AddressFamily, ty: SockType
 /// Create a pair of connected sockets
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/socketpair.html)
-pub fn socketpair<T: Into<Option<SockProtocol>>>(domain: AddressFamily, ty: SockType, protocol: T,
-                  flags: SockFlag) -> Result<(RawFd, RawFd)> {
+pub fn socketpair<T: Into<Option<SockProtocol>>>(
+    domain: AddressFamily,
+    ty: SockType,
+    protocol: T,
+    flags: SockFlag,
+) -> Result<(RawFd, RawFd)> {
     let protocol = match protocol.into() {
         None => 0,
         Some(p) => p as c_int,
@@ -1575,7 +2121,9 @@ pub fn socketpair<T: Into<Option<SockProtocol>>>(domain: AddressFamily, ty: Sock
 
     let mut fds = [-1, -1];
 
-    let res = unsafe { libc::socketpair(domain as c_int, ty, protocol, fds.as_mut_ptr()) };
+    let res = unsafe {
+        libc::socketpair(domain as c_int, ty, protocol, fds.as_mut_ptr())
+    };
     Errno::result(res)?;
 
     Ok((fds[0], fds[1]))
@@ -1593,11 +2141,8 @@ pub fn listen(sockfd: RawFd, backlog: usize) -> Result<()> {
 /// Bind a name to a socket
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html)
-pub fn bind(fd: RawFd, addr: &SockAddr) -> Result<()> {
-    let res = unsafe {
-        let (ptr, len) = addr.as_ffi_pair();
-        libc::bind(fd, ptr, len)
-    };
+pub fn bind(fd: RawFd, addr: &dyn SockaddrLike) -> Result<()> {
+    let res = unsafe { libc::bind(fd, addr.as_ptr(), addr.len()) };
 
     Errno::result(res).map(drop)
 }
@@ -1614,19 +2159,28 @@ pub fn accept(sockfd: RawFd) -> Result<RawFd> {
 /// Accept a connection on a socket
 ///
 /// [Further reading](https://man7.org/linux/man-pages/man2/accept.2.html)
-#[cfg(any(all(
-            target_os = "android",
-            any(
-                target_arch = "aarch64",
-                target_arch = "x86",
-                target_arch = "x86_64"
-            )
-          ),
-          target_os = "freebsd",
-          target_os = "linux",
-          target_os = "openbsd"))]
+#[cfg(any(
+    all(
+        target_os = "android",
+        any(
+            target_arch = "aarch64",
+            target_arch = "x86",
+            target_arch = "x86_64"
+        )
+    ),
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "freebsd",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "linux",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 pub fn accept4(sockfd: RawFd, flags: SockFlag) -> Result<RawFd> {
-    let res = unsafe { libc::accept4(sockfd, ptr::null_mut(), ptr::null_mut(), flags.bits()) };
+    let res = unsafe {
+        libc::accept4(sockfd, ptr::null_mut(), ptr::null_mut(), flags.bits())
+    };
 
     Errno::result(res)
 }
@@ -1634,11 +2188,8 @@ pub fn accept4(sockfd: RawFd, flags: SockFlag) -> Result<RawFd> {
 /// Initiate a connection on a socket
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html)
-pub fn connect(fd: RawFd, addr: &SockAddr) -> Result<()> {
-    let res = unsafe {
-        let (ptr, len) = addr.as_ffi_pair();
-        libc::connect(fd, ptr, len)
-    };
+pub fn connect(fd: RawFd, addr: &dyn SockaddrLike) -> Result<()> {
+    let res = unsafe { libc::connect(fd, addr.as_ptr(), addr.len()) };
 
     Errno::result(res).map(drop)
 }
@@ -1653,7 +2204,8 @@ pub fn recv(sockfd: RawFd, buf: &mut [u8], flags: MsgFlags) -> Result<usize> {
             sockfd,
             buf.as_ptr() as *mut c_void,
             buf.len() as size_t,
-            flags.bits());
+            flags.bits(),
+        );
 
         Errno::result(ret).map(|r| r as usize)
     }
@@ -1664,36 +2216,51 @@ pub fn recv(sockfd: RawFd, buf: &mut [u8], flags: MsgFlags) -> Result<usize> {
 /// address of the sender.
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html)
-pub fn recvfrom(sockfd: RawFd, buf: &mut [u8])
-    -> Result<(usize, Option<SockAddr>)>
-{
+pub fn recvfrom<T: SockaddrLike>(
+    sockfd: RawFd,
+    buf: &mut [u8],
+) -> Result<(usize, Option<T>)> {
     unsafe {
-        let mut addr: sockaddr_storage = mem::zeroed();
-        let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
+        let mut addr = mem::MaybeUninit::<T>::uninit();
+        let mut len = mem::size_of_val(&addr) as socklen_t;
 
         let ret = Errno::result(libc::recvfrom(
             sockfd,
             buf.as_ptr() as *mut c_void,
             buf.len() as size_t,
             0,
-            &mut addr as *mut libc::sockaddr_storage as *mut libc::sockaddr,
-            &mut len as *mut socklen_t))? as usize;
-
-        match sockaddr_storage_to_addr(&addr, len as usize) {
-            Err(Errno::ENOTCONN) => Ok((ret, None)),
-            Ok(addr) => Ok((ret, Some(addr))),
-            Err(e) => Err(e)
-        }
+            addr.as_mut_ptr() as *mut libc::sockaddr,
+            &mut len as *mut socklen_t,
+        ))? as usize;
+
+        Ok((
+            ret,
+            T::from_raw(
+                addr.assume_init().as_ptr() as *const libc::sockaddr,
+                Some(len),
+            ),
+        ))
     }
 }
 
 /// Send a message to a socket
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html)
-pub fn sendto(fd: RawFd, buf: &[u8], addr: &SockAddr, flags: MsgFlags) -> Result<usize> {
+pub fn sendto(
+    fd: RawFd,
+    buf: &[u8],
+    addr: &dyn SockaddrLike,
+    flags: MsgFlags,
+) -> Result<usize> {
     let ret = unsafe {
-        let (ptr, len) = addr.as_ffi_pair();
-        libc::sendto(fd, buf.as_ptr() as *const c_void, buf.len() as size_t, flags.bits(), ptr, len)
+        libc::sendto(
+            fd,
+            buf.as_ptr() as *const c_void,
+            buf.len() as size_t,
+            flags.bits(),
+            addr.as_ptr(),
+            addr.len(),
+        )
     };
 
     Errno::result(ret).map(|r| r as usize)
@@ -1704,7 +2271,12 @@ pub fn sendto(fd: RawFd, buf: &[u8], addr: &SockAddr, flags: MsgFlags) -> Result
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/send.html)
 pub fn send(fd: RawFd, buf: &[u8], flags: MsgFlags) -> Result<usize> {
     let ret = unsafe {
-        libc::send(fd, buf.as_ptr() as *const c_void, buf.len() as size_t, flags.bits())
+        libc::send(
+            fd,
+            buf.as_ptr() as *const c_void,
+            buf.len() as size_t,
+            flags.bits(),
+        )
     };
 
     Errno::result(ret).map(|r| r as usize)
@@ -1717,7 +2289,7 @@ pub fn send(fd: RawFd, buf: &[u8], flags: MsgFlags) -> Result<usize> {
  */
 
 /// Represents a socket option that can be retrieved.
-pub trait GetSockOpt : Copy {
+pub trait GetSockOpt: Copy {
     type Val;
 
     /// Look up the value of this socket option on the given socket.
@@ -1725,7 +2297,7 @@ pub trait GetSockOpt : Copy {
 }
 
 /// Represents a socket option that can be set.
-pub trait SetSockOpt : Clone {
+pub trait SetSockOpt: Clone {
     type Val;
 
     /// Set the value of this socket option on the given socket.
@@ -1756,47 +2328,51 @@ pub fn getsockopt<O: GetSockOpt>(fd: RawFd, opt: O) -> Result<O::Val> {
 /// let res = setsockopt(fd, KeepAlive, &true);
 /// assert!(res.is_ok());
 /// ```
-pub fn setsockopt<O: SetSockOpt>(fd: RawFd, opt: O, val: &O::Val) -> Result<()> {
+pub fn setsockopt<O: SetSockOpt>(
+    fd: RawFd,
+    opt: O,
+    val: &O::Val,
+) -> Result<()> {
     opt.set(fd, val)
 }
 
 /// Get the address of the peer connected to the socket `fd`.
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html)
-pub fn getpeername(fd: RawFd) -> Result<SockAddr> {
+pub fn getpeername<T: SockaddrLike>(fd: RawFd) -> Result<T> {
     unsafe {
-        let mut addr = mem::MaybeUninit::uninit();
-        let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
+        let mut addr = mem::MaybeUninit::<T>::uninit();
+        let mut len = T::size();
 
         let ret = libc::getpeername(
             fd,
             addr.as_mut_ptr() as *mut libc::sockaddr,
-            &mut len
+            &mut len,
         );
 
         Errno::result(ret)?;
 
-        sockaddr_storage_to_addr(&addr.assume_init(), len as usize)
+        T::from_raw(addr.assume_init().as_ptr(), Some(len)).ok_or(Errno::EINVAL)
     }
 }
 
 /// Get the current address to which the socket `fd` is bound.
 ///
 /// [Further reading](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html)
-pub fn getsockname(fd: RawFd) -> Result<SockAddr> {
+pub fn getsockname<T: SockaddrLike>(fd: RawFd) -> Result<T> {
     unsafe {
-        let mut addr = mem::MaybeUninit::uninit();
-        let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
+        let mut addr = mem::MaybeUninit::<T>::uninit();
+        let mut len = T::size();
 
         let ret = libc::getsockname(
             fd,
             addr.as_mut_ptr() as *mut libc::sockaddr,
-            &mut len
+            &mut len,
         );
 
         Errno::result(ret)?;
 
-        sockaddr_storage_to_addr(&addr.assume_init(), len as usize)
+        T::from_raw(addr.assume_init().as_ptr(), Some(len)).ok_or(Errno::EINVAL)
     }
 }
 
@@ -1808,78 +2384,73 @@ pub fn getsockname(fd: RawFd) -> Result<SockAddr> {
 /// allocated and valid.  It must be at least as large as all the useful parts
 /// of the structure.  Note that in the case of a `sockaddr_un`, `len` need not
 /// include the terminating null.
+#[deprecated(
+    since = "0.24.0",
+    note = "use SockaddrLike or SockaddrStorage instead"
+)]
+#[allow(deprecated)]
 pub fn sockaddr_storage_to_addr(
     addr: &sockaddr_storage,
-    len: usize) -> Result<SockAddr> {
-
+    len: usize,
+) -> Result<SockAddr> {
     assert!(len <= mem::size_of::<sockaddr_storage>());
     if len < mem::size_of_val(&addr.ss_family) {
         return Err(Errno::ENOTCONN);
     }
 
     match c_int::from(addr.ss_family) {
+        #[cfg(feature = "net")]
         libc::AF_INET => {
-            assert!(len as usize >= mem::size_of::<sockaddr_in>());
+            assert!(len >= mem::size_of::<sockaddr_in>());
             let sin = unsafe {
                 *(addr as *const sockaddr_storage as *const sockaddr_in)
             };
             Ok(SockAddr::Inet(InetAddr::V4(sin)))
         }
+        #[cfg(feature = "net")]
         libc::AF_INET6 => {
-            assert!(len as usize >= mem::size_of::<sockaddr_in6>());
-            let sin6 = unsafe {
-                *(addr as *const _ as *const sockaddr_in6)
-            };
+            assert!(len >= mem::size_of::<sockaddr_in6>());
+            let sin6 = unsafe { *(addr as *const _ as *const sockaddr_in6) };
             Ok(SockAddr::Inet(InetAddr::V6(sin6)))
         }
-        libc::AF_UNIX => {
-            let pathlen = len - offset_of!(sockaddr_un, sun_path);
-            unsafe {
-                let sun = *(addr as *const _ as *const sockaddr_un);
-                Ok(SockAddr::Unix(UnixAddr::from_raw_parts(sun, pathlen)))
-            }
-        }
+        libc::AF_UNIX => unsafe {
+            let sun = *(addr as *const _ as *const sockaddr_un);
+            let sun_len = len.try_into().unwrap();
+            Ok(SockAddr::Unix(UnixAddr::from_raw_parts(sun, sun_len)))
+        },
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg(feature = "net")]
         libc::AF_PACKET => {
             use libc::sockaddr_ll;
             // Don't assert anything about the size.
             // Apparently the Linux kernel can return smaller sizes when
             // the value in the last element of sockaddr_ll (`sll_addr`) is
             // smaller than the declared size of that field
-            let sll = unsafe {
-                *(addr as *const _ as *const sockaddr_ll)
-            };
+            let sll = unsafe { *(addr as *const _ as *const sockaddr_ll) };
             Ok(SockAddr::Link(LinkAddr(sll)))
         }
         #[cfg(any(target_os = "android", target_os = "linux"))]
         libc::AF_NETLINK => {
             use libc::sockaddr_nl;
-            let snl = unsafe {
-                *(addr as *const _ as *const sockaddr_nl)
-            };
+            let snl = unsafe { *(addr as *const _ as *const sockaddr_nl) };
             Ok(SockAddr::Netlink(NetlinkAddr(snl)))
         }
         #[cfg(any(target_os = "android", target_os = "linux"))]
         libc::AF_ALG => {
             use libc::sockaddr_alg;
-            let salg = unsafe {
-                *(addr as *const _ as *const sockaddr_alg)
-            };
+            let salg = unsafe { *(addr as *const _ as *const sockaddr_alg) };
             Ok(SockAddr::Alg(AlgAddr(salg)))
         }
         #[cfg(any(target_os = "android", target_os = "linux"))]
         libc::AF_VSOCK => {
             use libc::sockaddr_vm;
-            let svm = unsafe {
-                *(addr as *const _ as *const sockaddr_vm)
-            };
+            let svm = unsafe { *(addr as *const _ as *const sockaddr_vm) };
             Ok(SockAddr::Vsock(VsockAddr(svm)))
         }
         af => panic!("unexpected address family {}", af),
     }
 }
 
-
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Shutdown {
     /// Further receptions will be disallowed.
@@ -1898,9 +2469,9 @@ pub fn shutdown(df: RawFd, how: Shutdown) -> Result<()> {
         use libc::shutdown;
 
         let how = match how {
-            Shutdown::Read  => libc::SHUT_RD,
+            Shutdown::Read => libc::SHUT_RD,
             Shutdown::Write => libc::SHUT_WR,
-            Shutdown::Both  => libc::SHUT_RDWR,
+            Shutdown::Both => libc::SHUT_RDWR,
         };
 
         Errno::result(shutdown(df, how)).map(drop)
diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs
index fcb4be8..06e9ee4 100644
--- a/src/sys/socket/sockopt.rs
+++ b/src/sys/socket/sockopt.rs
@@ -1,22 +1,23 @@
 //! Socket options as used by `setsockopt` and `getsockopt`.
-use cfg_if::cfg_if;
 use super::{GetSockOpt, SetSockOpt};
-use crate::Result;
 use crate::errno::Errno;
 use crate::sys::time::TimeVal;
+use crate::Result;
+use cfg_if::cfg_if;
 use libc::{self, c_int, c_void, socklen_t};
-use std::mem::{
-    self,
-    MaybeUninit
-};
-use std::os::unix::io::RawFd;
 use std::ffi::{OsStr, OsString};
+use std::{
+    convert::TryFrom,
+    mem::{self, MaybeUninit}
+};
 #[cfg(target_family = "unix")]
 use std::os::unix::ffi::OsStrExt;
+use std::os::unix::io::RawFd;
 
 // Constants
 // TCP_CA_NAME_MAX isn't defined in user space include files
-#[cfg(any(target_os = "freebsd", target_os = "linux"))] 
+#[cfg(any(target_os = "freebsd", target_os = "linux"))]
+#[cfg(feature = "net")]
 const TCP_CA_NAME_MAX: usize = 16;
 
 /// Helper for implementing `SetSockOpt` for a given socket option. See
@@ -50,14 +51,18 @@ macro_rules! setsockopt_impl {
                 unsafe {
                     let setter: $setter = Set::new(val);
 
-                    let res = libc::setsockopt(fd, $level, $flag,
-                                               setter.ffi_ptr(),
-                                               setter.ffi_len());
+                    let res = libc::setsockopt(
+                        fd,
+                        $level,
+                        $flag,
+                        setter.ffi_ptr(),
+                        setter.ffi_len(),
+                    );
                     Errno::result(res).map(drop)
                 }
             }
         }
-    }
+    };
 }
 
 /// Helper for implementing `GetSockOpt` for a given socket option. See
@@ -91,16 +96,23 @@ macro_rules! getsockopt_impl {
                 unsafe {
                     let mut getter: $getter = Get::uninit();
 
-                    let res = libc::getsockopt(fd, $level, $flag,
-                                               getter.ffi_ptr(),
-                                               getter.ffi_len());
+                    let res = libc::getsockopt(
+                        fd,
+                        $level,
+                        $flag,
+                        getter.ffi_ptr(),
+                        getter.ffi_len(),
+                    );
                     Errno::result(res)?;
 
-                    Ok(getter.assume_init())
+                    match <$ty>::try_from(getter.assume_init()) {
+                        Err(_) => Err(Errno::EINVAL),
+                        Ok(r) => Ok(r)
+                    }
                 }
             }
         }
-    }
+    };
 }
 
 /// Helper to generate the sockopt accessors. See
@@ -128,6 +140,9 @@ macro_rules! getsockopt_impl {
 /// * `$ty:ty`: type of the value that will be get/set.
 /// * `$getter:ty`: `Get` implementation; optional; only for `GetOnly` and `Both`.
 /// * `$setter:ty`: `Set` implementation; optional; only for `SetOnly` and `Both`.
+// Some targets don't use all rules.
+#[allow(unknown_lints)]
+#[allow(unused_macro_rules)]
 macro_rules! sockopt_impl {
     ($(#[$attr:meta])* $name:ident, GetOnly, $level:expr, $flag:path, bool) => {
         sockopt_impl!($(#[$attr])*
@@ -244,14 +259,25 @@ macro_rules! sockopt_impl {
 
 sockopt_impl!(
     /// Enables local address reuse
-    ReuseAddr, Both, libc::SOL_SOCKET, libc::SO_REUSEADDR, bool
+    ReuseAddr,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_REUSEADDR,
+    bool
 );
 #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
 sockopt_impl!(
     /// Permits multiple AF_INET or AF_INET6 sockets to be bound to an
     /// identical socket address.
-    ReusePort, Both, libc::SOL_SOCKET, libc::SO_REUSEPORT, bool);
+    ReusePort,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_REUSEPORT,
+    bool
+);
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Under most circumstances, TCP sends data when it is presented; when
     /// outstanding data has not yet been acknowledged, it gathers small amounts
     /// of output to be sent in a single packet once an acknowledgement is
@@ -259,26 +285,52 @@ sockopt_impl!(
     /// send a stream of mouse events which receive no replies, this
     /// packetization may cause significant delays.  The boolean option
     /// TCP_NODELAY defeats this algorithm.
-    TcpNoDelay, Both, libc::IPPROTO_TCP, libc::TCP_NODELAY, bool);
+    TcpNoDelay,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_NODELAY,
+    bool
+);
 sockopt_impl!(
     /// When enabled,  a close(2) or shutdown(2) will not return until all
     /// queued messages for the socket have been successfully sent or the
     /// linger timeout has been reached.
-    Linger, Both, libc::SOL_SOCKET, libc::SO_LINGER, libc::linger);
+    Linger,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_LINGER,
+    libc::linger
+);
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Join a multicast group
-    IpAddMembership, SetOnly, libc::IPPROTO_IP, libc::IP_ADD_MEMBERSHIP,
-    super::IpMembershipRequest);
+    IpAddMembership,
+    SetOnly,
+    libc::IPPROTO_IP,
+    libc::IP_ADD_MEMBERSHIP,
+    super::IpMembershipRequest
+);
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Leave a multicast group.
-    IpDropMembership, SetOnly, libc::IPPROTO_IP, libc::IP_DROP_MEMBERSHIP,
-    super::IpMembershipRequest);
+    IpDropMembership,
+    SetOnly,
+    libc::IPPROTO_IP,
+    libc::IP_DROP_MEMBERSHIP,
+    super::IpMembershipRequest
+);
 cfg_if! {
     if #[cfg(any(target_os = "android", target_os = "linux"))] {
+        #[cfg(feature = "net")]
         sockopt_impl!(
+            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
             /// Join an IPv6 multicast group.
             Ipv6AddMembership, SetOnly, libc::IPPROTO_IPV6, libc::IPV6_ADD_MEMBERSHIP, super::Ipv6MembershipRequest);
+        #[cfg(feature = "net")]
         sockopt_impl!(
+            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
             /// Leave an IPv6 multicast group.
             Ipv6DropMembership, SetOnly, libc::IPPROTO_IPV6, libc::IPV6_DROP_MEMBERSHIP, super::Ipv6MembershipRequest);
     } else if #[cfg(any(target_os = "dragonfly",
@@ -289,77 +341,199 @@ cfg_if! {
                         target_os = "netbsd",
                         target_os = "openbsd",
                         target_os = "solaris"))] {
+        #[cfg(feature = "net")]
         sockopt_impl!(
+            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
             /// Join an IPv6 multicast group.
             Ipv6AddMembership, SetOnly, libc::IPPROTO_IPV6,
             libc::IPV6_JOIN_GROUP, super::Ipv6MembershipRequest);
+        #[cfg(feature = "net")]
         sockopt_impl!(
+            #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
             /// Leave an IPv6 multicast group.
             Ipv6DropMembership, SetOnly, libc::IPPROTO_IPV6,
             libc::IPV6_LEAVE_GROUP, super::Ipv6MembershipRequest);
     }
 }
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Set or read the time-to-live value of outgoing multicast packets for
     /// this socket.
-    IpMulticastTtl, Both, libc::IPPROTO_IP, libc::IP_MULTICAST_TTL, u8);
+    IpMulticastTtl,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_MULTICAST_TTL,
+    u8
+);
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Set or read a boolean integer argument that determines whether sent
     /// multicast packets should be looped back to the local sockets.
-    IpMulticastLoop, Both, libc::IPPROTO_IP, libc::IP_MULTICAST_LOOP, bool);
+    IpMulticastLoop,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_MULTICAST_LOOP,
+    bool
+);
+#[cfg(target_os = "linux")]
+#[cfg(feature = "net")]
+sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    /// Set the protocol-defined priority for all packets to be
+    /// sent on this socket
+    Priority,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_PRIORITY,
+    libc::c_int
+);
+#[cfg(target_os = "linux")]
+#[cfg(feature = "net")]
+sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    /// Set or receive the Type-Of-Service (TOS) field that is
+    /// sent with every IP packet originating from this socket
+    IpTos,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_TOS,
+    libc::c_int
+);
+#[cfg(target_os = "linux")]
+#[cfg(feature = "net")]
+sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    /// Traffic class associated with outgoing packets
+    Ipv6TClass,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_TCLASS,
+    libc::c_int
+);
 #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// If enabled, this boolean option allows binding to an IP address that
     /// is nonlocal or does not (yet) exist.
-    IpFreebind, Both, libc::IPPROTO_IP, libc::IP_FREEBIND, bool);
+    IpFreebind,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_FREEBIND,
+    bool
+);
 sockopt_impl!(
     /// Specify the receiving timeout until reporting an error.
-    ReceiveTimeout, Both, libc::SOL_SOCKET, libc::SO_RCVTIMEO, TimeVal);
+    ReceiveTimeout,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_RCVTIMEO,
+    TimeVal
+);
 sockopt_impl!(
     /// Specify the sending timeout until reporting an error.
-    SendTimeout, Both, libc::SOL_SOCKET, libc::SO_SNDTIMEO, TimeVal);
+    SendTimeout,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_SNDTIMEO,
+    TimeVal
+);
 sockopt_impl!(
     /// Set or get the broadcast flag.
-    Broadcast, Both, libc::SOL_SOCKET, libc::SO_BROADCAST, bool);
+    Broadcast,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_BROADCAST,
+    bool
+);
 sockopt_impl!(
     /// If this option is enabled, out-of-band data is directly placed into
     /// the receive data stream.
-    OobInline, Both, libc::SOL_SOCKET, libc::SO_OOBINLINE, bool);
+    OobInline,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_OOBINLINE,
+    bool
+);
 sockopt_impl!(
     /// Get and clear the pending socket error.
-    SocketError, GetOnly, libc::SOL_SOCKET, libc::SO_ERROR, i32);
+    SocketError,
+    GetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_ERROR,
+    i32
+);
+sockopt_impl!(
+    /// Set or get the don't route flag.
+    DontRoute,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_DONTROUTE,
+    bool
+);
 sockopt_impl!(
     /// Enable sending of keep-alive messages on connection-oriented sockets.
-    KeepAlive, Both, libc::SOL_SOCKET, libc::SO_KEEPALIVE, bool);
+    KeepAlive,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_KEEPALIVE,
+    bool
+);
 #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "macos",
-        target_os = "ios"
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "ios"
 ))]
 sockopt_impl!(
     /// Get the credentials of the peer process of a connected unix domain
     /// socket.
-    LocalPeerCred, GetOnly, 0, libc::LOCAL_PEERCRED, super::XuCred);
+    LocalPeerCred,
+    GetOnly,
+    0,
+    libc::LOCAL_PEERCRED,
+    super::XuCred
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Return the credentials of the foreign process connected to this socket.
-    PeerCredentials, GetOnly, libc::SOL_SOCKET, libc::SO_PEERCRED, super::UnixCredentials);
-#[cfg(any(target_os = "ios",
-          target_os = "macos"))]
+    PeerCredentials,
+    GetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_PEERCRED,
+    super::UnixCredentials
+);
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Specify the amount of time, in seconds, that the connection must be idle
     /// before keepalive probes (if enabled) are sent.
-    TcpKeepAlive, Both, libc::IPPROTO_TCP, libc::TCP_KEEPALIVE, u32);
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "linux",
-          target_os = "nacl"))]
+    TcpKeepAlive,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_KEEPALIVE,
+    u32
+);
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux"
+))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The time (in seconds) the connection needs to remain idle before TCP
     /// starts sending keepalive probes
-    TcpKeepIdle, Both, libc::IPPROTO_TCP, libc::TCP_KEEPIDLE, u32);
+    TcpKeepIdle,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_KEEPIDLE,
+    u32
+);
 cfg_if! {
     if #[cfg(any(target_os = "android", target_os = "linux"))] {
         sockopt_impl!(
@@ -371,103 +545,234 @@ cfg_if! {
             TcpMaxSeg, GetOnly, libc::IPPROTO_TCP, libc::TCP_MAXSEG, u32);
     }
 }
-#[cfg(not(target_os = "openbsd"))]
+#[cfg(not(any(target_os = "openbsd", target_os = "haiku")))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The maximum number of keepalive probes TCP should send before
     /// dropping the connection.
-    TcpKeepCount, Both, libc::IPPROTO_TCP, libc::TCP_KEEPCNT, u32);
-#[cfg(any(target_os = "android",
-          target_os = "fuchsia",
-          target_os = "linux"))]
+    TcpKeepCount,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_KEEPCNT,
+    u32
+);
+#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
 sockopt_impl!(
     #[allow(missing_docs)]
     // Not documented by Linux!
-    TcpRepair, Both, libc::IPPROTO_TCP, libc::TCP_REPAIR, u32);
-#[cfg(not(target_os = "openbsd"))]
+    TcpRepair,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_REPAIR,
+    u32
+);
+#[cfg(not(any(target_os = "openbsd", target_os = "haiku")))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The time (in seconds) between individual keepalive probes.
-    TcpKeepInterval, Both, libc::IPPROTO_TCP, libc::TCP_KEEPINTVL, u32);
+    TcpKeepInterval,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_KEEPINTVL,
+    u32
+);
 #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Specifies the maximum amount of time in milliseconds that transmitted
     /// data may remain unacknowledged before TCP will forcibly close the
     /// corresponding connection
-    TcpUserTimeout, Both, libc::IPPROTO_TCP, libc::TCP_USER_TIMEOUT, u32);
+    TcpUserTimeout,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_USER_TIMEOUT,
+    u32
+);
 sockopt_impl!(
     /// Sets or gets the maximum socket receive buffer in bytes.
-    RcvBuf, Both, libc::SOL_SOCKET, libc::SO_RCVBUF, usize);
+    RcvBuf,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_RCVBUF,
+    usize
+);
 sockopt_impl!(
     /// Sets or gets the maximum socket send buffer in bytes.
-    SndBuf, Both, libc::SOL_SOCKET, libc::SO_SNDBUF, usize);
+    SndBuf,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_SNDBUF,
+    usize
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Using this socket option, a privileged (`CAP_NET_ADMIN`) process can
     /// perform the same task as `SO_RCVBUF`, but the `rmem_max limit` can be
     /// overridden.
-    RcvBufForce, SetOnly, libc::SOL_SOCKET, libc::SO_RCVBUFFORCE, usize);
+    RcvBufForce,
+    SetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_RCVBUFFORCE,
+    usize
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Using this socket option, a privileged (`CAP_NET_ADMIN`)  process can
     /// perform the same task as `SO_SNDBUF`, but the `wmem_max` limit can be
     /// overridden.
-    SndBufForce, SetOnly, libc::SOL_SOCKET, libc::SO_SNDBUFFORCE, usize);
+    SndBufForce,
+    SetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_SNDBUFFORCE,
+    usize
+);
 sockopt_impl!(
     /// Gets the socket type as an integer.
-    SockType, GetOnly, libc::SOL_SOCKET, libc::SO_TYPE, super::SockType);
+    SockType,
+    GetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_TYPE,
+    super::SockType,
+    GetStruct<i32>
+);
 sockopt_impl!(
     /// Returns a value indicating whether or not this socket has been marked to
     /// accept connections with `listen(2)`.
-    AcceptConn, GetOnly, libc::SOL_SOCKET, libc::SO_ACCEPTCONN, bool);
+    AcceptConn,
+    GetOnly,
+    libc::SOL_SOCKET,
+    libc::SO_ACCEPTCONN,
+    bool
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Bind this socket to a particular device like “eth0”.
-    BindToDevice, Both, libc::SOL_SOCKET, libc::SO_BINDTODEVICE, OsString<[u8; libc::IFNAMSIZ]>);
+    BindToDevice,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_BINDTODEVICE,
+    OsString<[u8; libc::IFNAMSIZ]>
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     #[allow(missing_docs)]
     // Not documented by Linux!
-    OriginalDst, GetOnly, libc::SOL_IP, libc::SO_ORIGINAL_DST, libc::sockaddr_in);
+    OriginalDst,
+    GetOnly,
+    libc::SOL_IP,
+    libc::SO_ORIGINAL_DST,
+    libc::sockaddr_in
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     #[allow(missing_docs)]
     // Not documented by Linux!
-    Ip6tOriginalDst, GetOnly, libc::SOL_IPV6, libc::IP6T_SO_ORIGINAL_DST, libc::sockaddr_in6);
-sockopt_impl!( 
+    Ip6tOriginalDst,
+    GetOnly,
+    libc::SOL_IPV6,
+    libc::IP6T_SO_ORIGINAL_DST,
+    libc::sockaddr_in6
+);
+#[cfg(any(target_os = "linux"))]
+sockopt_impl!(
+    /// Specifies exact type of timestamping information collected by the kernel
+    /// [Further reading](https://www.kernel.org/doc/html/latest/networking/timestamping.html)
+    Timestamping,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_TIMESTAMPING,
+    super::TimestampingFlag
+);
+#[cfg(not(target_os = "haiku"))]
+sockopt_impl!(
     /// Enable or disable the receiving of the `SO_TIMESTAMP` control message.
-    ReceiveTimestamp, Both, libc::SOL_SOCKET, libc::SO_TIMESTAMP, bool);
+    ReceiveTimestamp,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_TIMESTAMP,
+    bool
+);
 #[cfg(all(target_os = "linux"))]
 sockopt_impl!(
     /// Enable or disable the receiving of the `SO_TIMESTAMPNS` control message.
-    ReceiveTimestampns, Both, libc::SOL_SOCKET, libc::SO_TIMESTAMPNS, bool);
+    ReceiveTimestampns,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_TIMESTAMPNS,
+    bool
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Setting this boolean option enables transparent proxying on this socket.
-    IpTransparent, Both, libc::SOL_IP, libc::IP_TRANSPARENT, bool);
+    IpTransparent,
+    Both,
+    libc::SOL_IP,
+    libc::IP_TRANSPARENT,
+    bool
+);
 #[cfg(target_os = "openbsd")]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Allows the socket to be bound to addresses which are not local to the
     /// machine, so it can be used to make a transparent proxy.
-    BindAny, Both, libc::SOL_SOCKET, libc::SO_BINDANY, bool);
+    BindAny,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_BINDANY,
+    bool
+);
 #[cfg(target_os = "freebsd")]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Can `bind(2)` to any address, even one not bound to any available
     /// network interface in the system.
-    BindAny, Both, libc::IPPROTO_IP, libc::IP_BINDANY, bool);
+    BindAny,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_BINDANY,
+    bool
+);
 #[cfg(target_os = "linux")]
 sockopt_impl!(
     /// Set the mark for each packet sent through this socket (similar to the
     /// netfilter MARK target but socket-based).
-    Mark, Both, libc::SOL_SOCKET, libc::SO_MARK, u32);
+    Mark,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_MARK,
+    u32
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Enable or disable the receiving of the `SCM_CREDENTIALS` control
     /// message.
-    PassCred, Both, libc::SOL_SOCKET, libc::SO_PASSCRED, bool);
-#[cfg(any(target_os = "freebsd", target_os = "linux"))] 
+    PassCred,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_PASSCRED,
+    bool
+);
+#[cfg(any(target_os = "freebsd", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// This option allows the caller to set the TCP congestion control
     /// algorithm to be used,  on a per-socket basis.
-    TcpCongestion, Both, libc::IPPROTO_TCP, libc::TCP_CONGESTION, OsString<[u8; TCP_CA_NAME_MAX]>);
+    TcpCongestion,
+    Both,
+    libc::IPPROTO_TCP,
+    libc::TCP_CONGESTION,
+    OsString<[u8; TCP_CA_NAME_MAX]>
+);
 #[cfg(any(
     target_os = "android",
     target_os = "ios",
@@ -475,10 +780,17 @@ sockopt_impl!(
     target_os = "macos",
     target_os = "netbsd",
 ))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Pass an `IP_PKTINFO` ancillary message that contains a pktinfo
     /// structure that supplies some information about the incoming packet.
-    Ipv4PacketInfo, Both, libc::IPPROTO_IP, libc::IP_PKTINFO, bool);
+    Ipv4PacketInfo,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_PKTINFO,
+    bool
+);
 #[cfg(any(
     target_os = "android",
     target_os = "freebsd",
@@ -488,10 +800,17 @@ sockopt_impl!(
     target_os = "netbsd",
     target_os = "openbsd",
 ))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// Set delivery of the `IPV6_PKTINFO` control message on incoming
     /// datagrams.
-    Ipv6RecvPacketInfo, Both, libc::IPPROTO_IPV6, libc::IPV6_RECVPKTINFO, bool);
+    Ipv6RecvPacketInfo,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_RECVPKTINFO,
+    bool
+);
 #[cfg(any(
     target_os = "freebsd",
     target_os = "ios",
@@ -499,10 +818,17 @@ sockopt_impl!(
     target_os = "netbsd",
     target_os = "openbsd",
 ))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The `recvmsg(2)` call returns a `struct sockaddr_dl` corresponding to
     /// the interface on which the packet was received.
-    Ipv4RecvIf, Both, libc::IPPROTO_IP, libc::IP_RECVIF, bool);
+    Ipv4RecvIf,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_RECVIF,
+    bool
+);
 #[cfg(any(
     target_os = "freebsd",
     target_os = "ios",
@@ -510,46 +836,165 @@ sockopt_impl!(
     target_os = "netbsd",
     target_os = "openbsd",
 ))]
+#[cfg(feature = "net")]
+sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    /// The `recvmsg(2)` call will return the destination IP address for a UDP
+    /// datagram.
+    Ipv4RecvDstAddr,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_RECVDSTADDR,
+    bool
+);
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The `recvmsg(2)` call will return the destination IP address for a UDP
     /// datagram.
-    Ipv4RecvDstAddr, Both, libc::IPPROTO_IP, libc::IP_RECVDSTADDR, bool);
+    Ipv4OrigDstAddr,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_ORIGDSTADDR,
+    bool
+);
 #[cfg(target_os = "linux")]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     #[allow(missing_docs)]
     // Not documented by Linux!
-    UdpGsoSegment, Both, libc::SOL_UDP, libc::UDP_SEGMENT, libc::c_int);
+    UdpGsoSegment,
+    Both,
+    libc::SOL_UDP,
+    libc::UDP_SEGMENT,
+    libc::c_int
+);
 #[cfg(target_os = "linux")]
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     #[allow(missing_docs)]
     // Not documented by Linux!
-    UdpGroSegment, Both, libc::IPPROTO_UDP, libc::UDP_GRO, bool);
+    UdpGroSegment,
+    Both,
+    libc::IPPROTO_UDP,
+    libc::UDP_GRO,
+    bool
+);
+#[cfg(target_os = "linux")]
+sockopt_impl!(
+    /// Configures the behavior of time-based transmission of packets, for use
+    /// with the `TxTime` control message.
+    TxTime,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_TXTIME,
+    libc::sock_txtime
+);
 #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
 sockopt_impl!(
     /// Indicates that an unsigned 32-bit value ancillary message (cmsg) should
     /// be attached to received skbs indicating the number of packets dropped by
     /// the socket since its creation.
-    RxqOvfl, Both, libc::SOL_SOCKET, libc::SO_RXQ_OVFL, libc::c_int);
+    RxqOvfl,
+    Both,
+    libc::SOL_SOCKET,
+    libc::SO_RXQ_OVFL,
+    libc::c_int
+);
+#[cfg(feature = "net")]
 sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
     /// The socket is restricted to sending and receiving IPv6 packets only.
-    Ipv6V6Only, Both, libc::IPPROTO_IPV6, libc::IPV6_V6ONLY, bool);
+    Ipv6V6Only,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_V6ONLY,
+    bool
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Enable extended reliable error message passing.
-    Ipv4RecvErr, Both, libc::IPPROTO_IP, libc::IP_RECVERR, bool);
+    Ipv4RecvErr,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_RECVERR,
+    bool
+);
 #[cfg(any(target_os = "android", target_os = "linux"))]
 sockopt_impl!(
     /// Control receiving of asynchronous error options.
-    Ipv6RecvErr, Both, libc::IPPROTO_IPV6, libc::IPV6_RECVERR, bool);
+    Ipv6RecvErr,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_RECVERR,
+    bool
+);
+#[cfg(any(target_os = "android", target_os = "linux"))]
+sockopt_impl!(
+    /// Fetch the current system-estimated Path MTU.
+    IpMtu,
+    GetOnly,
+    libc::IPPROTO_IP,
+    libc::IP_MTU,
+    libc::c_int
+);
 #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
 sockopt_impl!(
     /// Set or retrieve the current time-to-live field that is used in every
     /// packet sent from this socket.
-    Ipv4Ttl, Both, libc::IPPROTO_IP, libc::IP_TTL, libc::c_int);
+    Ipv4Ttl,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_TTL,
+    libc::c_int
+);
 #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
 sockopt_impl!(
     /// Set the unicast hop limit for the socket.
-    Ipv6Ttl, Both, libc::IPPROTO_IPV6, libc::IPV6_UNICAST_HOPS, libc::c_int);
+    Ipv6Ttl,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_UNICAST_HOPS,
+    libc::c_int
+);
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg(feature = "net")]
+sockopt_impl!(
+    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
+    /// The `recvmsg(2)` call will return the destination IP address for a UDP
+    /// datagram.
+    Ipv6OrigDstAddr,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_ORIGDSTADDR,
+    bool
+);
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+sockopt_impl!(
+    /// Set "don't fragment packet" flag on the IP packet.
+    IpDontFrag,
+    Both,
+    libc::IPPROTO_IP,
+    libc::IP_DONTFRAG,
+    bool
+);
+#[cfg(any(
+    target_os = "android",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+))]
+sockopt_impl!(
+    /// Set "don't fragment packet" flag on the IPv6 packet.
+    Ipv6DontFrag,
+    Both,
+    libc::IPPROTO_IPV6,
+    libc::IPV6_DONTFRAG,
+    bool
+);
 
 #[allow(missing_docs)]
 // Not documented by Linux!
@@ -565,11 +1010,13 @@ impl SetSockOpt for AlgSetAeadAuthSize {
 
     fn set(&self, fd: RawFd, val: &usize) -> Result<()> {
         unsafe {
-            let res = libc::setsockopt(fd,
-                                       libc::SOL_ALG,
-                                       libc::ALG_SET_AEAD_AUTHSIZE,
-                                       ::std::ptr::null(),
-                                       *val as libc::socklen_t);
+            let res = libc::setsockopt(
+                fd,
+                libc::SOL_ALG,
+                libc::ALG_SET_AEAD_AUTHSIZE,
+                ::std::ptr::null(),
+                *val as libc::socklen_t,
+            );
             Errno::result(res).map(drop)
         }
     }
@@ -589,16 +1036,21 @@ impl<T> Default for AlgSetKey<T> {
 }
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
-impl<T> SetSockOpt for AlgSetKey<T> where T: AsRef<[u8]> + Clone {
+impl<T> SetSockOpt for AlgSetKey<T>
+where
+    T: AsRef<[u8]> + Clone,
+{
     type Val = T;
 
     fn set(&self, fd: RawFd, val: &T) -> Result<()> {
         unsafe {
-            let res = libc::setsockopt(fd,
-                                       libc::SOL_ALG,
-                                       libc::ALG_SET_KEY,
-                                       val.as_ref().as_ptr() as *const _,
-                                       val.as_ref().len() as libc::socklen_t);
+            let res = libc::setsockopt(
+                fd,
+                libc::SOL_ALG,
+                libc::ALG_SET_KEY,
+                val.as_ref().as_ptr() as *const _,
+                val.as_ref().len() as libc::socklen_t,
+            );
             Errno::result(res).map(drop)
         }
     }
@@ -659,7 +1111,11 @@ impl<T> Get<T> for GetStruct<T> {
     }
 
     unsafe fn assume_init(self) -> T {
-        assert_eq!(self.len as usize, mem::size_of::<T>(), "invalid getsockopt implementation");
+        assert_eq!(
+            self.len as usize,
+            mem::size_of::<T>(),
+            "invalid getsockopt implementation"
+        );
         self.val.assume_init()
     }
 }
@@ -706,7 +1162,11 @@ impl Get<bool> for GetBool {
     }
 
     unsafe fn assume_init(self) -> bool {
-        assert_eq!(self.len as usize, mem::size_of::<c_int>(), "invalid getsockopt implementation");
+        assert_eq!(
+            self.len as usize,
+            mem::size_of::<c_int>(),
+            "invalid getsockopt implementation"
+        );
         self.val.assume_init() != 0
     }
 }
@@ -718,7 +1178,9 @@ struct SetBool {
 
 impl<'a> Set<'a, bool> for SetBool {
     fn new(val: &'a bool) -> SetBool {
-        SetBool { val: if *val { 1 } else { 0 } }
+        SetBool {
+            val: i32::from(*val),
+        }
     }
 
     fn ffi_ptr(&self) -> *const c_void {
@@ -753,7 +1215,11 @@ impl Get<u8> for GetU8 {
     }
 
     unsafe fn assume_init(self) -> u8 {
-        assert_eq!(self.len as usize, mem::size_of::<u8>(), "invalid getsockopt implementation");
+        assert_eq!(
+            self.len as usize,
+            mem::size_of::<u8>(),
+            "invalid getsockopt implementation"
+        );
         self.val.assume_init()
     }
 }
@@ -765,7 +1231,7 @@ struct SetU8 {
 
 impl<'a> Set<'a, u8> for SetU8 {
     fn new(val: &'a u8) -> SetU8 {
-        SetU8 { val: *val as u8 }
+        SetU8 { val: *val }
     }
 
     fn ffi_ptr(&self) -> *const c_void {
@@ -800,7 +1266,11 @@ impl Get<usize> for GetUsize {
     }
 
     unsafe fn assume_init(self) -> usize {
-        assert_eq!(self.len as usize, mem::size_of::<c_int>(), "invalid getsockopt implementation");
+        assert_eq!(
+            self.len as usize,
+            mem::size_of::<c_int>(),
+            "invalid getsockopt implementation"
+        );
         self.val.assume_init() as usize
     }
 }
@@ -860,7 +1330,9 @@ struct SetOsString<'a> {
 
 impl<'a> Set<'a, OsString> for SetOsString<'a> {
     fn new(val: &'a OsString) -> SetOsString {
-        SetOsString { val: val.as_os_str() }
+        SetOsString {
+            val: val.as_os_str(),
+        }
     }
 
     fn ffi_ptr(&self) -> *const c_void {
@@ -872,7 +1344,6 @@ impl<'a> Set<'a, OsString> for SetOsString<'a> {
     }
 }
 
-
 #[cfg(test)]
 mod test {
     #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -880,11 +1351,17 @@ mod test {
     fn can_get_peercred_on_unix_socket() {
         use super::super::*;
 
-        let (a, b) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty()).unwrap();
+        let (a, b) = socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
         let a_cred = getsockopt(a, super::PeerCredentials).unwrap();
         let b_cred = getsockopt(b, super::PeerCredentials).unwrap();
         assert_eq!(a_cred, b_cred);
-        assert!(a_cred.pid() != 0);
+        assert_ne!(a_cred.pid(), 0);
     }
 
     #[test]
@@ -892,7 +1369,13 @@ mod test {
         use super::super::*;
         use crate::unistd::close;
 
-        let (a, b) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty()).unwrap();
+        let (a, b) = socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
         let a_type = getsockopt(a, super::SockType).unwrap();
         assert_eq!(a_type, SockType::Stream);
         close(a).unwrap();
@@ -904,21 +1387,31 @@ mod test {
         use super::super::*;
         use crate::unistd::close;
 
-        let s = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(), None).unwrap();
+        let s = socket(
+            AddressFamily::Inet,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )
+        .unwrap();
         let s_type = getsockopt(s, super::SockType).unwrap();
         assert_eq!(s_type, SockType::Datagram);
         close(s).unwrap();
     }
 
-    #[cfg(any(target_os = "freebsd",
-              target_os = "linux",
-              target_os = "nacl"))]
+    #[cfg(any(target_os = "freebsd", target_os = "linux"))]
     #[test]
     fn can_get_listen_on_tcp_socket() {
         use super::super::*;
         use crate::unistd::close;
 
-        let s = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), None).unwrap();
+        let s = socket(
+            AddressFamily::Inet,
+            SockType::Stream,
+            SockFlag::empty(),
+            None,
+        )
+        .unwrap();
         let s_listening = getsockopt(s, super::AcceptConn).unwrap();
         assert!(!s_listening);
         listen(s, 10).unwrap();
@@ -926,5 +1419,4 @@ mod test {
         assert!(s_listening2);
         close(s).unwrap();
     }
-
 }
diff --git a/src/sys/stat.rs b/src/sys/stat.rs
index c8f1041..78203bf 100644
--- a/src/sys/stat.rs
+++ b/src/sys/stat.rs
@@ -1,12 +1,20 @@
-pub use libc::{dev_t, mode_t};
+#[cfg(any(target_os = "macos", target_os = "ios", target_os = "openbsd"))]
+pub use libc::c_uint;
+#[cfg(any(
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "dragonfly"
+))]
+pub use libc::c_ulong;
 pub use libc::stat as FileStat;
+pub use libc::{dev_t, mode_t};
 
-use crate::{Result, NixPath, errno::Errno};
 #[cfg(not(target_os = "redox"))]
-use crate::fcntl::{AtFlags, at_rawfd};
+use crate::fcntl::{at_rawfd, AtFlags};
+use crate::sys::time::{TimeSpec, TimeVal};
+use crate::{errno::Errno, NixPath, Result};
 use std::mem;
 use std::os::unix::io::RawFd;
-use crate::sys::time::{TimeSpec, TimeVal};
 
 libc_bitflags!(
     /// "File type" flags for `mknod` and related functions.
@@ -25,26 +33,149 @@ libc_bitflags!(
 libc_bitflags! {
     /// "File mode / permissions" flags.
     pub struct Mode: mode_t {
+        /// Read, write and execute for owner.
         S_IRWXU;
+        /// Read for owner.
         S_IRUSR;
+        /// Write for owner.
         S_IWUSR;
+        /// Execute for owner.
         S_IXUSR;
+        /// Read write and execute for group.
         S_IRWXG;
+        /// Read fr group.
         S_IRGRP;
+        /// Write for group.
         S_IWGRP;
+        /// Execute for group.
         S_IXGRP;
+        /// Read, write and execute for other.
         S_IRWXO;
+        /// Read for other.
         S_IROTH;
+        /// Write for other.
         S_IWOTH;
+        /// Execute for other.
         S_IXOTH;
+        /// Set user id on execution.
         S_ISUID as mode_t;
+        /// Set group id on execution.
         S_ISGID as mode_t;
         S_ISVTX as mode_t;
     }
 }
 
+#[cfg(any(target_os = "macos", target_os = "ios", target_os = "openbsd"))]
+pub type type_of_file_flag = c_uint;
+#[cfg(any(
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "dragonfly"
+))]
+pub type type_of_file_flag = c_ulong;
+
+#[cfg(any(
+    target_os = "openbsd",
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "macos",
+    target_os = "ios"
+))]
+libc_bitflags! {
+    /// File flags.
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub struct FileFlag: type_of_file_flag {
+        /// The file may only be appended to.
+        SF_APPEND;
+        /// The file has been archived.
+        SF_ARCHIVED;
+        #[cfg(any(target_os = "dragonfly"))]
+        SF_CACHE;
+        /// The file may not be changed.
+        SF_IMMUTABLE;
+        /// Indicates a WAPBL journal file.
+        #[cfg(any(target_os = "netbsd"))]
+        SF_LOG;
+        /// Do not retain history for file
+        #[cfg(any(target_os = "dragonfly"))]
+        SF_NOHISTORY;
+        /// The file may not be renamed or deleted.
+        #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+        SF_NOUNLINK;
+        /// Mask of superuser changeable flags
+        SF_SETTABLE;
+        /// Snapshot is invalid.
+        #[cfg(any(target_os = "netbsd"))]
+        SF_SNAPINVAL;
+        /// The file is a snapshot file.
+        #[cfg(any(target_os = "netbsd", target_os = "freebsd"))]
+        SF_SNAPSHOT;
+        #[cfg(any(target_os = "dragonfly"))]
+        SF_XLINK;
+        /// The file may only be appended to.
+        UF_APPEND;
+        /// The file needs to be archived.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_ARCHIVE;
+        #[cfg(any(target_os = "dragonfly"))]
+        UF_CACHE;
+        /// File is compressed at the file system level.
+        #[cfg(any(target_os = "macos", target_os = "ios"))]
+        UF_COMPRESSED;
+        /// The file may be hidden from directory listings at the application's
+        /// discretion.
+        #[cfg(any(
+            target_os = "freebsd",
+            target_os = "macos",
+            target_os = "ios",
+        ))]
+        UF_HIDDEN;
+        /// The file may not be changed.
+        UF_IMMUTABLE;
+        /// Do not dump the file.
+        UF_NODUMP;
+        #[cfg(any(target_os = "dragonfly"))]
+        UF_NOHISTORY;
+        /// The file may not be renamed or deleted.
+        #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+        UF_NOUNLINK;
+        /// The file is offline, or has the Windows and CIFS
+        /// `FILE_ATTRIBUTE_OFFLINE` attribute.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_OFFLINE;
+        /// The directory is opaque when viewed through a union stack.
+        UF_OPAQUE;
+        /// The file is read only, and may not be written or appended.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_READONLY;
+        /// The file contains a Windows reparse point.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_REPARSE;
+        /// Mask of owner changeable flags.
+        UF_SETTABLE;
+        /// The file has the Windows `FILE_ATTRIBUTE_SPARSE_FILE` attribute.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_SPARSE;
+        /// The file has the DOS, Windows and CIFS `FILE_ATTRIBUTE_SYSTEM`
+        /// attribute.
+        #[cfg(any(target_os = "freebsd"))]
+        UF_SYSTEM;
+        /// File renames and deletes are tracked.
+        #[cfg(any(target_os = "macos", target_os = "ios"))]
+        UF_TRACKED;
+        #[cfg(any(target_os = "dragonfly"))]
+        UF_XLINK;
+    }
+}
+
 /// Create a special or ordinary file, by pathname.
-pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t) -> Result<()> {
+pub fn mknod<P: ?Sized + NixPath>(
+    path: &P,
+    kind: SFlag,
+    perm: Mode,
+    dev: dev_t,
+) -> Result<()> {
     let res = path.with_nix_path(|cstr| unsafe {
         libc::mknod(cstr.as_ptr(), kind.bits | perm.bits() as mode_t, dev)
     })?;
@@ -53,7 +184,13 @@ pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t)
 }
 
 /// Create a special or ordinary file, relative to a given directory.
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn mknodat<P: ?Sized + NixPath>(
     dirfd: RawFd,
     path: &P,
@@ -62,30 +199,36 @@ pub fn mknodat<P: ?Sized + NixPath>(
     dev: dev_t,
 ) -> Result<()> {
     let res = path.with_nix_path(|cstr| unsafe {
-        libc::mknodat(dirfd, cstr.as_ptr(), kind.bits | perm.bits() as mode_t, dev)
+        libc::mknodat(
+            dirfd,
+            cstr.as_ptr(),
+            kind.bits | perm.bits() as mode_t,
+            dev,
+        )
     })?;
 
     Errno::result(res).map(drop)
 }
 
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub const fn major(dev: dev_t) -> u64 {
-    ((dev >> 32) & 0xffff_f000) |
-    ((dev >>  8) & 0x0000_0fff)
+    ((dev >> 32) & 0xffff_f000) | ((dev >> 8) & 0x0000_0fff)
 }
 
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub const fn minor(dev: dev_t) -> u64 {
-    ((dev >> 12) & 0xffff_ff00) |
-    ((dev      ) & 0x0000_00ff)
+    ((dev >> 12) & 0xffff_ff00) | ((dev) & 0x0000_00ff)
 }
 
 #[cfg(target_os = "linux")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub const fn makedev(major: u64, minor: u64) -> dev_t {
-    ((major & 0xffff_f000) << 32) |
-    ((major & 0x0000_0fff) <<  8) |
-    ((minor & 0xffff_ff00) << 12) |
-     (minor & 0x0000_00ff)
+    ((major & 0xffff_f000) << 32)
+        | ((major & 0x0000_0fff) << 8)
+        | ((minor & 0xffff_ff00) << 12)
+        | (minor & 0x0000_00ff)
 }
 
 pub fn umask(mode: Mode) -> Mode {
@@ -95,28 +238,24 @@ pub fn umask(mode: Mode) -> Mode {
 
 pub fn stat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
     let mut dst = mem::MaybeUninit::uninit();
-    let res = path.with_nix_path(|cstr| {
-        unsafe {
-            libc::stat(cstr.as_ptr(), dst.as_mut_ptr())
-        }
+    let res = path.with_nix_path(|cstr| unsafe {
+        libc::stat(cstr.as_ptr(), dst.as_mut_ptr())
     })?;
 
     Errno::result(res)?;
 
-    Ok(unsafe{dst.assume_init()})
+    Ok(unsafe { dst.assume_init() })
 }
 
 pub fn lstat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
     let mut dst = mem::MaybeUninit::uninit();
-    let res = path.with_nix_path(|cstr| {
-        unsafe {
-            libc::lstat(cstr.as_ptr(), dst.as_mut_ptr())
-        }
+    let res = path.with_nix_path(|cstr| unsafe {
+        libc::lstat(cstr.as_ptr(), dst.as_mut_ptr())
     })?;
 
     Errno::result(res)?;
 
-    Ok(unsafe{dst.assume_init()})
+    Ok(unsafe { dst.assume_init() })
 }
 
 pub fn fstat(fd: RawFd) -> Result<FileStat> {
@@ -125,19 +264,29 @@ pub fn fstat(fd: RawFd) -> Result<FileStat> {
 
     Errno::result(res)?;
 
-    Ok(unsafe{dst.assume_init()})
+    Ok(unsafe { dst.assume_init() })
 }
 
 #[cfg(not(target_os = "redox"))]
-pub fn fstatat<P: ?Sized + NixPath>(dirfd: RawFd, pathname: &P, f: AtFlags) -> Result<FileStat> {
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub fn fstatat<P: ?Sized + NixPath>(
+    dirfd: RawFd,
+    pathname: &P,
+    f: AtFlags,
+) -> Result<FileStat> {
     let mut dst = mem::MaybeUninit::uninit();
-    let res = pathname.with_nix_path(|cstr| {
-        unsafe { libc::fstatat(dirfd, cstr.as_ptr(), dst.as_mut_ptr(), f.bits() as libc::c_int) }
+    let res = pathname.with_nix_path(|cstr| unsafe {
+        libc::fstatat(
+            dirfd,
+            cstr.as_ptr(),
+            dst.as_mut_ptr(),
+            f.bits() as libc::c_int,
+        )
     })?;
 
     Errno::result(res)?;
 
-    Ok(unsafe{dst.assume_init()})
+    Ok(unsafe { dst.assume_init() })
 }
 
 /// Change the file permission bits of the file specified by a file descriptor.
@@ -175,17 +324,17 @@ pub enum FchmodatFlags {
 ///
 /// [fchmodat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmodat.html).
 #[cfg(not(target_os = "redox"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn fchmodat<P: ?Sized + NixPath>(
     dirfd: Option<RawFd>,
     path: &P,
     mode: Mode,
     flag: FchmodatFlags,
 ) -> Result<()> {
-    let atflag =
-        match flag {
-            FchmodatFlags::FollowSymlink => AtFlags::empty(),
-            FchmodatFlags::NoFollowSymlink => AtFlags::AT_SYMLINK_NOFOLLOW,
-        };
+    let atflag = match flag {
+        FchmodatFlags::FollowSymlink => AtFlags::empty(),
+        FchmodatFlags::NoFollowSymlink => AtFlags::AT_SYMLINK_NOFOLLOW,
+    };
     let res = path.with_nix_path(|cstr| unsafe {
         libc::fchmodat(
             at_rawfd(dirfd),
@@ -208,7 +357,11 @@ pub fn fchmodat<P: ?Sized + NixPath>(
 /// # References
 ///
 /// [utimes(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimes.html).
-pub fn utimes<P: ?Sized + NixPath>(path: &P, atime: &TimeVal, mtime: &TimeVal) -> Result<()> {
+pub fn utimes<P: ?Sized + NixPath>(
+    path: &P,
+    atime: &TimeVal,
+    mtime: &TimeVal,
+) -> Result<()> {
     let times: [libc::timeval; 2] = [*atime.as_ref(), *mtime.as_ref()];
     let res = path.with_nix_path(|cstr| unsafe {
         libc::utimes(cstr.as_ptr(), &times[0])
@@ -227,13 +380,20 @@ pub fn utimes<P: ?Sized + NixPath>(path: &P, atime: &TimeVal, mtime: &TimeVal) -
 /// # References
 ///
 /// [lutimes(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lutimes.html).
-#[cfg(any(target_os = "linux",
-          target_os = "haiku",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "netbsd"))]
-pub fn lutimes<P: ?Sized + NixPath>(path: &P, atime: &TimeVal, mtime: &TimeVal) -> Result<()> {
+#[cfg(any(
+    target_os = "linux",
+    target_os = "haiku",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "freebsd",
+    target_os = "netbsd"
+))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub fn lutimes<P: ?Sized + NixPath>(
+    path: &P,
+    atime: &TimeVal,
+    mtime: &TimeVal,
+) -> Result<()> {
     let times: [libc::timeval; 2] = [*atime.as_ref(), *mtime.as_ref()];
     let res = path.with_nix_path(|cstr| unsafe {
         libc::lutimes(cstr.as_ptr(), &times[0])
@@ -280,18 +440,18 @@ pub enum UtimensatFlags {
 ///
 /// [utimensat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/utimens.html).
 #[cfg(not(target_os = "redox"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn utimensat<P: ?Sized + NixPath>(
     dirfd: Option<RawFd>,
     path: &P,
     atime: &TimeSpec,
     mtime: &TimeSpec,
-    flag: UtimensatFlags
+    flag: UtimensatFlags,
 ) -> Result<()> {
-    let atflag =
-        match flag {
-            UtimensatFlags::FollowSymlink => AtFlags::empty(),
-            UtimensatFlags::NoFollowSymlink => AtFlags::AT_SYMLINK_NOFOLLOW,
-        };
+    let atflag = match flag {
+        UtimensatFlags::FollowSymlink => AtFlags::empty(),
+        UtimensatFlags::NoFollowSymlink => AtFlags::AT_SYMLINK_NOFOLLOW,
+    };
     let times: [libc::timespec; 2] = [*atime.as_ref(), *mtime.as_ref()];
     let res = path.with_nix_path(|cstr| unsafe {
         libc::utimensat(
@@ -306,9 +466,14 @@ pub fn utimensat<P: ?Sized + NixPath>(
 }
 
 #[cfg(not(target_os = "redox"))]
-pub fn mkdirat<P: ?Sized + NixPath>(fd: RawFd, path: &P, mode: Mode) -> Result<()> {
-    let res = path.with_nix_path(|cstr| {
-        unsafe { libc::mkdirat(fd, cstr.as_ptr(), mode.bits() as mode_t) }
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub fn mkdirat<P: ?Sized + NixPath>(
+    fd: RawFd,
+    path: &P,
+    mode: Mode,
+) -> Result<()> {
+    let res = path.with_nix_path(|cstr| unsafe {
+        libc::mkdirat(fd, cstr.as_ptr(), mode.bits() as mode_t)
     })?;
 
     Errno::result(res).map(drop)
diff --git a/src/sys/statfs.rs b/src/sys/statfs.rs
index 829be57..9be8ca6 100644
--- a/src/sys/statfs.rs
+++ b/src/sys/statfs.rs
@@ -1,25 +1,62 @@
 //! Get filesystem statistics, non-portably
 //!
 //! See [`statvfs`](crate::sys::statvfs) for a portable alternative.
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
+use std::ffi::CStr;
 use std::fmt::{self, Debug};
 use std::mem;
 use std::os::unix::io::AsRawFd;
-#[cfg(not(any(target_os = "linux", target_os = "android")))]
-use std::ffi::CStr;
 
-use crate::{NixPath, Result, errno::Errno};
+use cfg_if::cfg_if;
+
+#[cfg(all(
+    feature = "mount",
+    any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    )
+))]
+use crate::mount::MntFlags;
+#[cfg(target_os = "linux")]
+use crate::sys::statvfs::FsFlags;
+use crate::{errno::Errno, NixPath, Result};
 
 /// Identifies a mounted file system
 #[cfg(target_os = "android")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub type fsid_t = libc::__fsid_t;
 /// Identifies a mounted file system
 #[cfg(not(target_os = "android"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub type fsid_t = libc::fsid_t;
 
+cfg_if! {
+    if #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] {
+        type type_of_statfs = libc::statfs64;
+        const LIBC_FSTATFS: unsafe extern fn
+            (fd: libc::c_int, buf: *mut type_of_statfs) -> libc::c_int
+            = libc::fstatfs64;
+        const LIBC_STATFS: unsafe extern fn
+            (path: *const libc::c_char, buf: *mut type_of_statfs) -> libc::c_int
+            = libc::statfs64;
+    } else {
+        type type_of_statfs = libc::statfs;
+        const LIBC_FSTATFS: unsafe extern fn
+            (fd: libc::c_int, buf: *mut type_of_statfs) -> libc::c_int
+            = libc::fstatfs;
+        const LIBC_STATFS: unsafe extern fn
+            (path: *const libc::c_char, buf: *mut type_of_statfs) -> libc::c_int
+            = libc::statfs;
+    }
+}
+
 /// Describes a mounted file system
 #[derive(Clone, Copy)]
 #[repr(transparent)]
-pub struct Statfs(libc::statfs);
+pub struct Statfs(type_of_statfs);
 
 #[cfg(target_os = "freebsd")]
 type fs_type_t = u32;
@@ -29,7 +66,16 @@ type fs_type_t = libc::c_ulong;
 type fs_type_t = libc::c_uint;
 #[cfg(all(target_os = "linux", target_env = "musl"))]
 type fs_type_t = libc::c_ulong;
-#[cfg(all(target_os = "linux", not(any(target_arch = "s390x", target_env = "musl"))))]
+#[cfg(all(target_os = "linux", target_env = "uclibc"))]
+type fs_type_t = libc::c_int;
+#[cfg(all(
+    target_os = "linux",
+    not(any(
+        target_arch = "s390x",
+        target_env = "musl",
+        target_env = "uclibc"
+    ))
+))]
 type fs_type_t = libc::__fsword_t;
 
 /// Describes the file system type as known by the operating system.
@@ -38,101 +84,218 @@ type fs_type_t = libc::__fsword_t;
     target_os = "android",
     all(target_os = "linux", target_arch = "s390x"),
     all(target_os = "linux", target_env = "musl"),
-    all(target_os = "linux", not(any(target_arch = "s390x", target_env = "musl"))),
+    all(
+        target_os = "linux",
+        not(any(target_arch = "s390x", target_env = "musl"))
+    ),
 ))]
 #[derive(Eq, Copy, Clone, PartialEq, Debug)]
 pub struct FsType(pub fs_type_t);
 
 // These constants are defined without documentation in the Linux headers, so we
 // can't very well document them here.
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const ADFS_SUPER_MAGIC: FsType =
+    FsType(libc::ADFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const AFFS_SUPER_MAGIC: FsType =
+    FsType(libc::AFFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const AFS_SUPER_MAGIC: FsType = FsType(libc::AFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const AUTOFS_SUPER_MAGIC: FsType =
+    FsType(libc::AUTOFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const ADFS_SUPER_MAGIC: FsType = FsType(libc::ADFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const BPF_FS_MAGIC: FsType = FsType(libc::BPF_FS_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const AFFS_SUPER_MAGIC: FsType = FsType(libc::AFFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const BTRFS_SUPER_MAGIC: FsType =
+    FsType(libc::BTRFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const CODA_SUPER_MAGIC: FsType = FsType(libc::CODA_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const CGROUP2_SUPER_MAGIC: FsType =
+    FsType(libc::CGROUP2_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const CGROUP_SUPER_MAGIC: FsType =
+    FsType(libc::CGROUP_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const CODA_SUPER_MAGIC: FsType =
+    FsType(libc::CODA_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const CRAMFS_MAGIC: FsType = FsType(libc::CRAMFS_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const DEBUGFS_MAGIC: FsType = FsType(libc::DEBUGFS_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const DEVPTS_SUPER_MAGIC: FsType =
+    FsType(libc::DEVPTS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const ECRYPTFS_SUPER_MAGIC: FsType =
+    FsType(libc::ECRYPTFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const EFS_SUPER_MAGIC: FsType = FsType(libc::EFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const EXT2_SUPER_MAGIC: FsType =
+    FsType(libc::EXT2_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const EXT3_SUPER_MAGIC: FsType =
+    FsType(libc::EXT3_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const EXT4_SUPER_MAGIC: FsType =
+    FsType(libc::EXT4_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const EXT2_SUPER_MAGIC: FsType = FsType(libc::EXT2_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const F2FS_SUPER_MAGIC: FsType =
+    FsType(libc::F2FS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const EXT3_SUPER_MAGIC: FsType = FsType(libc::EXT3_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const FUSE_SUPER_MAGIC: FsType =
+    FsType(libc::FUSE_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const EXT4_SUPER_MAGIC: FsType = FsType(libc::EXT4_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const FUTEXFS_SUPER_MAGIC: FsType =
+    FsType(libc::FUTEXFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const HPFS_SUPER_MAGIC: FsType = FsType(libc::HPFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const HOSTFS_SUPER_MAGIC: FsType =
+    FsType(libc::HOSTFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const HPFS_SUPER_MAGIC: FsType =
+    FsType(libc::HPFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const HUGETLBFS_MAGIC: FsType = FsType(libc::HUGETLBFS_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const ISOFS_SUPER_MAGIC: FsType =
+    FsType(libc::ISOFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const ISOFS_SUPER_MAGIC: FsType = FsType(libc::ISOFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const JFFS2_SUPER_MAGIC: FsType =
+    FsType(libc::JFFS2_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const JFFS2_SUPER_MAGIC: FsType = FsType(libc::JFFS2_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MINIX2_SUPER_MAGIC2: FsType =
+    FsType(libc::MINIX2_SUPER_MAGIC2 as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const MINIX_SUPER_MAGIC: FsType = FsType(libc::MINIX_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MINIX2_SUPER_MAGIC: FsType =
+    FsType(libc::MINIX2_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const MINIX_SUPER_MAGIC2: FsType = FsType(libc::MINIX_SUPER_MAGIC2 as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MINIX3_SUPER_MAGIC: FsType =
+    FsType(libc::MINIX3_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const MINIX2_SUPER_MAGIC: FsType = FsType(libc::MINIX2_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MINIX_SUPER_MAGIC2: FsType =
+    FsType(libc::MINIX_SUPER_MAGIC2 as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const MINIX2_SUPER_MAGIC2: FsType = FsType(libc::MINIX2_SUPER_MAGIC2 as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MINIX_SUPER_MAGIC: FsType =
+    FsType(libc::MINIX_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const MSDOS_SUPER_MAGIC: FsType = FsType(libc::MSDOS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const MSDOS_SUPER_MAGIC: FsType =
+    FsType(libc::MSDOS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const NCP_SUPER_MAGIC: FsType = FsType(libc::NCP_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const NFS_SUPER_MAGIC: FsType = FsType(libc::NFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const NILFS_SUPER_MAGIC: FsType =
+    FsType(libc::NILFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const OCFS2_SUPER_MAGIC: FsType =
+    FsType(libc::OCFS2_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const OPENPROM_SUPER_MAGIC: FsType =
+    FsType(libc::OPENPROM_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const OVERLAYFS_SUPER_MAGIC: FsType =
+    FsType(libc::OVERLAYFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const PROC_SUPER_MAGIC: FsType =
+    FsType(libc::PROC_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const QNX4_SUPER_MAGIC: FsType =
+    FsType(libc::QNX4_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const OPENPROM_SUPER_MAGIC: FsType = FsType(libc::OPENPROM_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const QNX6_SUPER_MAGIC: FsType =
+    FsType(libc::QNX6_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const OVERLAYFS_SUPER_MAGIC: FsType = FsType(libc::OVERLAYFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const RDTGROUP_SUPER_MAGIC: FsType =
+    FsType(libc::RDTGROUP_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const PROC_SUPER_MAGIC: FsType = FsType(libc::PROC_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const REISERFS_SUPER_MAGIC: FsType =
+    FsType(libc::REISERFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const QNX4_SUPER_MAGIC: FsType = FsType(libc::QNX4_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const SECURITYFS_MAGIC: FsType =
+    FsType(libc::SECURITYFS_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const REISERFS_SUPER_MAGIC: FsType = FsType(libc::REISERFS_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const SELINUX_MAGIC: FsType = FsType(libc::SELINUX_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const SMACK_MAGIC: FsType = FsType(libc::SMACK_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const SMB_SUPER_MAGIC: FsType = FsType(libc::SMB_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const SYSFS_MAGIC: FsType = FsType(libc::SYSFS_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
 pub const TMPFS_MAGIC: FsType = FsType(libc::TMPFS_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const USBDEVICE_SUPER_MAGIC: FsType = FsType(libc::USBDEVICE_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const TRACEFS_MAGIC: FsType = FsType(libc::TRACEFS_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const CGROUP_SUPER_MAGIC: FsType = FsType(libc::CGROUP_SUPER_MAGIC as fs_type_t);
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const UDF_SUPER_MAGIC: FsType = FsType(libc::UDF_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[allow(missing_docs)]
-pub const CGROUP2_SUPER_MAGIC: FsType = FsType(libc::CGROUP2_SUPER_MAGIC as fs_type_t);
-
+pub const USBDEVICE_SUPER_MAGIC: FsType =
+    FsType(libc::USBDEVICE_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const XENFS_SUPER_MAGIC: FsType =
+    FsType(libc::XENFS_SUPER_MAGIC as fs_type_t);
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[allow(missing_docs)]
+pub const NSFS_MAGIC: FsType = FsType(libc::NSFS_MAGIC as fs_type_t);
+#[cfg(all(
+    any(target_os = "linux", target_os = "android"),
+    not(target_env = "musl")
+))]
+#[allow(missing_docs)]
+pub const XFS_SUPER_MAGIC: FsType = FsType(libc::XFS_SUPER_MAGIC as fs_type_t);
 
 impl Statfs {
     /// Magic code defining system type
@@ -142,12 +305,14 @@ impl Statfs {
         target_os = "ios",
         target_os = "macos"
     )))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn filesystem_type(&self) -> FsType {
         FsType(self.0.f_type)
     }
 
     /// Magic code defining system type
     #[cfg(not(any(target_os = "linux", target_os = "android")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn filesystem_type_name(&self) -> &str {
         let c_str = unsafe { CStr::from_ptr(self.0.f_fstypename.as_ptr()) };
         c_str.to_str().unwrap()
@@ -155,18 +320,21 @@ impl Statfs {
 
     /// Optimal transfer block size
     #[cfg(any(target_os = "ios", target_os = "macos"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> i32 {
         self.0.f_iosize
     }
 
     /// Optimal transfer block size
     #[cfg(target_os = "openbsd")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> u32 {
         self.0.f_iosize
     }
 
     /// Optimal transfer block size
     #[cfg(all(target_os = "linux", target_arch = "s390x"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> u32 {
         self.0.f_bsize
     }
@@ -176,30 +344,49 @@ impl Statfs {
         target_os = "android",
         all(target_os = "linux", target_env = "musl")
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> libc::c_ulong {
         self.0.f_bsize
     }
 
     /// Optimal transfer block size
-    #[cfg(all(target_os = "linux", not(any(target_arch = "s390x", target_env = "musl"))))]
+    #[cfg(all(
+        target_os = "linux",
+        not(any(
+            target_arch = "s390x",
+            target_env = "musl",
+            target_env = "uclibc"
+        ))
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> libc::__fsword_t {
         self.0.f_bsize
     }
 
     /// Optimal transfer block size
+    #[cfg(all(target_os = "linux", target_env = "uclibc"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn optimal_transfer_size(&self) -> libc::c_int {
+        self.0.f_bsize
+    }
+
+    /// Optimal transfer block size
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> libc::c_long {
         self.0.f_iosize
     }
 
     /// Optimal transfer block size
     #[cfg(target_os = "freebsd")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn optimal_transfer_size(&self) -> u64 {
         self.0.f_iosize
     }
 
     /// Size of a block
     #[cfg(any(target_os = "ios", target_os = "macos", target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> u32 {
         self.0.f_bsize
     }
@@ -207,6 +394,7 @@ impl Statfs {
     /// Size of a block
     // f_bsize on linux: https://github.com/torvalds/linux/blob/master/fs/nfs/super.c#L471
     #[cfg(all(target_os = "linux", target_arch = "s390x"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> u32 {
         self.0.f_bsize
     }
@@ -214,61 +402,126 @@ impl Statfs {
     /// Size of a block
     // f_bsize on linux: https://github.com/torvalds/linux/blob/master/fs/nfs/super.c#L471
     #[cfg(all(target_os = "linux", target_env = "musl"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> libc::c_ulong {
         self.0.f_bsize
     }
 
     /// Size of a block
     // f_bsize on linux: https://github.com/torvalds/linux/blob/master/fs/nfs/super.c#L471
-    #[cfg(all(target_os = "linux", not(any(target_arch = "s390x", target_env = "musl"))))]
+    #[cfg(all(target_os = "linux", target_env = "uclibc"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn block_size(&self) -> libc::c_int {
+        self.0.f_bsize
+    }
+
+    /// Size of a block
+    // f_bsize on linux: https://github.com/torvalds/linux/blob/master/fs/nfs/super.c#L471
+    #[cfg(all(
+        target_os = "linux",
+        not(any(
+            target_arch = "s390x",
+            target_env = "musl",
+            target_env = "uclibc"
+        ))
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> libc::__fsword_t {
         self.0.f_bsize
     }
 
     /// Size of a block
     #[cfg(target_os = "freebsd")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> u64 {
         self.0.f_bsize
     }
 
     /// Size of a block
     #[cfg(target_os = "android")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> libc::c_ulong {
         self.0.f_bsize
     }
 
     /// Size of a block
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn block_size(&self) -> libc::c_long {
         self.0.f_bsize
     }
 
+    /// Get the mount flags
+    #[cfg(all(
+        feature = "mount",
+        any(
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "macos",
+            target_os = "netbsd",
+            target_os = "openbsd"
+        )
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    #[allow(clippy::unnecessary_cast)] // Not unnecessary on all arches
+    pub fn flags(&self) -> MntFlags {
+        MntFlags::from_bits_truncate(self.0.f_flags as i32)
+    }
+
+    /// Get the mount flags
+    // The f_flags field exists on Android and Fuchsia too, but without man
+    // pages I can't tell if it can be cast to FsFlags.
+    #[cfg(target_os = "linux")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn flags(&self) -> FsFlags {
+        FsFlags::from_bits_truncate(self.0.f_flags as libc::c_ulong)
+    }
+
     /// Maximum length of filenames
     #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn maximum_name_length(&self) -> u32 {
         self.0.f_namemax
     }
 
     /// Maximum length of filenames
     #[cfg(all(target_os = "linux", target_arch = "s390x"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn maximum_name_length(&self) -> u32 {
         self.0.f_namelen
     }
 
     /// Maximum length of filenames
     #[cfg(all(target_os = "linux", target_env = "musl"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn maximum_name_length(&self) -> libc::c_ulong {
         self.0.f_namelen
     }
 
     /// Maximum length of filenames
-    #[cfg(all(target_os = "linux", not(any(target_arch = "s390x", target_env = "musl"))))]
+    #[cfg(all(target_os = "linux", target_env = "uclibc"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn maximum_name_length(&self) -> libc::c_int {
+        self.0.f_namelen
+    }
+
+    /// Maximum length of filenames
+    #[cfg(all(
+        target_os = "linux",
+        not(any(
+            target_arch = "s390x",
+            target_env = "musl",
+            target_env = "uclibc"
+        ))
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn maximum_name_length(&self) -> libc::__fsword_t {
         self.0.f_namelen
     }
 
     /// Maximum length of filenames
     #[cfg(target_os = "android")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn maximum_name_length(&self) -> libc::c_ulong {
         self.0.f_namelen
     }
@@ -279,35 +532,26 @@ impl Statfs {
         target_os = "macos",
         target_os = "android",
         target_os = "freebsd",
+        target_os = "fuchsia",
         target_os = "openbsd",
+        target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks(&self) -> u64 {
         self.0.f_blocks
     }
 
     /// Total data blocks in filesystem
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks(&self) -> libc::c_long {
         self.0.f_blocks
     }
 
     /// Total data blocks in filesystem
-    #[cfg(all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32"))))]
-    pub fn blocks(&self) -> u64 {
-        self.0.f_blocks
-    }
-
-    /// Total data blocks in filesystem
-    #[cfg(not(any(
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32")))
-    )))]
-    pub fn blocks(&self) -> libc::c_ulong {
+    #[cfg(target_os = "emscripten")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn blocks(&self) -> u32 {
         self.0.f_blocks
     }
 
@@ -317,73 +561,60 @@ impl Statfs {
         target_os = "macos",
         target_os = "android",
         target_os = "freebsd",
+        target_os = "fuchsia",
         target_os = "openbsd",
+        target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks_free(&self) -> u64 {
         self.0.f_bfree
     }
 
     /// Free blocks in filesystem
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks_free(&self) -> libc::c_long {
         self.0.f_bfree
     }
 
     /// Free blocks in filesystem
-    #[cfg(all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32"))))]
-    pub fn blocks_free(&self) -> u64 {
+    #[cfg(target_os = "emscripten")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn blocks_free(&self) -> u32 {
         self.0.f_bfree
     }
 
-    /// Free blocks in filesystem
-    #[cfg(not(any(
+    /// Free blocks available to unprivileged user
+    #[cfg(any(
         target_os = "ios",
         target_os = "macos",
         target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32")))
-    )))]
-    pub fn blocks_free(&self) -> libc::c_ulong {
-        self.0.f_bfree
-    }
-
-    /// Free blocks available to unprivileged user
-    #[cfg(any(target_os = "ios", target_os = "macos", target_os = "android"))]
+        target_os = "fuchsia",
+        target_os = "linux",
+    ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks_available(&self) -> u64 {
         self.0.f_bavail
     }
 
     /// Free blocks available to unprivileged user
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks_available(&self) -> libc::c_long {
         self.0.f_bavail
     }
 
     /// Free blocks available to unprivileged user
     #[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn blocks_available(&self) -> i64 {
         self.0.f_bavail
     }
 
     /// Free blocks available to unprivileged user
-    #[cfg(all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32"))))]
-    pub fn blocks_available(&self) -> u64 {
-        self.0.f_bavail
-    }
-
-    /// Free blocks available to unprivileged user
-    #[cfg(not(any(
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32")))
-    )))]
-    pub fn blocks_available(&self) -> libc::c_ulong {
+    #[cfg(target_os = "emscripten")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn blocks_available(&self) -> u32 {
         self.0.f_bavail
     }
 
@@ -393,78 +624,61 @@ impl Statfs {
         target_os = "macos",
         target_os = "android",
         target_os = "freebsd",
+        target_os = "fuchsia",
         target_os = "openbsd",
+        target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn files(&self) -> u64 {
         self.0.f_files
     }
 
     /// Total file nodes in filesystem
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn files(&self) -> libc::c_long {
         self.0.f_files
     }
 
     /// Total file nodes in filesystem
-    #[cfg(all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32"))))]
-    pub fn files(&self) -> libc::fsfilcnt_t {
+    #[cfg(target_os = "emscripten")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn files(&self) -> u32 {
         self.0.f_files
     }
 
-    /// Total file nodes in filesystem
-    #[cfg(not(any(
+    /// Free file nodes in filesystem
+    #[cfg(any(
         target_os = "ios",
         target_os = "macos",
         target_os = "android",
-        target_os = "freebsd",
+        target_os = "fuchsia",
         target_os = "openbsd",
-        target_os = "dragonfly",
-        all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32")))
-    )))]
-    pub fn files(&self) -> libc::c_ulong {
-        self.0.f_files
-    }
-
-    /// Free file nodes in filesystem
-    #[cfg(any(
-            target_os = "android",
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "openbsd"
+        target_os = "linux",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn files_free(&self) -> u64 {
         self.0.f_ffree
     }
 
     /// Free file nodes in filesystem
     #[cfg(target_os = "dragonfly")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn files_free(&self) -> libc::c_long {
         self.0.f_ffree
     }
 
     /// Free file nodes in filesystem
     #[cfg(target_os = "freebsd")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn files_free(&self) -> i64 {
         self.0.f_ffree
     }
 
     /// Free file nodes in filesystem
-    #[cfg(all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32"))))]
-    pub fn files_free(&self) -> libc::fsfilcnt_t {
-        self.0.f_ffree
-    }
-
-    /// Free file nodes in filesystem
-    #[cfg(not(any(
-        target_os = "ios",
-        target_os = "macos",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "dragonfly",
-        all(target_os = "linux", any(target_env = "musl", all(target_arch = "x86_64", target_pointer_width = "32")))
-    )))]
-    pub fn files_free(&self) -> libc::c_ulong {
+    #[cfg(target_os = "emscripten")]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub fn files_free(&self) -> u32 {
         self.0.f_ffree
     }
 
@@ -476,22 +690,33 @@ impl Statfs {
 
 impl Debug for Statfs {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Statfs")
-            .field("optimal_transfer_size", &self.optimal_transfer_size())
-            .field("block_size", &self.block_size())
-            .field("blocks", &self.blocks())
-            .field("blocks_free", &self.blocks_free())
-            .field("blocks_available", &self.blocks_available())
-            .field("files", &self.files())
-            .field("files_free", &self.files_free())
-            .field("filesystem_id", &self.filesystem_id())
-            .finish()
+        let mut ds = f.debug_struct("Statfs");
+        ds.field("optimal_transfer_size", &self.optimal_transfer_size());
+        ds.field("block_size", &self.block_size());
+        ds.field("blocks", &self.blocks());
+        ds.field("blocks_free", &self.blocks_free());
+        ds.field("blocks_available", &self.blocks_available());
+        ds.field("files", &self.files());
+        ds.field("files_free", &self.files_free());
+        ds.field("filesystem_id", &self.filesystem_id());
+        #[cfg(all(
+            feature = "mount",
+            any(
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "macos",
+                target_os = "netbsd",
+                target_os = "openbsd"
+            )
+        ))]
+        ds.field("flags", &self.flags());
+        ds.finish()
     }
 }
 
 /// Describes a mounted file system.
 ///
-/// The result is OS-dependent.  For a portabable alternative, see
+/// The result is OS-dependent.  For a portable alternative, see
 /// [`statvfs`](crate::sys::statvfs::statvfs).
 ///
 /// # Arguments
@@ -499,15 +724,17 @@ impl Debug for Statfs {
 /// `path` - Path to any file within the file system to describe
 pub fn statfs<P: ?Sized + NixPath>(path: &P) -> Result<Statfs> {
     unsafe {
-        let mut stat = mem::MaybeUninit::<libc::statfs>::uninit();
-        let res = path.with_nix_path(|path| libc::statfs(path.as_ptr(), stat.as_mut_ptr()))?;
+        let mut stat = mem::MaybeUninit::<type_of_statfs>::uninit();
+        let res = path.with_nix_path(|path| {
+            LIBC_STATFS(path.as_ptr(), stat.as_mut_ptr())
+        })?;
         Errno::result(res).map(|_| Statfs(stat.assume_init()))
     }
 }
 
 /// Describes a mounted file system.
 ///
-/// The result is OS-dependent.  For a portabable alternative, see
+/// The result is OS-dependent.  For a portable alternative, see
 /// [`fstatvfs`](crate::sys::statvfs::fstatvfs).
 ///
 /// # Arguments
@@ -515,8 +742,8 @@ pub fn statfs<P: ?Sized + NixPath>(path: &P) -> Result<Statfs> {
 /// `fd` - File descriptor of any open file within the file system to describe
 pub fn fstatfs<T: AsRawFd>(fd: &T) -> Result<Statfs> {
     unsafe {
-        let mut stat = mem::MaybeUninit::<libc::statfs>::uninit();
-        Errno::result(libc::fstatfs(fd.as_raw_fd(), stat.as_mut_ptr()))
+        let mut stat = mem::MaybeUninit::<type_of_statfs>::uninit();
+        Errno::result(LIBC_FSTATFS(fd.as_raw_fd(), stat.as_mut_ptr()))
             .map(|_| Statfs(stat.assume_init()))
     }
 }
@@ -564,6 +791,8 @@ mod test {
         assert_fs_equals(fs, vfs);
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn assert_fs_equals(fs: Statfs, vfs: Statvfs) {
         assert_eq!(fs.files() as u64, vfs.files() as u64);
         assert_eq!(fs.blocks() as u64, vfs.blocks() as u64);
@@ -611,6 +840,8 @@ mod test {
         assert_fs_equals_strict(fs.unwrap(), vfs.unwrap())
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn assert_fs_equals_strict(fs: Statfs, vfs: Statvfs) {
         assert_eq!(fs.files_free() as u64, vfs.files_free() as u64);
         assert_eq!(fs.blocks_free() as u64, vfs.blocks_free() as u64);
diff --git a/src/sys/statvfs.rs b/src/sys/statvfs.rs
index 15e7a7d..8de369f 100644
--- a/src/sys/statvfs.rs
+++ b/src/sys/statvfs.rs
@@ -7,7 +7,7 @@ use std::os::unix::io::AsRawFd;
 
 use libc::{self, c_ulong};
 
-use crate::{Result, NixPath, errno::Errno};
+use crate::{errno::Errno, NixPath, Result};
 
 #[cfg(not(target_os = "redox"))]
 libc_bitflags!(
@@ -16,38 +16,50 @@ libc_bitflags!(
     #[derive(Default)]
     pub struct FsFlags: c_ulong {
         /// Read Only
+        #[cfg(not(target_os = "haiku"))]
         ST_RDONLY;
         /// Do not allow the set-uid bits to have an effect
+        #[cfg(not(target_os = "haiku"))]
         ST_NOSUID;
         /// Do not interpret character or block-special devices
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_NODEV;
         /// Do not allow execution of binaries on the filesystem
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_NOEXEC;
         /// All IO should be done synchronously
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_SYNCHRONOUS;
         /// Allow mandatory locks on the filesystem
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_MANDLOCK;
         /// Write on file/directory/symlink
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_WRITE;
         /// Append-only file
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_APPEND;
         /// Immutable file
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_IMMUTABLE;
         /// Do not update access times on files
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_NOATIME;
         /// Do not update access times on files
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_NODIRATIME;
         /// Update access time relative to modify/change time
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_env = "musl"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ST_RELATIME;
     }
 );
@@ -109,6 +121,7 @@ impl Statvfs {
 
     /// Get the mount flags
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn flags(&self) -> FsFlags {
         FsFlags::from_bits_truncate(self.0.f_flag)
     }
@@ -117,7 +130,6 @@ impl Statvfs {
     pub fn name_max(&self) -> c_ulong {
         self.0.f_namemax
     }
-
 }
 
 /// Return a `Statvfs` object with information about the `path`
@@ -125,9 +137,9 @@ pub fn statvfs<P: ?Sized + NixPath>(path: &P) -> Result<Statvfs> {
     unsafe {
         Errno::clear();
         let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit();
-        let res = path.with_nix_path(|path|
+        let res = path.with_nix_path(|path| {
             libc::statvfs(path.as_ptr(), stat.as_mut_ptr())
-        )?;
+        })?;
 
         Errno::result(res).map(|_| Statvfs(stat.assume_init()))
     }
@@ -145,8 +157,8 @@ pub fn fstatvfs<T: AsRawFd>(fd: &T) -> Result<Statvfs> {
 
 #[cfg(test)]
 mod test {
-    use std::fs::File;
     use crate::sys::statvfs::*;
+    use std::fs::File;
 
     #[test]
     fn statvfs_call() {
diff --git a/src/sys/sysinfo.rs b/src/sys/sysinfo.rs
index dc943c1..e8aa00b 100644
--- a/src/sys/sysinfo.rs
+++ b/src/sys/sysinfo.rs
@@ -1,9 +1,9 @@
 use libc::{self, SI_LOAD_SHIFT};
-use std::{cmp, mem};
 use std::time::Duration;
+use std::{cmp, mem};
 
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
 
 /// System info structure returned by `sysinfo`.
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
@@ -30,6 +30,8 @@ impl SysInfo {
     }
 
     /// Returns the time since system boot.
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     pub fn uptime(&self) -> Duration {
         // Truncate negative values to 0
         Duration::from_secs(cmp::max(self.0.uptime, 0) as u64)
@@ -64,6 +66,8 @@ impl SysInfo {
         self.scale_mem(self.0.freeram)
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn scale_mem(&self, units: mem_blocks_t) -> u64 {
         units as u64 * self.0.mem_unit as u64
     }
@@ -75,5 +79,5 @@ impl SysInfo {
 pub fn sysinfo() -> Result<SysInfo> {
     let mut info = mem::MaybeUninit::uninit();
     let res = unsafe { libc::sysinfo(info.as_mut_ptr()) };
-    Errno::result(res).map(|_| unsafe{ SysInfo(info.assume_init()) })
+    Errno::result(res).map(|_| unsafe { SysInfo(info.assume_init()) })
 }
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
index 01d4608..fba2cd8 100644
--- a/src/sys/termios.rs
+++ b/src/sys/termios.rs
@@ -64,9 +64,9 @@
 //! # use nix::sys::termios::{BaudRate, cfsetispeed, cfsetospeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
-//! cfsetispeed(&mut t, BaudRate::B9600);
-//! cfsetospeed(&mut t, BaudRate::B9600);
-//! cfsetspeed(&mut t, BaudRate::B9600);
+//! cfsetispeed(&mut t, BaudRate::B9600).unwrap();
+//! cfsetospeed(&mut t, BaudRate::B9600).unwrap();
+//! cfsetspeed(&mut t, BaudRate::B9600).unwrap();
 //! # }
 //! ```
 //!
@@ -76,21 +76,37 @@
 //! # use nix::sys::termios::{BaudRate, cfgetispeed, cfgetospeed, cfsetispeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
-//! # cfsetspeed(&mut t, BaudRate::B9600);
+//! # cfsetspeed(&mut t, BaudRate::B9600).unwrap();
 //! let speed = cfgetispeed(&t);
 //! assert_eq!(speed, cfgetospeed(&t));
-//! cfsetispeed(&mut t, speed);
+//! cfsetispeed(&mut t, speed).unwrap();
 //! # }
 //! ```
 //!
 //! On non-BSDs, `cfgetispeed()` and `cfgetospeed()` both return a `BaudRate`:
 //!
-#![cfg_attr(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                target_os = "macos", target_os = "netbsd", target_os = "openbsd"),
-            doc = " ```rust,ignore")]
-#![cfg_attr(not(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                    target_os = "macos", target_os = "netbsd", target_os = "openbsd")),
-            doc = " ```rust")]
+#![cfg_attr(
+    any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    doc = " ```rust,ignore"
+)]
+#![cfg_attr(
+    not(any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    )),
+    doc = " ```rust"
+)]
 //! # use nix::sys::termios::{BaudRate, cfgetispeed, cfgetospeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
@@ -102,12 +118,28 @@
 //!
 //! But on the BSDs, `cfgetispeed()` and `cfgetospeed()` both return `u32`s:
 //!
-#![cfg_attr(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                target_os = "macos", target_os = "netbsd", target_os = "openbsd"),
-            doc = " ```rust")]
-#![cfg_attr(not(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                    target_os = "macos", target_os = "netbsd", target_os = "openbsd")),
-            doc = " ```rust,ignore")]
+#![cfg_attr(
+    any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    doc = " ```rust"
+)]
+#![cfg_attr(
+    not(any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    )),
+    doc = " ```rust,ignore"
+)]
 //! # use nix::sys::termios::{BaudRate, cfgetispeed, cfgetospeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
@@ -119,12 +151,28 @@
 //!
 //! It's trivial to convert from a `BaudRate` to a `u32` on BSDs:
 //!
-#![cfg_attr(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                target_os = "macos", target_os = "netbsd", target_os = "openbsd"),
-            doc = " ```rust")]
-#![cfg_attr(not(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                    target_os = "macos", target_os = "netbsd", target_os = "openbsd")),
-            doc = " ```rust,ignore")]
+#![cfg_attr(
+    any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    doc = " ```rust"
+)]
+#![cfg_attr(
+    not(any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    )),
+    doc = " ```rust,ignore"
+)]
 //! # use nix::sys::termios::{BaudRate, cfgetispeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
@@ -137,12 +185,28 @@
 //! And on BSDs you can specify arbitrary baud rates (**note** this depends on hardware support)
 //! by specifying baud rates directly using `u32`s:
 //!
-#![cfg_attr(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                target_os = "macos", target_os = "netbsd", target_os = "openbsd"),
-            doc = " ```rust")]
-#![cfg_attr(not(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
-                    target_os = "macos", target_os = "netbsd", target_os = "openbsd")),
-            doc = " ```rust,ignore")]
+#![cfg_attr(
+    any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ),
+    doc = " ```rust"
+)]
+#![cfg_attr(
+    not(any(
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    )),
+    doc = " ```rust,ignore"
+)]
 //! # use nix::sys::termios::{cfsetispeed, cfsetospeed, cfsetspeed, Termios};
 //! # fn main() {
 //! # let mut t: Termios = unsafe { std::mem::zeroed() };
@@ -151,15 +215,16 @@
 //! cfsetspeed(&mut t, 9600u32);
 //! # }
 //! ```
-use cfg_if::cfg_if;
-use crate::Result;
 use crate::errno::Errno;
+use crate::Result;
+use cfg_if::cfg_if;
 use libc::{self, c_int, tcflag_t};
 use std::cell::{Ref, RefCell};
 use std::convert::From;
 use std::mem;
 use std::os::unix::io::RawFd;
 
+#[cfg(feature = "process")]
 use crate::unistd::Pid;
 
 /// Stores settings for the termios API
@@ -180,6 +245,12 @@ pub struct Termios {
     pub local_flags: LocalFlags,
     /// Control characters (see `termios.c_cc` documentation)
     pub control_chars: [libc::cc_t; NCCS],
+    /// Line discipline (see `termios.c_line` documentation)
+    #[cfg(any(target_os = "linux", target_os = "android",))]
+    pub line_discipline: libc::cc_t,
+    /// Line discipline (see `termios.c_line` documentation)
+    #[cfg(target_os = "haiku")]
+    pub line_discipline: libc::c_char,
 }
 
 impl Termios {
@@ -195,6 +266,14 @@ impl Termios {
             termios.c_cflag = self.control_flags.bits();
             termios.c_lflag = self.local_flags.bits();
             termios.c_cc = self.control_chars;
+            #[cfg(any(
+                target_os = "linux",
+                target_os = "android",
+                target_os = "haiku",
+            ))]
+            {
+                termios.c_line = self.line_discipline;
+            }
         }
         self.inner.borrow()
     }
@@ -213,6 +292,14 @@ impl Termios {
             termios.c_cflag = self.control_flags.bits();
             termios.c_lflag = self.local_flags.bits();
             termios.c_cc = self.control_chars;
+            #[cfg(any(
+                target_os = "linux",
+                target_os = "android",
+                target_os = "haiku",
+            ))]
+            {
+                termios.c_line = self.line_discipline;
+            }
         }
         self.inner.as_ptr()
     }
@@ -225,6 +312,14 @@ impl Termios {
         self.control_flags = ControlFlags::from_bits_truncate(termios.c_cflag);
         self.local_flags = LocalFlags::from_bits_truncate(termios.c_lflag);
         self.control_chars = termios.c_cc;
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "android",
+            target_os = "haiku",
+        ))]
+        {
+            self.line_discipline = termios.c_line;
+        }
     }
 }
 
@@ -237,6 +332,12 @@ impl From<libc::termios> for Termios {
             control_flags: ControlFlags::from_bits_truncate(termios.c_cflag),
             local_flags: LocalFlags::from_bits_truncate(termios.c_lflag),
             control_chars: termios.c_cc,
+            #[cfg(any(
+                target_os = "linux",
+                target_os = "android",
+                target_os = "haiku",
+            ))]
+            line_discipline: termios.c_line,
         }
     }
 }
@@ -247,15 +348,16 @@ impl From<Termios> for libc::termios {
     }
 }
 
-libc_enum!{
+libc_enum! {
     /// Baud rates supported by the system.
     ///
     /// For the BSDs, arbitrary baud rates can be specified by using `u32`s directly instead of this
     /// enum.
     ///
     /// B0 is special and will disable the port.
+    #[cfg_attr(all(any(target_os = "haiku"), target_pointer_width = "64"), repr(u8))]
     #[cfg_attr(all(any(target_os = "ios", target_os = "macos"), target_pointer_width = "64"), repr(u64))]
-    #[cfg_attr(not(all(any(target_os = "ios", target_os = "macos"), target_pointer_width = "64")), repr(u32))]
+    #[cfg_attr(not(all(any(target_os = "ios", target_os = "macos", target_os = "haiku"), target_pointer_width = "64")), repr(u32))]
     #[non_exhaustive]
     pub enum BaudRate {
         B0,
@@ -276,6 +378,7 @@ libc_enum!{
                 target_os = "macos",
                 target_os = "netbsd",
                 target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B7200,
         B9600,
         #[cfg(any(target_os = "dragonfly",
@@ -283,6 +386,7 @@ libc_enum!{
                 target_os = "macos",
                 target_os = "netbsd",
                 target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B14400,
         B19200,
         #[cfg(any(target_os = "dragonfly",
@@ -290,6 +394,7 @@ libc_enum!{
                 target_os = "macos",
                 target_os = "netbsd",
                 target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B28800,
         B38400,
         B57600,
@@ -298,12 +403,15 @@ libc_enum!{
                 target_os = "macos",
                 target_os = "netbsd",
                 target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B76800,
         B115200,
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B153600,
         B230400,
         #[cfg(any(target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B307200,
         #[cfg(any(target_os = "android",
                   target_os = "freebsd",
@@ -311,10 +419,13 @@ libc_enum!{
                   target_os = "linux",
                   target_os = "netbsd",
                   target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B460800,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B500000,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B576000,
         #[cfg(any(target_os = "android",
                   target_os = "freebsd",
@@ -322,39 +433,57 @@ libc_enum!{
                   target_os = "linux",
                   target_os = "netbsd",
                   target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B921600,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B1000000,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B1152000,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B1500000,
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B2000000,
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_arch = "sparc64"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B2500000,
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_arch = "sparc64"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B3000000,
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_arch = "sparc64"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B3500000,
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_arch = "sparc64"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         B4000000,
     }
     impl TryFrom<libc::speed_t>
 }
 
-#[cfg(any(target_os = "freebsd",
-          target_os = "dragonfly",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 impl From<BaudRate> for u32 {
     fn from(b: BaudRate) -> u32 {
         b as u32
     }
 }
 
+#[cfg(target_os = "haiku")]
+impl From<BaudRate> for u8 {
+    fn from(b: BaudRate) -> u8 {
+        b as u8
+    }
+}
+
 // TODO: Add TCSASOFT, which will require treating this as a bitfield.
 libc_enum! {
     /// Specify when a port configuration change should occur.
@@ -407,6 +536,7 @@ libc_enum! {
 }
 
 // TODO: Make this usable directly as a slice index.
+#[cfg(not(target_os = "haiku"))]
 libc_enum! {
     /// Indices into the `termios.c_cc` array for special characters.
     #[repr(usize)]
@@ -420,6 +550,7 @@ libc_enum! {
                 target_os = "netbsd",
                 target_os = "openbsd",
                 target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VDSUSP,
         VEOF,
         VEOL,
@@ -429,12 +560,14 @@ libc_enum! {
                   target_os = "freebsd",
                   target_os = "illumos",
                   target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VERASE2,
         VINTR,
         VKILL,
         VLNEXT,
         #[cfg(not(any(all(target_os = "linux", target_arch = "sparc64"),
                 target_os = "illumos", target_os = "solaris")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VMIN,
         VQUIT,
         VREPRINT,
@@ -446,36 +579,48 @@ libc_enum! {
                 target_os = "netbsd",
                 target_os = "openbsd",
                 target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VSTATUS,
         VSTOP,
         VSUSP,
         #[cfg(target_os = "linux")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VSWTC,
         #[cfg(any(target_os = "haiku", target_os = "illumos", target_os = "solaris"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VSWTCH,
         #[cfg(not(any(all(target_os = "linux", target_arch = "sparc64"),
                 target_os = "illumos", target_os = "solaris")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VTIME,
         VWERASE,
         #[cfg(target_os = "dragonfly")]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VCHECKPT,
     }
 }
 
-#[cfg(any(all(target_os = "linux", target_arch = "sparc64"),
-        target_os = "illumos", target_os = "solaris"))]
+#[cfg(any(
+    all(target_os = "linux", target_arch = "sparc64"),
+    target_os = "illumos",
+    target_os = "solaris"
+))]
 impl SpecialCharacterIndices {
     pub const VMIN: SpecialCharacterIndices = SpecialCharacterIndices::VEOF;
     pub const VTIME: SpecialCharacterIndices = SpecialCharacterIndices::VEOL;
 }
 
 pub use libc::NCCS;
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub use libc::_POSIX_VDISABLE;
 
 libc_bitflags! {
@@ -493,10 +638,13 @@ libc_bitflags! {
         IXON;
         IXOFF;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IXANY;
-        #[cfg(not(target_os = "redox"))]
+        #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IMAXBEL;
         #[cfg(any(target_os = "android", target_os = "linux", target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         IUTF8;
     }
 }
@@ -509,6 +657,7 @@ libc_bitflags! {
                   target_os = "haiku",
                   target_os = "linux",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         OLCUC;
         ONLCR;
         OCRNL as tcflag_t;
@@ -519,48 +668,56 @@ libc_bitflags! {
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         OFILL as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         OFDEL as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         NL0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         NL1 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CR0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CR1 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CR2 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CR3 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "freebsd",
@@ -568,18 +725,21 @@ libc_bitflags! {
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         TAB0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         TAB1 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         TAB2 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "freebsd",
@@ -587,44 +747,52 @@ libc_bitflags! {
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         TAB3 as tcflag_t;
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         XTABS;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         BS0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         BS1 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VT0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VT1 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         FF0 as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         FF1 as tcflag_t;
         #[cfg(any(target_os = "freebsd",
                   target_os = "dragonfly",
@@ -632,12 +800,14 @@ libc_bitflags! {
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         OXTABS;
         #[cfg(any(target_os = "freebsd",
                   target_os = "dragonfly",
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ONOEOT as tcflag_t;
 
         // Bitmasks for use with OutputFlags to select specific settings
@@ -649,12 +819,14 @@ libc_bitflags! {
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         NLDLY as tcflag_t; // FIXME: Datatype needs to be corrected in libc for mac
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CRDLY as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "freebsd",
@@ -662,24 +834,28 @@ libc_bitflags! {
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         TABDLY as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         BSDLY as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         VTDLY as tcflag_t;
         #[cfg(any(target_os = "android",
                   target_os = "haiku",
                   target_os = "ios",
                   target_os = "linux",
                   target_os = "macos"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         FFDLY as tcflag_t;
     }
 }
@@ -693,6 +869,7 @@ libc_bitflags! {
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CIGNORE;
         CS5;
         CS6;
@@ -705,43 +882,54 @@ libc_bitflags! {
         HUPCL;
         CLOCAL;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CRTSCTS;
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CBAUD;
         #[cfg(any(target_os = "android", all(target_os = "linux", not(target_arch = "mips"))))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CMSPAR;
         #[cfg(any(target_os = "android",
                   all(target_os = "linux",
                       not(any(target_arch = "powerpc", target_arch = "powerpc64")))))]
         CIBAUD;
         #[cfg(any(target_os = "android", target_os = "linux"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CBAUDEX;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd",
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         MDMBUF;
         #[cfg(any(target_os = "netbsd", target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CHWFLOW;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CCTS_OFLOW;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CRTS_IFLOW;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CDTR_IFLOW;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CDSR_OFLOW;
         #[cfg(any(target_os = "dragonfly",
                   target_os = "freebsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         CCAR_OFLOW;
 
         // Bitmasks for use with ControlFlags to select specific settings
@@ -756,14 +944,17 @@ libc_bitflags! {
     /// Flags for setting any local modes
     pub struct LocalFlags: tcflag_t {
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ECHOKE;
         ECHOE;
         ECHOK;
         ECHO;
         ECHONL;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ECHOPRT;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ECHOCTL;
         ISIG;
         ICANON;
@@ -773,12 +964,15 @@ libc_bitflags! {
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         ALTWERASE;
         IEXTEN;
-        #[cfg(not(target_os = "redox"))]
+        #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         EXTPROC;
         TOSTOP;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         FLUSHO;
         #[cfg(any(target_os = "freebsd",
                   target_os = "dragonfly",
@@ -786,14 +980,16 @@ libc_bitflags! {
                   target_os = "macos",
                   target_os = "netbsd",
                   target_os = "openbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         NOKERNINFO;
         #[cfg(not(target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         PENDIN;
         NOFLSH;
     }
 }
 
-cfg_if!{
+cfg_if! {
     if #[cfg(any(target_os = "freebsd",
                  target_os = "dragonfly",
                  target_os = "ios",
@@ -804,6 +1000,8 @@ cfg_if!{
         /// [cfgetispeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetispeed.html)).
         ///
         /// `cfgetispeed()` extracts the input baud rate from the given `Termios` structure.
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         pub fn cfgetispeed(termios: &Termios) -> u32 {
             let inner_termios = termios.get_libc_termios();
             unsafe { libc::cfgetispeed(&*inner_termios) as u32 }
@@ -813,6 +1011,8 @@ cfg_if!{
         /// [cfgetospeed(3p)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/cfgetospeed.html)).
         ///
         /// `cfgetospeed()` extracts the output baud rate from the given `Termios` structure.
+        // The cast is not unnecessary on all platforms.
+        #[allow(clippy::unnecessary_cast)]
         pub fn cfgetospeed(termios: &Termios) -> u32 {
             let inner_termios = termios.get_libc_termios();
             unsafe { libc::cfgetospeed(&*inner_termios) as u32 }
@@ -899,6 +1099,7 @@ cfg_if!{
         ///
         /// `cfsetspeed()` sets the input and output baud rate in the given `Termios` structure. Note that
         /// this is part of the 4.4BSD standard and not part of POSIX.
+        #[cfg(not(target_os = "haiku"))]
         pub fn cfsetspeed(termios: &mut Termios, baud: BaudRate) -> Result<()> {
             let inner_termios = unsafe { termios.get_libc_termios_mut() };
             let res = unsafe { libc::cfsetspeed(inner_termios, baud as libc::speed_t) };
@@ -927,6 +1128,7 @@ pub fn cfmakeraw(termios: &mut Termios) {
 ///
 /// Note that this is a non-standard function, available on FreeBSD.
 #[cfg(target_os = "freebsd")]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn cfmakesane(termios: &mut Termios) {
     let inner_termios = unsafe { termios.get_libc_termios_mut() };
     unsafe {
@@ -959,7 +1161,10 @@ pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
 /// *any* of the parameters were successfully set, not only if all were set successfully.
 pub fn tcsetattr(fd: RawFd, actions: SetArg, termios: &Termios) -> Result<()> {
     let inner_termios = termios.get_libc_termios();
-    Errno::result(unsafe { libc::tcsetattr(fd, actions as c_int, &*inner_termios) }).map(drop)
+    Errno::result(unsafe {
+        libc::tcsetattr(fd, actions as c_int, &*inner_termios)
+    })
+    .map(drop)
 }
 
 /// Block until all output data is written (see
@@ -995,6 +1200,8 @@ pub fn tcsendbreak(fd: RawFd, duration: c_int) -> Result<()> {
     Errno::result(unsafe { libc::tcsendbreak(fd, duration) }).map(drop)
 }
 
+feature! {
+#![feature = "process"]
 /// Get the session controlled by the given terminal (see
 /// [tcgetsid(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetsid.html)).
 pub fn tcgetsid(fd: RawFd) -> Result<Pid> {
@@ -1002,6 +1209,7 @@ pub fn tcgetsid(fd: RawFd) -> Result<Pid> {
 
     Errno::result(res).map(Pid::from_raw)
 }
+}
 
 #[cfg(test)]
 mod test {
@@ -1011,6 +1219,9 @@ mod test {
     #[test]
     fn try_from() {
         assert_eq!(Ok(BaudRate::B0), BaudRate::try_from(libc::B0));
-        assert!(BaudRate::try_from(999999999).is_err());
+        #[cfg(not(target_os = "haiku"))]
+        BaudRate::try_from(999999999).expect_err("assertion failed");
+        #[cfg(target_os = "haiku")]
+        BaudRate::try_from(99).expect_err("assertion failed");
     }
 }
diff --git a/src/sys/time.rs b/src/sys/time.rs
index ac42471..0042c45 100644
--- a/src/sys/time.rs
+++ b/src/sys/time.rs
@@ -1,9 +1,144 @@
-use std::{cmp, fmt, ops};
-use std::time::Duration;
-use std::convert::From;
+#[cfg_attr(target_env = "musl", allow(deprecated))]
+// https://github.com/rust-lang/libc/issues/1848
+pub use libc::{suseconds_t, time_t};
 use libc::{timespec, timeval};
-#[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-pub use libc::{time_t, suseconds_t};
+use std::convert::From;
+use std::time::Duration;
+use std::{cmp, fmt, ops};
+
+const fn zero_init_timespec() -> timespec {
+    // `std::mem::MaybeUninit::zeroed()` is not yet a const fn
+    // (https://github.com/rust-lang/rust/issues/91850) so we will instead initialize an array of
+    // the appropriate size to zero and then transmute it to a timespec value.
+    unsafe { std::mem::transmute([0u8; std::mem::size_of::<timespec>()]) }
+}
+
+#[cfg(any(
+    all(feature = "time", any(target_os = "android", target_os = "linux")),
+    all(
+        any(
+            target_os = "freebsd",
+            target_os = "illumos",
+            target_os = "linux",
+            target_os = "netbsd"
+        ),
+        feature = "time",
+        feature = "signal"
+    )
+))]
+pub(crate) mod timer {
+    use crate::sys::time::{zero_init_timespec, TimeSpec};
+    use bitflags::bitflags;
+
+    #[derive(Debug, Clone, Copy)]
+    pub(crate) struct TimerSpec(libc::itimerspec);
+
+    impl TimerSpec {
+        pub const fn none() -> Self {
+            Self(libc::itimerspec {
+                it_interval: zero_init_timespec(),
+                it_value: zero_init_timespec(),
+            })
+        }
+    }
+
+    impl AsMut<libc::itimerspec> for TimerSpec {
+        fn as_mut(&mut self) -> &mut libc::itimerspec {
+            &mut self.0
+        }
+    }
+
+    impl AsRef<libc::itimerspec> for TimerSpec {
+        fn as_ref(&self) -> &libc::itimerspec {
+            &self.0
+        }
+    }
+
+    impl From<Expiration> for TimerSpec {
+        fn from(expiration: Expiration) -> TimerSpec {
+            match expiration {
+                Expiration::OneShot(t) => TimerSpec(libc::itimerspec {
+                    it_interval: zero_init_timespec(),
+                    it_value: *t.as_ref(),
+                }),
+                Expiration::IntervalDelayed(start, interval) => {
+                    TimerSpec(libc::itimerspec {
+                        it_interval: *interval.as_ref(),
+                        it_value: *start.as_ref(),
+                    })
+                }
+                Expiration::Interval(t) => TimerSpec(libc::itimerspec {
+                    it_interval: *t.as_ref(),
+                    it_value: *t.as_ref(),
+                }),
+            }
+        }
+    }
+
+    /// An enumeration allowing the definition of the expiration time of an alarm,
+    /// recurring or not.
+    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
+    pub enum Expiration {
+        /// Alarm will trigger once after the time given in `TimeSpec`
+        OneShot(TimeSpec),
+        /// Alarm will trigger after a specified delay and then every interval of
+        /// time.
+        IntervalDelayed(TimeSpec, TimeSpec),
+        /// Alarm will trigger every specified interval of time.
+        Interval(TimeSpec),
+    }
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    bitflags! {
+        /// Flags that are used for arming the timer.
+        pub struct TimerSetTimeFlags: libc::c_int {
+            const TFD_TIMER_ABSTIME = libc::TFD_TIMER_ABSTIME;
+        }
+    }
+    #[cfg(any(
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "dragonfly",
+        target_os = "illumos"
+    ))]
+    bitflags! {
+        /// Flags that are used for arming the timer.
+        pub struct TimerSetTimeFlags: libc::c_int {
+            const TFD_TIMER_ABSTIME = libc::TIMER_ABSTIME;
+        }
+    }
+
+    impl From<TimerSpec> for Expiration {
+        fn from(timerspec: TimerSpec) -> Expiration {
+            match timerspec {
+                TimerSpec(libc::itimerspec {
+                    it_interval:
+                        libc::timespec {
+                            tv_sec: 0,
+                            tv_nsec: 0,
+                            ..
+                        },
+                    it_value: ts,
+                }) => Expiration::OneShot(ts.into()),
+                TimerSpec(libc::itimerspec {
+                    it_interval: int_ts,
+                    it_value: val_ts,
+                }) => {
+                    if (int_ts.tv_sec == val_ts.tv_sec)
+                        && (int_ts.tv_nsec == val_ts.tv_nsec)
+                    {
+                        Expiration::Interval(int_ts.into())
+                    } else {
+                        Expiration::IntervalDelayed(
+                            val_ts.into(),
+                            int_ts.into(),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
 
 pub trait TimeValLike: Sized {
     #[inline]
@@ -13,14 +148,16 @@ pub trait TimeValLike: Sized {
 
     #[inline]
     fn hours(hours: i64) -> Self {
-        let secs = hours.checked_mul(SECS_PER_HOUR)
+        let secs = hours
+            .checked_mul(SECS_PER_HOUR)
             .expect("TimeValLike::hours ouf of bounds");
         Self::seconds(secs)
     }
 
     #[inline]
     fn minutes(minutes: i64) -> Self {
-        let secs = minutes.checked_mul(SECS_PER_MINUTE)
+        let secs = minutes
+            .checked_mul(SECS_PER_MINUTE)
             .expect("TimeValLike::minutes out of bounds");
         Self::seconds(secs)
     }
@@ -55,10 +192,10 @@ const SECS_PER_MINUTE: i64 = 60;
 const SECS_PER_HOUR: i64 = 3600;
 
 #[cfg(target_pointer_width = "64")]
-const TS_MAX_SECONDS: i64 = (::std::i64::MAX / NANOS_PER_SEC) - 1;
+const TS_MAX_SECONDS: i64 = (i64::MAX / NANOS_PER_SEC) - 1;
 
 #[cfg(target_pointer_width = "32")]
-const TS_MAX_SECONDS: i64 = ::std::isize::MAX as i64;
+const TS_MAX_SECONDS: i64 = isize::MAX as i64;
 
 const TS_MIN_SECONDS: i64 = -TS_MAX_SECONDS;
 
@@ -119,16 +256,23 @@ impl PartialOrd for TimeSpec {
 
 impl TimeValLike for TimeSpec {
     #[inline]
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    // https://github.com/rust-lang/libc/issues/1848
     fn seconds(seconds: i64) -> TimeSpec {
-        assert!(seconds >= TS_MIN_SECONDS && seconds <= TS_MAX_SECONDS,
-                "TimeSpec out of bounds; seconds={}", seconds);
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeSpec(timespec {tv_sec: seconds as time_t, tv_nsec: 0 })
+        assert!(
+            (TS_MIN_SECONDS..=TS_MAX_SECONDS).contains(&seconds),
+            "TimeSpec out of bounds; seconds={}",
+            seconds
+        );
+        let mut ts = zero_init_timespec();
+        ts.tv_sec = seconds as time_t;
+        TimeSpec(ts)
     }
 
     #[inline]
     fn milliseconds(milliseconds: i64) -> TimeSpec {
-        let nanoseconds = milliseconds.checked_mul(1_000_000)
+        let nanoseconds = milliseconds
+            .checked_mul(1_000_000)
             .expect("TimeSpec::milliseconds out of bounds");
 
         TimeSpec::nanoseconds(nanoseconds)
@@ -137,7 +281,8 @@ impl TimeValLike for TimeSpec {
     /// Makes a new `TimeSpec` with given number of microseconds.
     #[inline]
     fn microseconds(microseconds: i64) -> TimeSpec {
-        let nanoseconds = microseconds.checked_mul(1_000)
+        let nanoseconds = microseconds
+            .checked_mul(1_000)
             .expect("TimeSpec::milliseconds out of bounds");
 
         TimeSpec::nanoseconds(nanoseconds)
@@ -145,15 +290,22 @@ impl TimeValLike for TimeSpec {
 
     /// Makes a new `TimeSpec` with given number of nanoseconds.
     #[inline]
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    // https://github.com/rust-lang/libc/issues/1848
     fn nanoseconds(nanoseconds: i64) -> TimeSpec {
         let (secs, nanos) = div_mod_floor_64(nanoseconds, NANOS_PER_SEC);
-        assert!(secs >= TS_MIN_SECONDS && secs <= TS_MAX_SECONDS,
-                "TimeSpec out of bounds");
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeSpec(timespec {tv_sec: secs as time_t,
-                           tv_nsec: nanos as timespec_tv_nsec_t })
-    }
-
+        assert!(
+            (TS_MIN_SECONDS..=TS_MAX_SECONDS).contains(&secs),
+            "TimeSpec out of bounds"
+        );
+        let mut ts = zero_init_timespec();
+        ts.tv_sec = secs as time_t;
+        ts.tv_nsec = nanos as timespec_tv_nsec_t;
+        TimeSpec(ts)
+    }
+
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_seconds(&self) -> i64 {
         if self.tv_sec() < 0 && self.tv_nsec() > 0 {
             (self.tv_sec() + 1) as i64
@@ -167,9 +319,11 @@ impl TimeValLike for TimeSpec {
     }
 
     fn num_microseconds(&self) -> i64 {
-        self.num_nanoseconds() / 1_000_000_000
+        self.num_nanoseconds() / 1_000
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_nanoseconds(&self) -> i64 {
         let secs = self.num_seconds() * 1_000_000_000;
         let nsec = self.nanos_mod_sec();
@@ -178,6 +332,15 @@ impl TimeValLike for TimeSpec {
 }
 
 impl TimeSpec {
+    /// Construct a new `TimeSpec` from its components
+    #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
+    pub const fn new(seconds: time_t, nanoseconds: timespec_tv_nsec_t) -> Self {
+        let mut ts = zero_init_timespec();
+        ts.tv_sec = seconds;
+        ts.tv_nsec = nanoseconds;
+        Self(ts)
+    }
+
     fn nanos_mod_sec(&self) -> timespec_tv_nsec_t {
         if self.tv_sec() < 0 && self.tv_nsec() > 0 {
             self.tv_nsec() - NANOS_PER_SEC as timespec_tv_nsec_t
@@ -195,12 +358,13 @@ impl TimeSpec {
         self.0.tv_nsec
     }
 
+    #[cfg_attr(target_env = "musl", allow(deprecated))]
+    // https://github.com/rust-lang/libc/issues/1848
     pub const fn from_duration(duration: Duration) -> Self {
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeSpec(timespec {
-            tv_sec: duration.as_secs() as time_t,
-            tv_nsec: duration.subsec_nanos() as timespec_tv_nsec_t
-        })
+        let mut ts = zero_init_timespec();
+        ts.tv_sec = duration.as_secs() as time_t;
+        ts.tv_nsec = duration.subsec_nanos() as timespec_tv_nsec_t;
+        TimeSpec(ts)
     }
 
     pub const fn from_timespec(timespec: timespec) -> Self {
@@ -220,8 +384,7 @@ impl ops::Add for TimeSpec {
     type Output = TimeSpec;
 
     fn add(self, rhs: TimeSpec) -> TimeSpec {
-        TimeSpec::nanoseconds(
-            self.num_nanoseconds() + rhs.num_nanoseconds())
+        TimeSpec::nanoseconds(self.num_nanoseconds() + rhs.num_nanoseconds())
     }
 }
 
@@ -229,8 +392,7 @@ impl ops::Sub for TimeSpec {
     type Output = TimeSpec;
 
     fn sub(self, rhs: TimeSpec) -> TimeSpec {
-        TimeSpec::nanoseconds(
-            self.num_nanoseconds() - rhs.num_nanoseconds())
+        TimeSpec::nanoseconds(self.num_nanoseconds() - rhs.num_nanoseconds())
     }
 }
 
@@ -238,7 +400,9 @@ impl ops::Mul<i32> for TimeSpec {
     type Output = TimeSpec;
 
     fn mul(self, rhs: i32) -> TimeSpec {
-        let usec = self.num_nanoseconds().checked_mul(i64::from(rhs))
+        let usec = self
+            .num_nanoseconds()
+            .checked_mul(i64::from(rhs))
             .expect("TimeSpec multiply out of bounds");
 
         TimeSpec::nanoseconds(usec)
@@ -284,8 +448,6 @@ impl fmt::Display for TimeSpec {
     }
 }
 
-
-
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct TimeVal(timeval);
@@ -293,10 +455,10 @@ pub struct TimeVal(timeval);
 const MICROS_PER_SEC: i64 = 1_000_000;
 
 #[cfg(target_pointer_width = "64")]
-const TV_MAX_SECONDS: i64 = (::std::i64::MAX / MICROS_PER_SEC) - 1;
+const TV_MAX_SECONDS: i64 = (i64::MAX / MICROS_PER_SEC) - 1;
 
 #[cfg(target_pointer_width = "32")]
-const TV_MAX_SECONDS: i64 = ::std::isize::MAX as i64;
+const TV_MAX_SECONDS: i64 = isize::MAX as i64;
 
 const TV_MIN_SECONDS: i64 = -TV_MAX_SECONDS;
 
@@ -333,15 +495,23 @@ impl PartialOrd for TimeVal {
 impl TimeValLike for TimeVal {
     #[inline]
     fn seconds(seconds: i64) -> TimeVal {
-        assert!(seconds >= TV_MIN_SECONDS && seconds <= TV_MAX_SECONDS,
-                "TimeVal out of bounds; seconds={}", seconds);
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeVal(timeval {tv_sec: seconds as time_t, tv_usec: 0 })
+        assert!(
+            (TV_MIN_SECONDS..=TV_MAX_SECONDS).contains(&seconds),
+            "TimeVal out of bounds; seconds={}",
+            seconds
+        );
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
+        // https://github.com/rust-lang/libc/issues/1848
+        TimeVal(timeval {
+            tv_sec: seconds as time_t,
+            tv_usec: 0,
+        })
     }
 
     #[inline]
     fn milliseconds(milliseconds: i64) -> TimeVal {
-        let microseconds = milliseconds.checked_mul(1_000)
+        let microseconds = milliseconds
+            .checked_mul(1_000)
             .expect("TimeVal::milliseconds out of bounds");
 
         TimeVal::microseconds(microseconds)
@@ -351,11 +521,16 @@ impl TimeValLike for TimeVal {
     #[inline]
     fn microseconds(microseconds: i64) -> TimeVal {
         let (secs, micros) = div_mod_floor_64(microseconds, MICROS_PER_SEC);
-        assert!(secs >= TV_MIN_SECONDS && secs <= TV_MAX_SECONDS,
-                "TimeVal out of bounds");
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeVal(timeval {tv_sec: secs as time_t,
-                           tv_usec: micros as suseconds_t })
+        assert!(
+            (TV_MIN_SECONDS..=TV_MAX_SECONDS).contains(&secs),
+            "TimeVal out of bounds"
+        );
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
+        // https://github.com/rust-lang/libc/issues/1848
+        TimeVal(timeval {
+            tv_sec: secs as time_t,
+            tv_usec: micros as suseconds_t,
+        })
     }
 
     /// Makes a new `TimeVal` with given number of nanoseconds.  Some precision
@@ -364,13 +539,20 @@ impl TimeValLike for TimeVal {
     fn nanoseconds(nanoseconds: i64) -> TimeVal {
         let microseconds = nanoseconds / 1000;
         let (secs, micros) = div_mod_floor_64(microseconds, MICROS_PER_SEC);
-        assert!(secs >= TV_MIN_SECONDS && secs <= TV_MAX_SECONDS,
-                "TimeVal out of bounds");
-        #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
-        TimeVal(timeval {tv_sec: secs as time_t,
-                           tv_usec: micros as suseconds_t })
+        assert!(
+            (TV_MIN_SECONDS..=TV_MAX_SECONDS).contains(&secs),
+            "TimeVal out of bounds"
+        );
+        #[cfg_attr(target_env = "musl", allow(deprecated))]
+        // https://github.com/rust-lang/libc/issues/1848
+        TimeVal(timeval {
+            tv_sec: secs as time_t,
+            tv_usec: micros as suseconds_t,
+        })
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_seconds(&self) -> i64 {
         if self.tv_sec() < 0 && self.tv_usec() > 0 {
             (self.tv_sec() + 1) as i64
@@ -383,6 +565,8 @@ impl TimeValLike for TimeVal {
         self.num_microseconds() / 1_000
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     fn num_microseconds(&self) -> i64 {
         let secs = self.num_seconds() * 1_000_000;
         let usec = self.micros_mod_sec();
@@ -395,6 +579,15 @@ impl TimeValLike for TimeVal {
 }
 
 impl TimeVal {
+    /// Construct a new `TimeVal` from its components
+    #[cfg_attr(target_env = "musl", allow(deprecated))] // https://github.com/rust-lang/libc/issues/1848
+    pub const fn new(seconds: time_t, microseconds: suseconds_t) -> Self {
+        Self(timeval {
+            tv_sec: seconds,
+            tv_usec: microseconds,
+        })
+    }
+
     fn micros_mod_sec(&self) -> suseconds_t {
         if self.tv_sec() < 0 && self.tv_usec() > 0 {
             self.tv_usec() - MICROS_PER_SEC as suseconds_t
@@ -425,8 +618,7 @@ impl ops::Add for TimeVal {
     type Output = TimeVal;
 
     fn add(self, rhs: TimeVal) -> TimeVal {
-        TimeVal::microseconds(
-            self.num_microseconds() + rhs.num_microseconds())
+        TimeVal::microseconds(self.num_microseconds() + rhs.num_microseconds())
     }
 }
 
@@ -434,8 +626,7 @@ impl ops::Sub for TimeVal {
     type Output = TimeVal;
 
     fn sub(self, rhs: TimeVal) -> TimeVal {
-        TimeVal::microseconds(
-            self.num_microseconds() - rhs.num_microseconds())
+        TimeVal::microseconds(self.num_microseconds() - rhs.num_microseconds())
     }
 }
 
@@ -443,7 +634,9 @@ impl ops::Mul<i32> for TimeVal {
     type Output = TimeVal;
 
     fn mul(self, rhs: i32) -> TimeVal {
-        let usec = self.num_microseconds().checked_mul(i64::from(rhs))
+        let usec = self
+            .num_microseconds()
+            .checked_mul(i64::from(rhs))
             .expect("TimeVal multiply out of bounds");
 
         TimeVal::microseconds(usec)
@@ -501,18 +694,16 @@ fn div_mod_floor_64(this: i64, other: i64) -> (i64, i64) {
 #[inline]
 fn div_floor_64(this: i64, other: i64) -> i64 {
     match div_rem_64(this, other) {
-        (d, r) if (r > 0 && other < 0)
-               || (r < 0 && other > 0) => d - 1,
-        (d, _)                         => d,
+        (d, r) if (r > 0 && other < 0) || (r < 0 && other > 0) => d - 1,
+        (d, _) => d,
     }
 }
 
 #[inline]
 fn mod_floor_64(this: i64, other: i64) -> i64 {
     match this % other {
-        r if (r > 0 && other < 0)
-          || (r < 0 && other > 0) => r + other,
-        r                         => r,
+        r if (r > 0 && other < 0) || (r < 0 && other > 0) => r + other,
+        r => r,
     }
 }
 
@@ -528,11 +719,15 @@ mod test {
 
     #[test]
     pub fn test_timespec() {
-        assert!(TimeSpec::seconds(1) != TimeSpec::zero());
-        assert_eq!(TimeSpec::seconds(1) + TimeSpec::seconds(2),
-                   TimeSpec::seconds(3));
-        assert_eq!(TimeSpec::minutes(3) + TimeSpec::seconds(2),
-                   TimeSpec::seconds(182));
+        assert_ne!(TimeSpec::seconds(1), TimeSpec::zero());
+        assert_eq!(
+            TimeSpec::seconds(1) + TimeSpec::seconds(2),
+            TimeSpec::seconds(3)
+        );
+        assert_eq!(
+            TimeSpec::minutes(3) + TimeSpec::seconds(2),
+            TimeSpec::seconds(182)
+        );
     }
 
     #[test]
@@ -554,7 +749,7 @@ mod test {
 
     #[test]
     pub fn test_timespec_ord() {
-        assert!(TimeSpec::seconds(1) == TimeSpec::nanoseconds(1_000_000_000));
+        assert_eq!(TimeSpec::seconds(1), TimeSpec::nanoseconds(1_000_000_000));
         assert!(TimeSpec::seconds(1) < TimeSpec::nanoseconds(1_000_000_001));
         assert!(TimeSpec::seconds(1) > TimeSpec::nanoseconds(999_999_999));
         assert!(TimeSpec::seconds(-1) < TimeSpec::nanoseconds(-999_999_999));
@@ -567,22 +762,29 @@ mod test {
         assert_eq!(TimeSpec::seconds(42).to_string(), "42 seconds");
         assert_eq!(TimeSpec::milliseconds(42).to_string(), "0.042 seconds");
         assert_eq!(TimeSpec::microseconds(42).to_string(), "0.000042 seconds");
-        assert_eq!(TimeSpec::nanoseconds(42).to_string(), "0.000000042 seconds");
+        assert_eq!(
+            TimeSpec::nanoseconds(42).to_string(),
+            "0.000000042 seconds"
+        );
         assert_eq!(TimeSpec::seconds(-86401).to_string(), "-86401 seconds");
     }
 
     #[test]
     pub fn test_timeval() {
-        assert!(TimeVal::seconds(1) != TimeVal::zero());
-        assert_eq!(TimeVal::seconds(1) + TimeVal::seconds(2),
-                   TimeVal::seconds(3));
-        assert_eq!(TimeVal::minutes(3) + TimeVal::seconds(2),
-                   TimeVal::seconds(182));
+        assert_ne!(TimeVal::seconds(1), TimeVal::zero());
+        assert_eq!(
+            TimeVal::seconds(1) + TimeVal::seconds(2),
+            TimeVal::seconds(3)
+        );
+        assert_eq!(
+            TimeVal::minutes(3) + TimeVal::seconds(2),
+            TimeVal::seconds(182)
+        );
     }
 
     #[test]
     pub fn test_timeval_ord() {
-        assert!(TimeVal::seconds(1) == TimeVal::microseconds(1_000_000));
+        assert_eq!(TimeVal::seconds(1), TimeVal::microseconds(1_000_000));
         assert!(TimeVal::seconds(1) < TimeVal::microseconds(1_000_001));
         assert!(TimeVal::seconds(1) > TimeVal::microseconds(999_999));
         assert!(TimeVal::seconds(-1) < TimeVal::microseconds(-999_999));
diff --git a/src/sys/timer.rs b/src/sys/timer.rs
new file mode 100644
index 0000000..e1a3405
--- /dev/null
+++ b/src/sys/timer.rs
@@ -0,0 +1,187 @@
+//! Timer API via signals.
+//!
+//! Timer is a POSIX API to create timers and get expiration notifications
+//! through queued Unix signals, for the current process. This is similar to
+//! Linux's timerfd mechanism, except that API is specific to Linux and makes
+//! use of file polling.
+//!
+//! For more documentation, please read [timer_create](https://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_create.html).
+//!
+//! # Examples
+//!
+//! Create an interval timer that signals SIGALARM every 250 milliseconds.
+//!
+//! ```no_run
+//! use nix::sys::signal::{self, SigEvent, SigHandler, SigevNotify, Signal};
+//! use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
+//! use nix::time::ClockId;
+//! use std::convert::TryFrom;
+//! use std::sync::atomic::{AtomicU64, Ordering};
+//! use std::thread::yield_now;
+//! use std::time::Duration;
+//!
+//! const SIG: Signal = Signal::SIGALRM;
+//! static ALARMS: AtomicU64 = AtomicU64::new(0);
+//!
+//! extern "C" fn handle_alarm(signal: libc::c_int) {
+//!     let signal = Signal::try_from(signal).unwrap();
+//!     if signal == SIG {
+//!         ALARMS.fetch_add(1, Ordering::Relaxed);
+//!     }
+//! }
+//!
+//! fn main() {
+//!     let clockid = ClockId::CLOCK_MONOTONIC;
+//!     let sigevent = SigEvent::new(SigevNotify::SigevSignal {
+//!         signal: SIG,
+//!         si_value: 0,
+//!     });
+//!
+//!     let mut timer = Timer::new(clockid, sigevent).unwrap();
+//!     let expiration = Expiration::Interval(Duration::from_millis(250).into());
+//!     let flags = TimerSetTimeFlags::empty();
+//!     timer.set(expiration, flags).expect("could not set timer");
+//!
+//!     let handler = SigHandler::Handler(handle_alarm);
+//!     unsafe { signal::signal(SIG, handler) }.unwrap();
+//!
+//!     loop {
+//!         let alarms = ALARMS.load(Ordering::Relaxed);
+//!         if alarms >= 10 {
+//!             println!("total alarms handled: {}", alarms);
+//!             break;
+//!         }
+//!         yield_now()
+//!     }
+//! }
+//! ```
+use crate::sys::signal::SigEvent;
+use crate::sys::time::timer::TimerSpec;
+pub use crate::sys::time::timer::{Expiration, TimerSetTimeFlags};
+use crate::time::ClockId;
+use crate::{errno::Errno, Result};
+use core::mem;
+
+/// A Unix signal per-process timer.
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct Timer(libc::timer_t);
+
+impl Timer {
+    /// Creates a new timer based on the clock defined by `clockid`. The details
+    /// of the signal and its handler are defined by the passed `sigevent`.
+    #[doc(alias("timer_create"))]
+    pub fn new(clockid: ClockId, mut sigevent: SigEvent) -> Result<Self> {
+        let mut timer_id: mem::MaybeUninit<libc::timer_t> =
+            mem::MaybeUninit::uninit();
+        Errno::result(unsafe {
+            libc::timer_create(
+                clockid.as_raw(),
+                sigevent.as_mut_ptr(),
+                timer_id.as_mut_ptr(),
+            )
+        })
+        .map(|_| {
+            // SAFETY: libc::timer_create is responsible for initializing
+            // timer_id.
+            unsafe { Self(timer_id.assume_init()) }
+        })
+    }
+
+    /// Set a new alarm on the timer.
+    ///
+    /// # Types of alarm
+    ///
+    /// There are 3 types of alarms you can set:
+    ///
+    ///   - one shot: the alarm will trigger once after the specified amount of
+    /// time.
+    ///     Example: I want an alarm to go off in 60s and then disable itself.
+    ///
+    ///   - interval: the alarm will trigger every specified interval of time.
+    ///     Example: I want an alarm to go off every 60s. The alarm will first
+    ///     go off 60s after I set it and every 60s after that. The alarm will
+    ///     not disable itself.
+    ///
+    ///   - interval delayed: the alarm will trigger after a certain amount of
+    ///     time and then trigger at a specified interval.
+    ///     Example: I want an alarm to go off every 60s but only start in 1h.
+    ///     The alarm will first trigger 1h after I set it and then every 60s
+    ///     after that. The alarm will not disable itself.
+    ///
+    /// # Relative vs absolute alarm
+    ///
+    /// If you do not set any `TimerSetTimeFlags`, then the `TimeSpec` you pass
+    /// to the `Expiration` you want is relative. If however you want an alarm
+    /// to go off at a certain point in time, you can set `TFD_TIMER_ABSTIME`.
+    /// Then the one shot TimeSpec and the delay TimeSpec of the delayed
+    /// interval are going to be interpreted as absolute.
+    ///
+    /// # Disabling alarms
+    ///
+    /// Note: Only one alarm can be set for any given timer. Setting a new alarm
+    /// actually removes the previous one.
+    ///
+    /// Note: Setting a one shot alarm with a 0s TimeSpec disable the alarm
+    /// altogether.
+    #[doc(alias("timer_settime"))]
+    pub fn set(
+        &mut self,
+        expiration: Expiration,
+        flags: TimerSetTimeFlags,
+    ) -> Result<()> {
+        let timerspec: TimerSpec = expiration.into();
+        Errno::result(unsafe {
+            libc::timer_settime(
+                self.0,
+                flags.bits(),
+                timerspec.as_ref(),
+                core::ptr::null_mut(),
+            )
+        })
+        .map(drop)
+    }
+
+    /// Get the parameters for the alarm currently set, if any.
+    #[doc(alias("timer_gettime"))]
+    pub fn get(&self) -> Result<Option<Expiration>> {
+        let mut timerspec = TimerSpec::none();
+        Errno::result(unsafe {
+            libc::timer_gettime(self.0, timerspec.as_mut())
+        })
+        .map(|_| {
+            if timerspec.as_ref().it_interval.tv_sec == 0
+                && timerspec.as_ref().it_interval.tv_nsec == 0
+                && timerspec.as_ref().it_value.tv_sec == 0
+                && timerspec.as_ref().it_value.tv_nsec == 0
+            {
+                None
+            } else {
+                Some(timerspec.into())
+            }
+        })
+    }
+
+    /// Return the number of timers that have overrun
+    ///
+    /// Each timer is able to queue one signal to the process at a time, meaning
+    /// if the signal is not handled before the next expiration the timer has
+    /// 'overrun'. This function returns how many times that has happened to
+    /// this timer, up to `libc::DELAYTIMER_MAX`. If more than the maximum
+    /// number of overruns have happened the return is capped to the maximum.
+    #[doc(alias("timer_getoverrun"))]
+    pub fn overruns(&self) -> i32 {
+        unsafe { libc::timer_getoverrun(self.0) }
+    }
+}
+
+impl Drop for Timer {
+    fn drop(&mut self) {
+        if !std::thread::panicking() {
+            let result = Errno::result(unsafe { libc::timer_delete(self.0) });
+            if let Err(Errno::EINVAL) = result {
+                panic!("close of Timer encountered EINVAL");
+            }
+        }
+    }
+}
diff --git a/src/sys/timerfd.rs b/src/sys/timerfd.rs
index 705a3c4..a35fc92 100644
--- a/src/sys/timerfd.rs
+++ b/src/sys/timerfd.rs
@@ -28,10 +28,10 @@
 //! // We wait for the timer to expire.
 //! timer.wait().unwrap();
 //! ```
-use crate::sys::time::TimeSpec;
+use crate::sys::time::timer::TimerSpec;
+pub use crate::sys::time::timer::{Expiration, TimerSetTimeFlags};
 use crate::unistd::read;
 use crate::{errno::Errno, Result};
-use bitflags::bitflags;
 use libc::c_int;
 use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
 
@@ -60,10 +60,19 @@ libc_enum! {
     #[repr(i32)]
     #[non_exhaustive]
     pub enum ClockId {
+        /// A settable system-wide real-time clock.
         CLOCK_REALTIME,
+        /// A non-settable monotonically increasing clock.
+        ///
+        /// Does not change after system startup.
+        /// Does not measure time while the system is suspended.
         CLOCK_MONOTONIC,
+        /// Like `CLOCK_MONOTONIC`, except that `CLOCK_BOOTTIME` includes the time
+        /// that the system was suspended.
         CLOCK_BOOTTIME,
+        /// Like `CLOCK_REALTIME`, but will wake the system if it is suspended.
         CLOCK_REALTIME_ALARM,
+        /// Like `CLOCK_BOOTTIME`, but will wake the system if it is suspended.
         CLOCK_BOOTTIME_ALARM,
     }
 }
@@ -72,105 +81,23 @@ libc_bitflags! {
     /// Additional flags to change the behaviour of the file descriptor at the
     /// time of creation.
     pub struct TimerFlags: c_int {
+        /// Set the `O_NONBLOCK` flag on the open file description referred to by the new file descriptor.
         TFD_NONBLOCK;
+        /// Set the `FD_CLOEXEC` flag on the file descriptor.
         TFD_CLOEXEC;
     }
 }
 
-bitflags! {
-    /// Flags that are used for arming the timer.
-    pub struct TimerSetTimeFlags: libc::c_int {
-        const TFD_TIMER_ABSTIME = libc::TFD_TIMER_ABSTIME;
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-struct TimerSpec(libc::itimerspec);
-
-impl TimerSpec {
-    pub const fn none() -> Self {
-        Self(libc::itimerspec {
-            it_interval: libc::timespec {
-                tv_sec: 0,
-                tv_nsec: 0,
-            },
-            it_value: libc::timespec {
-                tv_sec: 0,
-                tv_nsec: 0,
-            },
-        })
-    }
-}
-
-impl AsRef<libc::itimerspec> for TimerSpec {
-    fn as_ref(&self) -> &libc::itimerspec {
-        &self.0
-    }
-}
-
-impl From<Expiration> for TimerSpec {
-    fn from(expiration: Expiration) -> TimerSpec {
-        match expiration {
-            Expiration::OneShot(t) => TimerSpec(libc::itimerspec {
-                it_interval: libc::timespec {
-                    tv_sec: 0,
-                    tv_nsec: 0,
-                },
-                it_value: *t.as_ref(),
-            }),
-            Expiration::IntervalDelayed(start, interval) => TimerSpec(libc::itimerspec {
-                it_interval: *interval.as_ref(),
-                it_value: *start.as_ref(),
-            }),
-            Expiration::Interval(t) => TimerSpec(libc::itimerspec {
-                it_interval: *t.as_ref(),
-                it_value: *t.as_ref(),
-            }),
-        }
-    }
-}
-
-impl From<TimerSpec> for Expiration {
-    fn from(timerspec: TimerSpec) -> Expiration {
-        match timerspec {
-            TimerSpec(libc::itimerspec {
-                it_interval:
-                    libc::timespec {
-                        tv_sec: 0,
-                        tv_nsec: 0,
-                    },
-                it_value: ts,
-            }) => Expiration::OneShot(ts.into()),
-            TimerSpec(libc::itimerspec {
-                it_interval: int_ts,
-                it_value: val_ts,
-            }) => {
-                if (int_ts.tv_sec == val_ts.tv_sec) && (int_ts.tv_nsec == val_ts.tv_nsec) {
-                    Expiration::Interval(int_ts.into())
-                } else {
-                    Expiration::IntervalDelayed(val_ts.into(), int_ts.into())
-                }
-            }
-        }
-    }
-}
-
-/// An enumeration allowing the definition of the expiration time of an alarm,
-/// recurring or not.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Expiration {
-    OneShot(TimeSpec),
-    IntervalDelayed(TimeSpec, TimeSpec),
-    Interval(TimeSpec),
-}
-
 impl TimerFd {
     /// Creates a new timer based on the clock defined by `clockid`. The
     /// underlying fd can be assigned specific flags with `flags` (CLOEXEC,
     /// NONBLOCK). The underlying fd will be closed on drop.
+    #[doc(alias("timerfd_create"))]
     pub fn new(clockid: ClockId, flags: TimerFlags) -> Result<Self> {
-        Errno::result(unsafe { libc::timerfd_create(clockid as i32, flags.bits()) })
-            .map(|fd| Self { fd })
+        Errno::result(unsafe {
+            libc::timerfd_create(clockid as i32, flags.bits())
+        })
+        .map(|fd| Self { fd })
     }
 
     /// Sets a new alarm on the timer.
@@ -181,7 +108,7 @@ impl TimerFd {
     ///
     ///   - one shot: the alarm will trigger once after the specified amount of
     /// time.
-    ///     Example: I want an alarm to go off in 60s and then disables itself.
+    ///     Example: I want an alarm to go off in 60s and then disable itself.
     ///
     ///   - interval: the alarm will trigger every specified interval of time.
     ///     Example: I want an alarm to go off every 60s. The alarm will first
@@ -209,7 +136,12 @@ impl TimerFd {
     ///
     /// Note: Setting a one shot alarm with a 0s TimeSpec disables the alarm
     /// altogether.
-    pub fn set(&self, expiration: Expiration, flags: TimerSetTimeFlags) -> Result<()> {
+    #[doc(alias("timerfd_settime"))]
+    pub fn set(
+        &self,
+        expiration: Expiration,
+        flags: TimerSetTimeFlags,
+    ) -> Result<()> {
         let timerspec: TimerSpec = expiration.into();
         Errno::result(unsafe {
             libc::timerfd_settime(
@@ -223,15 +155,17 @@ impl TimerFd {
     }
 
     /// Get the parameters for the alarm currently set, if any.
+    #[doc(alias("timerfd_gettime"))]
     pub fn get(&self) -> Result<Option<Expiration>> {
         let mut timerspec = TimerSpec::none();
-        let timerspec_ptr: *mut libc::itimerspec = &mut timerspec.0;
-
-        Errno::result(unsafe { libc::timerfd_gettime(self.fd, timerspec_ptr) }).map(|_| {
-            if timerspec.0.it_interval.tv_sec == 0
-                && timerspec.0.it_interval.tv_nsec == 0
-                && timerspec.0.it_value.tv_sec == 0
-                && timerspec.0.it_value.tv_nsec == 0
+        Errno::result(unsafe {
+            libc::timerfd_gettime(self.fd, timerspec.as_mut())
+        })
+        .map(|_| {
+            if timerspec.as_ref().it_interval.tv_sec == 0
+                && timerspec.as_ref().it_interval.tv_nsec == 0
+                && timerspec.as_ref().it_value.tv_sec == 0
+                && timerspec.as_ref().it_value.tv_nsec == 0
             {
                 None
             } else {
@@ -241,6 +175,7 @@ impl TimerFd {
     }
 
     /// Remove the alarm if any is set.
+    #[doc(alias("timerfd_settime"))]
     pub fn unset(&self) -> Result<()> {
         Errno::result(unsafe {
             libc::timerfd_settime(
@@ -259,7 +194,7 @@ impl TimerFd {
     pub fn wait(&self) -> Result<()> {
         while let Err(e) = read(self.fd, &mut [0u8; 8]) {
             if e != Errno::EINTR {
-                return Err(e)
+                return Err(e);
             }
         }
 
@@ -270,9 +205,7 @@ impl TimerFd {
 impl Drop for TimerFd {
     fn drop(&mut self) {
         if !std::thread::panicking() {
-            let result = Errno::result(unsafe {
-                libc::close(self.fd)
-            });
+            let result = Errno::result(unsafe { libc::close(self.fd) });
             if let Err(Errno::EBADF) = result {
                 panic!("close of TimerFd encountered EBADF");
             }
diff --git a/src/sys/uio.rs b/src/sys/uio.rs
index 3abcde2..b31c306 100644
--- a/src/sys/uio.rs
+++ b/src/sys/uio.rs
@@ -1,16 +1,26 @@
 //! Vectored I/O
 
-use crate::Result;
 use crate::errno::Errno;
-use libc::{self, c_int, c_void, size_t, off_t};
+use crate::Result;
+use libc::{self, c_int, c_void, off_t, size_t};
+use std::io::{IoSlice, IoSliceMut};
 use std::marker::PhantomData;
 use std::os::unix::io::RawFd;
 
 /// Low-level vectored write to a raw file descriptor
 ///
 /// See also [writev(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/writev.html)
-pub fn writev(fd: RawFd, iov: &[IoVec<&[u8]>]) -> Result<usize> {
-    let res = unsafe { libc::writev(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int) };
+pub fn writev(fd: RawFd, iov: &[IoSlice<'_>]) -> Result<usize> {
+    // SAFETY: to quote the documentation for `IoSlice`:
+    //
+    // [IoSlice] is semantically a wrapper around a &[u8], but is
+    // guaranteed to be ABI compatible with the iovec type on Unix
+    // platforms.
+    //
+    // Because it is ABI compatible, a pointer cast here is valid
+    let res = unsafe {
+        libc::writev(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int)
+    };
 
     Errno::result(res).map(|r| r as usize)
 }
@@ -18,8 +28,11 @@ pub fn writev(fd: RawFd, iov: &[IoVec<&[u8]>]) -> Result<usize> {
 /// Low-level vectored read from a raw file descriptor
 ///
 /// See also [readv(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/readv.html)
-pub fn readv(fd: RawFd, iov: &mut [IoVec<&mut [u8]>]) -> Result<usize> {
-    let res = unsafe { libc::readv(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int) };
+pub fn readv(fd: RawFd, iov: &mut [IoSliceMut<'_>]) -> Result<usize> {
+    // SAFETY: same as in writev(), IoSliceMut is ABI-compatible with iovec
+    let res = unsafe {
+        libc::readv(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int)
+    };
 
     Errno::result(res).map(|r| r as usize)
 }
@@ -30,11 +43,20 @@ pub fn readv(fd: RawFd, iov: &mut [IoVec<&mut [u8]>]) -> Result<usize> {
 /// or an error occurs. The file offset is not changed.
 ///
 /// See also: [`writev`](fn.writev.html) and [`pwrite`](fn.pwrite.html)
-#[cfg(not(target_os = "redox"))]
-pub fn pwritev(fd: RawFd, iov: &[IoVec<&[u8]>],
-               offset: off_t) -> Result<usize> {
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub fn pwritev(fd: RawFd, iov: &[IoSlice<'_>], offset: off_t) -> Result<usize> {
+    #[cfg(target_env = "uclibc")]
+    let offset = offset as libc::off64_t; // uclibc doesn't use off_t
+
+    // SAFETY: same as in writev()
     let res = unsafe {
-        libc::pwritev(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int, offset)
+        libc::pwritev(
+            fd,
+            iov.as_ptr() as *const libc::iovec,
+            iov.len() as c_int,
+            offset,
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
@@ -47,11 +69,24 @@ pub fn pwritev(fd: RawFd, iov: &[IoVec<&[u8]>],
 /// changed.
 ///
 /// See also: [`readv`](fn.readv.html) and [`pread`](fn.pread.html)
-#[cfg(not(target_os = "redox"))]
-pub fn preadv(fd: RawFd, iov: &[IoVec<&mut [u8]>],
-              offset: off_t) -> Result<usize> {
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub fn preadv(
+    fd: RawFd,
+    iov: &mut [IoSliceMut<'_>],
+    offset: off_t,
+) -> Result<usize> {
+    #[cfg(target_env = "uclibc")]
+    let offset = offset as libc::off64_t; // uclibc doesn't use off_t
+
+    // SAFETY: same as in readv()
     let res = unsafe {
-        libc::preadv(fd, iov.as_ptr() as *const libc::iovec, iov.len() as c_int, offset)
+        libc::preadv(
+            fd,
+            iov.as_ptr() as *const libc::iovec,
+            iov.len() as c_int,
+            offset,
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
@@ -63,21 +98,29 @@ pub fn preadv(fd: RawFd, iov: &[IoVec<&mut [u8]>],
 // TODO: move to unistd
 pub fn pwrite(fd: RawFd, buf: &[u8], offset: off_t) -> Result<usize> {
     let res = unsafe {
-        libc::pwrite(fd, buf.as_ptr() as *const c_void, buf.len() as size_t,
-                    offset)
+        libc::pwrite(
+            fd,
+            buf.as_ptr() as *const c_void,
+            buf.len() as size_t,
+            offset,
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
 }
 
-/// Low-level write to a file, with specified offset.
+/// Low-level read from a file, with specified offset.
 ///
 /// See also [pread(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pread.html)
 // TODO: move to unistd
-pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result<usize>{
+pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result<usize> {
     let res = unsafe {
-        libc::pread(fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t,
-                   offset)
+        libc::pread(
+            fd,
+            buf.as_mut_ptr() as *mut c_void,
+            buf.len() as size_t,
+            offset,
+        )
     };
 
     Errno::result(res).map(|r| r as usize)
@@ -86,12 +129,13 @@ pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result<usize>{
 /// A slice of memory in a remote process, starting at address `base`
 /// and consisting of `len` bytes.
 ///
-/// This is the same underlying C structure as [`IoVec`](struct.IoVec.html),
+/// This is the same underlying C structure as `IoSlice`,
 /// except that it refers to memory in some other process, and is
-/// therefore not represented in Rust by an actual slice as `IoVec` is. It
+/// therefore not represented in Rust by an actual slice as `IoSlice` is. It
 /// is used with [`process_vm_readv`](fn.process_vm_readv.html)
 /// and [`process_vm_writev`](fn.process_vm_writev.html).
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct RemoteIoVec {
@@ -101,10 +145,84 @@ pub struct RemoteIoVec {
     pub len: usize,
 }
 
+/// A vector of buffers.
+///
+/// Vectored I/O methods like [`writev`] and [`readv`] use this structure for
+/// both reading and writing.  Each `IoVec` specifies the base address and
+/// length of an area in memory.
+#[deprecated(
+    since = "0.24.0",
+    note = "`IoVec` is no longer used in the public interface, use `IoSlice` or `IoSliceMut` instead"
+)]
+#[repr(transparent)]
+#[allow(renamed_and_removed_lints)]
+#[allow(clippy::unknown_clippy_lints)]
+// Clippy false positive: https://github.com/rust-lang/rust-clippy/issues/8867
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct IoVec<T>(pub(crate) libc::iovec, PhantomData<T>);
+
+#[allow(deprecated)]
+impl<T> IoVec<T> {
+    /// View the `IoVec` as a Rust slice.
+    #[deprecated(
+        since = "0.24.0",
+        note = "Use the `Deref` impl of `IoSlice` or `IoSliceMut` instead"
+    )]
+    #[inline]
+    pub fn as_slice(&self) -> &[u8] {
+        use std::slice;
+
+        unsafe {
+            slice::from_raw_parts(self.0.iov_base as *const u8, self.0.iov_len)
+        }
+    }
+}
+
+#[allow(deprecated)]
+impl<'a> IoVec<&'a [u8]> {
+    /// Create an `IoVec` from a Rust slice.
+    #[deprecated(since = "0.24.0", note = "Use `IoSlice::new` instead")]
+    pub fn from_slice(buf: &'a [u8]) -> IoVec<&'a [u8]> {
+        IoVec(
+            libc::iovec {
+                iov_base: buf.as_ptr() as *mut c_void,
+                iov_len: buf.len() as size_t,
+            },
+            PhantomData,
+        )
+    }
+}
+
+#[allow(deprecated)]
+impl<'a> IoVec<&'a mut [u8]> {
+    /// Create an `IoVec` from a mutable Rust slice.
+    #[deprecated(since = "0.24.0", note = "Use `IoSliceMut::new` instead")]
+    pub fn from_mut_slice(buf: &'a mut [u8]) -> IoVec<&'a mut [u8]> {
+        IoVec(
+            libc::iovec {
+                iov_base: buf.as_ptr() as *mut c_void,
+                iov_len: buf.len() as size_t,
+            },
+            PhantomData,
+        )
+    }
+}
+
+// The only reason IoVec isn't automatically Send+Sync is because libc::iovec
+// contains raw pointers.
+#[allow(deprecated)]
+unsafe impl<T> Send for IoVec<T> where T: Send {}
+#[allow(deprecated)]
+unsafe impl<T> Sync for IoVec<T> where T: Sync {}
+
+feature! {
+#![feature = "process"]
+
 /// Write data directly to another process's virtual memory
 /// (see [`process_vm_writev`(2)]).
 ///
-/// `local_iov` is a list of [`IoVec`]s containing the data to be written,
+/// `local_iov` is a list of [`IoSlice`]s containing the data to be written,
 /// and `remote_iov` is a list of [`RemoteIoVec`]s identifying where the
 /// data should be written in the target process. On success, returns the
 /// number of bytes written, which will always be a whole
@@ -115,16 +233,16 @@ pub struct RemoteIoVec {
 /// `CAP_SYS_PTRACE`), or you must be running as the same user as the
 /// target process and the OS must have unprivileged debugging enabled.
 ///
-/// This function is only available on Linux.
+/// This function is only available on Linux and Android(SDK23+).
 ///
 /// [`process_vm_writev`(2)]: https://man7.org/linux/man-pages/man2/process_vm_writev.2.html
 /// [ptrace]: ../ptrace/index.html
-/// [`IoVec`]: struct.IoVec.html
+/// [`IoSlice`]: https://doc.rust-lang.org/std/io/struct.IoSlice.html
 /// [`RemoteIoVec`]: struct.RemoteIoVec.html
-#[cfg(target_os = "linux")]
+#[cfg(all(any(target_os = "linux", target_os = "android"), not(target_env = "uclibc")))]
 pub fn process_vm_writev(
     pid: crate::unistd::Pid,
-    local_iov: &[IoVec<&[u8]>],
+    local_iov: &[IoSlice<'_>],
     remote_iov: &[RemoteIoVec]) -> Result<usize>
 {
     let res = unsafe {
@@ -139,7 +257,7 @@ pub fn process_vm_writev(
 /// Read data directly from another process's virtual memory
 /// (see [`process_vm_readv`(2)]).
 ///
-/// `local_iov` is a list of [`IoVec`]s containing the buffer to copy
+/// `local_iov` is a list of [`IoSliceMut`]s containing the buffer to copy
 /// data into, and `remote_iov` is a list of [`RemoteIoVec`]s identifying
 /// where the source data is in the target process. On success,
 /// returns the number of bytes written, which will always be a whole
@@ -150,16 +268,16 @@ pub fn process_vm_writev(
 /// `CAP_SYS_PTRACE`), or you must be running as the same user as the
 /// target process and the OS must have unprivileged debugging enabled.
 ///
-/// This function is only available on Linux.
+/// This function is only available on Linux and Android(SDK23+).
 ///
 /// [`process_vm_readv`(2)]: https://man7.org/linux/man-pages/man2/process_vm_readv.2.html
 /// [`ptrace`]: ../ptrace/index.html
-/// [`IoVec`]: struct.IoVec.html
+/// [`IoSliceMut`]: https://doc.rust-lang.org/std/io/struct.IoSliceMut.html
 /// [`RemoteIoVec`]: struct.RemoteIoVec.html
-#[cfg(any(target_os = "linux"))]
+#[cfg(all(any(target_os = "linux", target_os = "android"), not(target_env = "uclibc")))]
 pub fn process_vm_readv(
     pid: crate::unistd::Pid,
-    local_iov: &[IoVec<&mut [u8]>],
+    local_iov: &mut [IoSliceMut<'_>],
     remote_iov: &[RemoteIoVec]) -> Result<usize>
 {
     let res = unsafe {
@@ -170,54 +288,4 @@ pub fn process_vm_readv(
 
     Errno::result(res).map(|r| r as usize)
 }
-
-/// A vector of buffers.
-///
-/// Vectored I/O methods like [`writev`] and [`readv`] use this structure for
-/// both reading and writing.  Each `IoVec` specifies the base address and
-/// length of an area in memory.
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub struct IoVec<T>(pub(crate) libc::iovec, PhantomData<T>);
-
-impl<T> IoVec<T> {
-    /// View the `IoVec` as a Rust slice.
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        use std::slice;
-
-        unsafe {
-            slice::from_raw_parts(
-                self.0.iov_base as *const u8,
-                self.0.iov_len as usize)
-        }
-    }
-}
-
-impl<'a> IoVec<&'a [u8]> {
-    #[cfg(target_os = "freebsd")]
-    pub(crate) fn from_raw_parts(base: *mut c_void, len: usize) -> Self {
-        IoVec(libc::iovec {
-            iov_base: base,
-            iov_len: len
-        }, PhantomData)
-    }
-
-    /// Create an `IoVec` from a Rust slice.
-    pub fn from_slice(buf: &'a [u8]) -> IoVec<&'a [u8]> {
-        IoVec(libc::iovec {
-            iov_base: buf.as_ptr() as *mut c_void,
-            iov_len: buf.len() as size_t,
-        }, PhantomData)
-    }
-}
-
-impl<'a> IoVec<&'a mut [u8]> {
-    /// Create an `IoVec` from a mutable Rust slice.
-    pub fn from_mut_slice(buf: &'a mut [u8]) -> IoVec<&'a mut [u8]> {
-        IoVec(libc::iovec {
-            iov_base: buf.as_ptr() as *mut c_void,
-            iov_len: buf.len() as size_t,
-        }, PhantomData)
-    }
 }
diff --git a/src/sys/utsname.rs b/src/sys/utsname.rs
index 98edee0..b48ed9f 100644
--- a/src/sys/utsname.rs
+++ b/src/sys/utsname.rs
@@ -1,8 +1,9 @@
 //! Get system identification
+use crate::{Errno, Result};
+use libc::c_char;
+use std::ffi::OsStr;
 use std::mem;
-use libc::{self, c_char};
-use std::ffi::CStr;
-use std::str::from_utf8_unchecked;
+use std::os::unix::ffi::OsStrExt;
 
 /// Describes the running system.  Return type of [`uname`].
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
@@ -10,47 +11,56 @@ use std::str::from_utf8_unchecked;
 pub struct UtsName(libc::utsname);
 
 impl UtsName {
-    /// Name of the operating system implementation
-    pub fn sysname(&self) -> &str {
-        to_str(&(&self.0.sysname as *const c_char ) as *const *const c_char)
+    /// Name of the operating system implementation.
+    pub fn sysname(&self) -> &OsStr {
+        cast_and_trim(&self.0.sysname)
     }
 
     /// Network name of this machine.
-    pub fn nodename(&self) -> &str {
-        to_str(&(&self.0.nodename as *const c_char ) as *const *const c_char)
+    pub fn nodename(&self) -> &OsStr {
+        cast_and_trim(&self.0.nodename)
     }
 
     /// Release level of the operating system.
-    pub fn release(&self) -> &str {
-        to_str(&(&self.0.release as *const c_char ) as *const *const c_char)
+    pub fn release(&self) -> &OsStr {
+        cast_and_trim(&self.0.release)
     }
 
     /// Version level of the operating system.
-    pub fn version(&self) -> &str {
-        to_str(&(&self.0.version as *const c_char ) as *const *const c_char)
+    pub fn version(&self) -> &OsStr {
+        cast_and_trim(&self.0.version)
     }
 
     /// Machine hardware platform.
-    pub fn machine(&self) -> &str {
-        to_str(&(&self.0.machine as *const c_char ) as *const *const c_char)
+    pub fn machine(&self) -> &OsStr {
+        cast_and_trim(&self.0.machine)
+    }
+
+    /// NIS or YP domain name of this machine.
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    pub fn domainname(&self) -> &OsStr {
+        cast_and_trim(&self.0.domainname)
     }
 }
 
 /// Get system identification
-pub fn uname() -> UtsName {
+pub fn uname() -> Result<UtsName> {
     unsafe {
-        let mut ret = mem::MaybeUninit::uninit();
-        libc::uname(ret.as_mut_ptr());
-        UtsName(ret.assume_init())
+        let mut ret = mem::MaybeUninit::zeroed();
+        Errno::result(libc::uname(ret.as_mut_ptr()))?;
+        Ok(UtsName(ret.assume_init()))
     }
 }
 
-#[inline]
-fn to_str<'a>(s: *const *const c_char) -> &'a str {
-    unsafe {
-        let res = CStr::from_ptr(*s).to_bytes();
-        from_utf8_unchecked(res)
-    }
+fn cast_and_trim(slice: &[c_char]) -> &OsStr {
+    let length = slice
+        .iter()
+        .position(|&byte| byte == 0)
+        .unwrap_or(slice.len());
+    let bytes =
+        unsafe { std::slice::from_raw_parts(slice.as_ptr().cast(), length) };
+
+    OsStr::from_bytes(bytes)
 }
 
 #[cfg(test)]
@@ -58,18 +68,18 @@ mod test {
     #[cfg(target_os = "linux")]
     #[test]
     pub fn test_uname_linux() {
-        assert_eq!(super::uname().sysname(), "Linux");
+        assert_eq!(super::uname().unwrap().sysname(), "Linux");
     }
 
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     #[test]
     pub fn test_uname_darwin() {
-        assert_eq!(super::uname().sysname(), "Darwin");
+        assert_eq!(super::uname().unwrap().sysname(), "Darwin");
     }
 
     #[cfg(target_os = "freebsd")]
     #[test]
     pub fn test_uname_freebsd() {
-        assert_eq!(super::uname().sysname(), "FreeBSD");
+        assert_eq!(super::uname().unwrap().sysname(), "FreeBSD");
     }
 }
diff --git a/src/sys/wait.rs b/src/sys/wait.rs
index ee49e37..b6524e8 100644
--- a/src/sys/wait.rs
+++ b/src/sys/wait.rs
@@ -6,6 +6,11 @@ use crate::Result;
 use cfg_if::cfg_if;
 use libc::{self, c_int};
 use std::convert::TryFrom;
+#[cfg(any(
+    target_os = "android",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+use std::os::unix::io::RawFd;
 
 libc_bitflags!(
     /// Controls the behavior of [`waitpid`].
@@ -27,6 +32,7 @@ libc_bitflags!(
                   target_os = "redox",
                   target_os = "macos",
                   target_os = "netbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         WEXITED;
         /// Report the status of selected processes that have continued from a
         /// job control stop by receiving a
@@ -41,6 +47,7 @@ libc_bitflags!(
                   target_os = "redox",
                   target_os = "macos",
                   target_os = "netbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         WSTOPPED;
         /// Don't reap, just poll status.
         #[cfg(any(target_os = "android",
@@ -51,15 +58,19 @@ libc_bitflags!(
                   target_os = "redox",
                   target_os = "macos",
                   target_os = "netbsd"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         WNOWAIT;
         /// Don't wait on children of other threads in this group
         #[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         __WNOTHREAD;
         /// Wait on all children, regardless of type
         #[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         __WALL;
         /// Wait for "clone" children only.
         #[cfg(any(target_os = "android", target_os = "linux", target_os = "redox"))]
+        #[cfg_attr(docsrs, doc(cfg(all())))]
         __WCLONE;
     }
 );
@@ -97,6 +108,7 @@ pub enum WaitStatus {
     /// [`nix::sys::ptrace`]: ../ptrace/index.html
     /// [`ptrace`(2)]: https://man7.org/linux/man-pages/man2/ptrace.2.html
     #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PtraceEvent(Pid, Signal, c_int),
     /// The traced process was stopped by execution of a system call,
     /// and `PTRACE_O_TRACESYSGOOD` is in effect. See [`ptrace`(2)] for
@@ -104,6 +116,7 @@ pub enum WaitStatus {
     ///
     /// [`ptrace`(2)]: https://man7.org/linux/man-pages/man2/ptrace.2.html
     #[cfg(any(target_os = "linux", target_os = "android"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PtraceSyscall(Pid),
     /// The process was previously stopped but has resumed execution
     /// after receiving a `SIGCONT` signal. This is only reported if
@@ -122,7 +135,9 @@ impl WaitStatus {
     pub fn pid(&self) -> Option<Pid> {
         use self::WaitStatus::*;
         match *self {
-            Exited(p, _) | Signaled(p, _, _) | Stopped(p, _) | Continued(p) => Some(p),
+            Exited(p, _) | Signaled(p, _, _) | Stopped(p, _) | Continued(p) => {
+                Some(p)
+            }
             StillAlive => None,
             #[cfg(any(target_os = "android", target_os = "linux"))]
             PtraceEvent(p, _, _) | PtraceSyscall(p) => Some(p),
@@ -225,12 +240,72 @@ impl WaitStatus {
             WaitStatus::Continued(pid)
         })
     }
+
+    /// Convert a `siginfo_t` as returned by `waitid` to a `WaitStatus`
+    ///
+    /// # Errors
+    ///
+    /// Returns an `Error` corresponding to `EINVAL` for invalid values.
+    ///
+    /// # Safety
+    ///
+    /// siginfo_t is actually a union, not all fields may be initialized.
+    /// The functions si_pid() and si_status() must be valid to call on
+    /// the passed siginfo_t.
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "haiku",
+        all(target_os = "linux", not(target_env = "uclibc")),
+    ))]
+    unsafe fn from_siginfo(siginfo: &libc::siginfo_t) -> Result<WaitStatus> {
+        let si_pid = siginfo.si_pid();
+        if si_pid == 0 {
+            return Ok(WaitStatus::StillAlive);
+        }
+
+        assert_eq!(siginfo.si_signo, libc::SIGCHLD);
+
+        let pid = Pid::from_raw(si_pid);
+        let si_status = siginfo.si_status();
+
+        let status = match siginfo.si_code {
+            libc::CLD_EXITED => WaitStatus::Exited(pid, si_status),
+            libc::CLD_KILLED | libc::CLD_DUMPED => WaitStatus::Signaled(
+                pid,
+                Signal::try_from(si_status)?,
+                siginfo.si_code == libc::CLD_DUMPED,
+            ),
+            libc::CLD_STOPPED => {
+                WaitStatus::Stopped(pid, Signal::try_from(si_status)?)
+            }
+            libc::CLD_CONTINUED => WaitStatus::Continued(pid),
+            #[cfg(any(target_os = "android", target_os = "linux"))]
+            libc::CLD_TRAPPED => {
+                if si_status == libc::SIGTRAP | 0x80 {
+                    WaitStatus::PtraceSyscall(pid)
+                } else {
+                    WaitStatus::PtraceEvent(
+                        pid,
+                        Signal::try_from(si_status & 0xff)?,
+                        (si_status >> 8) as c_int,
+                    )
+                }
+            }
+            _ => return Err(Errno::EINVAL),
+        };
+
+        Ok(status)
+    }
 }
 
 /// Wait for a process to change status
 ///
 /// See also [waitpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/waitpid.html)
-pub fn waitpid<P: Into<Option<Pid>>>(pid: P, options: Option<WaitPidFlag>) -> Result<WaitStatus> {
+pub fn waitpid<P: Into<Option<Pid>>>(
+    pid: P,
+    options: Option<WaitPidFlag>,
+) -> Result<WaitStatus> {
     use self::WaitStatus::*;
 
     let mut status: i32 = 0;
@@ -260,3 +335,54 @@ pub fn waitpid<P: Into<Option<Pid>>>(pid: P, options: Option<WaitPidFlag>) -> Re
 pub fn wait() -> Result<WaitStatus> {
     waitpid(None, None)
 }
+
+/// The ID argument for `waitid`
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Id {
+    /// Wait for any child
+    All,
+    /// Wait for the child whose process ID matches the given PID
+    Pid(Pid),
+    /// Wait for the child whose process group ID matches the given PID
+    ///
+    /// If the PID is zero, the caller's process group is used since Linux 5.4.
+    PGid(Pid),
+    /// Wait for the child referred to by the given PID file descriptor
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    PIDFd(RawFd),
+}
+
+/// Wait for a process to change status
+///
+/// See also [waitid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/waitid.html)
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+pub fn waitid(id: Id, flags: WaitPidFlag) -> Result<WaitStatus> {
+    let (idtype, idval) = match id {
+        Id::All => (libc::P_ALL, 0),
+        Id::Pid(pid) => (libc::P_PID, pid.as_raw() as libc::id_t),
+        Id::PGid(pid) => (libc::P_PGID, pid.as_raw() as libc::id_t),
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        Id::PIDFd(fd) => (libc::P_PIDFD, fd as libc::id_t),
+    };
+
+    let siginfo = unsafe {
+        // Memory is zeroed rather than uninitialized, as not all platforms
+        // initialize the memory in the StillAlive case
+        let mut siginfo: libc::siginfo_t = std::mem::zeroed();
+        Errno::result(libc::waitid(idtype, idval, &mut siginfo, flags.bits()))?;
+        siginfo
+    };
+
+    unsafe { WaitStatus::from_siginfo(&siginfo) }
+}
diff --git a/src/time.rs b/src/time.rs
index 6275b59..2e03c46 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -6,6 +6,7 @@ use crate::sys::time::TimeSpec;
     target_os = "android",
     target_os = "emscripten",
 ))]
+#[cfg(feature = "process")]
 use crate::unistd::Pid;
 use crate::{Errno, Result};
 use libc::{self, clockid_t};
@@ -13,7 +14,7 @@ use std::mem::MaybeUninit;
 
 /// Clock identifier
 ///
-/// Newtype pattern around `clockid_t` (which is just alias). It pervents bugs caused by
+/// Newtype pattern around `clockid_t` (which is just alias). It prevents bugs caused by
 /// accidentally passing wrong value.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct ClockId(clockid_t);
@@ -24,6 +25,8 @@ impl ClockId {
         ClockId(clk_id)
     }
 
+    feature! {
+    #![feature = "process"]
     /// Returns `ClockId` of a `pid` CPU-time clock
     #[cfg(any(
         target_os = "freebsd",
@@ -32,12 +35,15 @@ impl ClockId {
         target_os = "android",
         target_os = "emscripten",
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn pid_cpu_clock_id(pid: Pid) -> Result<Self> {
         clock_getcpuclockid(pid)
     }
+    }
 
     /// Returns resolution of the clock id
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn res(self) -> Result<TimeSpec> {
         clock_getres(self)
     }
@@ -51,11 +57,10 @@ impl ClockId {
     #[cfg(not(any(
         target_os = "macos",
         target_os = "ios",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlibc")),
-            any(target_os = "redox", target_os = "hermit",),
-        ),
+        target_os = "redox",
+        target_os = "hermit",
     )))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub fn set_time(self, timespec: TimeSpec) -> Result<()> {
         clock_settime(self, timespec)
     }
@@ -66,122 +71,134 @@ impl ClockId {
     }
 
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten"),
-        )
+        target_os = "linux"
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_BOOTTIME: ClockId = ClockId(libc::CLOCK_BOOTTIME);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "linux"
     ))]
-    pub const CLOCK_BOOTTIME_ALARM: ClockId = ClockId(libc::CLOCK_BOOTTIME_ALARM);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_BOOTTIME_ALARM: ClockId =
+        ClockId(libc::CLOCK_BOOTTIME_ALARM);
     pub const CLOCK_MONOTONIC: ClockId = ClockId(libc::CLOCK_MONOTONIC);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "linux"
     ))]
-    pub const CLOCK_MONOTONIC_COARSE: ClockId = ClockId(libc::CLOCK_MONOTONIC_COARSE);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_MONOTONIC_COARSE: ClockId =
+        ClockId(libc::CLOCK_MONOTONIC_COARSE);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-    pub const CLOCK_MONOTONIC_FAST: ClockId = ClockId(libc::CLOCK_MONOTONIC_FAST);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_MONOTONIC_FAST: ClockId =
+        ClockId(libc::CLOCK_MONOTONIC_FAST);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-    pub const CLOCK_MONOTONIC_PRECISE: ClockId = ClockId(libc::CLOCK_MONOTONIC_PRECISE);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_MONOTONIC_PRECISE: ClockId =
+        ClockId(libc::CLOCK_MONOTONIC_PRECISE);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "linux"
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_MONOTONIC_RAW: ClockId = ClockId(libc::CLOCK_MONOTONIC_RAW);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        target_env = "uclibc",
         target_os = "macos",
         target_os = "ios",
         target_os = "freebsd",
         target_os = "dragonfly",
-        all(
-            not(target_env = "newlib"),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "redox",
+        target_os = "linux"
     ))]
-    pub const CLOCK_PROCESS_CPUTIME_ID: ClockId = ClockId(libc::CLOCK_PROCESS_CPUTIME_ID);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_PROCESS_CPUTIME_ID: ClockId =
+        ClockId(libc::CLOCK_PROCESS_CPUTIME_ID);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_PROF: ClockId = ClockId(libc::CLOCK_PROF);
     pub const CLOCK_REALTIME: ClockId = ClockId(libc::CLOCK_REALTIME);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "linux"
     ))]
-    pub const CLOCK_REALTIME_ALARM: ClockId = ClockId(libc::CLOCK_REALTIME_ALARM);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_REALTIME_ALARM: ClockId =
+        ClockId(libc::CLOCK_REALTIME_ALARM);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten")
-        )
+        target_os = "linux"
     ))]
-    pub const CLOCK_REALTIME_COARSE: ClockId = ClockId(libc::CLOCK_REALTIME_COARSE);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_REALTIME_COARSE: ClockId =
+        ClockId(libc::CLOCK_REALTIME_COARSE);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_REALTIME_FAST: ClockId = ClockId(libc::CLOCK_REALTIME_FAST);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-    pub const CLOCK_REALTIME_PRECISE: ClockId = ClockId(libc::CLOCK_REALTIME_PRECISE);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_REALTIME_PRECISE: ClockId =
+        ClockId(libc::CLOCK_REALTIME_PRECISE);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_SECOND: ClockId = ClockId(libc::CLOCK_SECOND);
     #[cfg(any(
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(
-                target_os = "emscripten",
-                all(target_os = "linux", target_env = "musl")
-            )
-        )
+        all(target_os = "linux", target_env = "musl")
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_SGI_CYCLE: ClockId = ClockId(libc::CLOCK_SGI_CYCLE);
     #[cfg(any(
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
-        all(
-            not(any(target_env = "uclibc", target_env = "newlib")),
-            any(
-                target_os = "emscripten",
-                all(target_os = "linux", target_env = "musl")
-            )
-        )
+        target_os = "linux"
     ))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_TAI: ClockId = ClockId(libc::CLOCK_TAI);
     #[cfg(any(
-        target_env = "uclibc",
+        target_os = "android",
+        target_os = "emscripten",
         target_os = "fuchsia",
         target_os = "ios",
         target_os = "macos",
         target_os = "freebsd",
         target_os = "dragonfly",
-        all(
-            not(target_env = "newlib"),
-            any(target_os = "linux", target_os = "android", target_os = "emscripten",),
-        ),
+        target_os = "linux"
     ))]
-    pub const CLOCK_THREAD_CPUTIME_ID: ClockId = ClockId(libc::CLOCK_THREAD_CPUTIME_ID);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_THREAD_CPUTIME_ID: ClockId =
+        ClockId(libc::CLOCK_THREAD_CPUTIME_ID);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_UPTIME: ClockId = ClockId(libc::CLOCK_UPTIME);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_UPTIME_FAST: ClockId = ClockId(libc::CLOCK_UPTIME_FAST);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
-    pub const CLOCK_UPTIME_PRECISE: ClockId = ClockId(libc::CLOCK_UPTIME_PRECISE);
+    #[cfg_attr(docsrs, doc(cfg(all())))]
+    pub const CLOCK_UPTIME_PRECISE: ClockId =
+        ClockId(libc::CLOCK_UPTIME_PRECISE);
     #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub const CLOCK_VIRTUAL: ClockId = ClockId(libc::CLOCK_VIRTUAL);
 }
 
@@ -206,9 +223,11 @@ impl std::fmt::Display for ClockId {
 /// Get the resolution of the specified clock, (see
 /// [clock_getres(2)](https://pubs.opengroup.org/onlinepubs/7908799/xsh/clock_getres.html)).
 #[cfg(not(target_os = "redox"))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn clock_getres(clock_id: ClockId) -> Result<TimeSpec> {
     let mut c_time: MaybeUninit<libc::timespec> = MaybeUninit::uninit();
-    let ret = unsafe { libc::clock_getres(clock_id.as_raw(), c_time.as_mut_ptr()) };
+    let ret =
+        unsafe { libc::clock_getres(clock_id.as_raw(), c_time.as_mut_ptr()) };
     Errno::result(ret)?;
     let res = unsafe { c_time.assume_init() };
     Ok(TimeSpec::from(res))
@@ -218,7 +237,8 @@ pub fn clock_getres(clock_id: ClockId) -> Result<TimeSpec> {
 /// [clock_gettime(2)](https://pubs.opengroup.org/onlinepubs/7908799/xsh/clock_gettime.html)).
 pub fn clock_gettime(clock_id: ClockId) -> Result<TimeSpec> {
     let mut c_time: MaybeUninit<libc::timespec> = MaybeUninit::uninit();
-    let ret = unsafe { libc::clock_gettime(clock_id.as_raw(), c_time.as_mut_ptr()) };
+    let ret =
+        unsafe { libc::clock_gettime(clock_id.as_raw(), c_time.as_mut_ptr()) };
     Errno::result(ret)?;
     let res = unsafe { c_time.assume_init() };
     Ok(TimeSpec::from(res))
@@ -229,13 +249,13 @@ pub fn clock_gettime(clock_id: ClockId) -> Result<TimeSpec> {
 #[cfg(not(any(
     target_os = "macos",
     target_os = "ios",
-    all(
-        not(any(target_env = "uclibc", target_env = "newlibc")),
-        any(target_os = "redox", target_os = "hermit",),
-    ),
+    target_os = "redox",
+    target_os = "hermit",
 )))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
 pub fn clock_settime(clock_id: ClockId, timespec: TimeSpec) -> Result<()> {
-    let ret = unsafe { libc::clock_settime(clock_id.as_raw(), timespec.as_ref()) };
+    let ret =
+        unsafe { libc::clock_settime(clock_id.as_raw(), timespec.as_ref()) };
     Errno::result(ret).map(drop)
 }
 
@@ -248,9 +268,12 @@ pub fn clock_settime(clock_id: ClockId, timespec: TimeSpec) -> Result<()> {
     target_os = "android",
     target_os = "emscripten",
 ))]
+#[cfg(feature = "process")]
+#[cfg_attr(docsrs, doc(cfg(feature = "process")))]
 pub fn clock_getcpuclockid(pid: Pid) -> Result<ClockId> {
     let mut clk_id: MaybeUninit<libc::clockid_t> = MaybeUninit::uninit();
-    let ret = unsafe { libc::clock_getcpuclockid(pid.into(), clk_id.as_mut_ptr()) };
+    let ret =
+        unsafe { libc::clock_getcpuclockid(pid.into(), clk_id.as_mut_ptr()) };
     if ret == 0 {
         let res = unsafe { clk_id.assume_init() };
         Ok(ClockId::from(res))
diff --git a/src/ucontext.rs b/src/ucontext.rs
index f2338bd..b2a39f7 100644
--- a/src/ucontext.rs
+++ b/src/ucontext.rs
@@ -1,10 +1,10 @@
 #[cfg(not(target_env = "musl"))]
-use crate::Result;
-#[cfg(not(target_env = "musl"))]
 use crate::errno::Errno;
+use crate::sys::signal::SigSet;
+#[cfg(not(target_env = "musl"))]
+use crate::Result;
 #[cfg(not(target_env = "musl"))]
 use std::mem;
-use crate::sys::signal::SigSet;
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct UContext {
@@ -17,7 +17,9 @@ impl UContext {
         let mut context = mem::MaybeUninit::<libc::ucontext_t>::uninit();
         let res = unsafe { libc::getcontext(context.as_mut_ptr()) };
         Errno::result(res).map(|_| unsafe {
-            UContext { context: context.assume_init()}
+            UContext {
+                context: context.assume_init(),
+            }
         })
     }
 
@@ -31,13 +33,15 @@ impl UContext {
 
     pub fn sigmask_mut(&mut self) -> &mut SigSet {
         unsafe {
-            &mut *(&mut self.context.uc_sigmask as *mut libc::sigset_t as *mut SigSet)
+            &mut *(&mut self.context.uc_sigmask as *mut libc::sigset_t
+                as *mut SigSet)
         }
     }
 
     pub fn sigmask(&self) -> &SigSet {
         unsafe {
-            &*(&self.context.uc_sigmask as *const libc::sigset_t as *const SigSet)
+            &*(&self.context.uc_sigmask as *const libc::sigset_t
+                as *const SigSet)
         }
     }
 }
diff --git a/src/unistd.rs b/src/unistd.rs
index 2c89d77..ca07b34 100644
--- a/src/unistd.rs
+++ b/src/unistd.rs
@@ -1,37 +1,70 @@
 //! Safe wrappers around functions found in libc "unistd.h" header
 
-#[cfg(not(target_os = "redox"))]
-use cfg_if::cfg_if;
 use crate::errno::{self, Errno};
-use crate::{Error, Result, NixPath};
 #[cfg(not(target_os = "redox"))]
-use crate::fcntl::{AtFlags, at_rawfd};
-use crate::fcntl::{FdFlag, OFlag, fcntl};
-use crate::fcntl::FcntlArg::F_SETFD;
-use libc::{self, c_char, c_void, c_int, c_long, c_uint, size_t, pid_t, off_t,
-           uid_t, gid_t, mode_t, PATH_MAX};
-use std::{fmt, mem, ptr};
+#[cfg(feature = "fs")]
+use crate::fcntl::{at_rawfd, AtFlags};
+#[cfg(feature = "fs")]
+use crate::fcntl::{fcntl, FcntlArg::F_SETFD, FdFlag, OFlag};
+#[cfg(all(
+    feature = "fs",
+    any(
+        target_os = "openbsd",
+        target_os = "netbsd",
+        target_os = "freebsd",
+        target_os = "dragonfly",
+        target_os = "macos",
+        target_os = "ios"
+    )
+))]
+use crate::sys::stat::FileFlag;
+#[cfg(feature = "fs")]
+use crate::sys::stat::Mode;
+use crate::{Error, NixPath, Result};
+#[cfg(not(target_os = "redox"))]
+use cfg_if::cfg_if;
+use libc::{
+    self, c_char, c_int, c_long, c_uint, c_void, gid_t, mode_t, off_t, pid_t,
+    size_t, uid_t, PATH_MAX,
+};
 use std::convert::Infallible;
 use std::ffi::{CStr, OsString};
 #[cfg(not(target_os = "redox"))]
 use std::ffi::{CString, OsStr};
-use std::os::unix::ffi::OsStringExt;
 #[cfg(not(target_os = "redox"))]
 use std::os::unix::ffi::OsStrExt;
+use std::os::unix::ffi::OsStringExt;
 use std::os::unix::io::RawFd;
 use std::path::PathBuf;
-use crate::sys::stat::Mode;
+use std::{fmt, mem, ptr};
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub use self::pivot_root::*;
+feature! {
+    #![feature = "fs"]
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    pub use self::pivot_root::*;
+}
 
-#[cfg(any(target_os = "android", target_os = "freebsd",
-          target_os = "linux", target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 pub use self::setres::*;
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 pub use self::getres::*;
 
+feature! {
+#![feature = "user"]
+
 /// User identifier
 ///
 /// Newtype pattern around `uid_t` (which is just alias). It prevents bugs caused by accidentally
@@ -46,11 +79,13 @@ impl Uid {
     }
 
     /// Returns Uid of calling process. This is practically a more Rusty alias for `getuid`.
+    #[doc(alias("getuid"))]
     pub fn current() -> Self {
         getuid()
     }
 
     /// Returns effective Uid of calling process. This is practically a more Rusty alias for `geteuid`.
+    #[doc(alias("geteuid"))]
     pub fn effective() -> Self {
         geteuid()
     }
@@ -72,6 +107,12 @@ impl From<Uid> for uid_t {
     }
 }
 
+impl From<uid_t> for Uid {
+    fn from(uid: uid_t) -> Self {
+        Uid(uid)
+    }
+}
+
 impl fmt::Display for Uid {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self.0, f)
@@ -95,11 +136,13 @@ impl Gid {
     }
 
     /// Returns Gid of calling process. This is practically a more Rusty alias for `getgid`.
+    #[doc(alias("getgid"))]
     pub fn current() -> Self {
         getgid()
     }
 
     /// Returns effective Gid of calling process. This is practically a more Rusty alias for `getegid`.
+    #[doc(alias("getegid"))]
     pub fn effective() -> Self {
         getegid()
     }
@@ -116,12 +159,21 @@ impl From<Gid> for gid_t {
     }
 }
 
+impl From<gid_t> for Gid {
+    fn from(gid: gid_t) -> Self {
+        Gid(gid)
+    }
+}
+
 impl fmt::Display for Gid {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self.0, f)
     }
 }
+}
 
+feature! {
+#![feature = "process"]
 /// Process identifier
 ///
 /// Newtype pattern around `pid_t` (which is just alias). It prevents bugs caused by accidentally
@@ -136,11 +188,13 @@ impl Pid {
     }
 
     /// Returns PID of calling process
+    #[doc(alias("getpid"))]
     pub fn this() -> Self {
         getpid()
     }
 
     /// Returns PID of parent of calling process
+    #[doc(alias("getppid"))]
     pub fn parent() -> Self {
         getppid()
     }
@@ -193,8 +247,8 @@ impl ForkResult {
 /// Create a new child process duplicating the parent process ([see
 /// fork(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html)).
 ///
-/// After calling the fork system call (successfully) two processes will
-/// be created that are identical with the exception of their pid and the
+/// After successfully calling the fork system call, a second process will
+/// be created which is identical to the original except for the pid and the
 /// return value of this function.  As an example:
 ///
 /// ```
@@ -214,7 +268,7 @@ impl ForkResult {
 /// }
 /// ```
 ///
-/// This will print something like the following (order indeterministic).  The
+/// This will print something like the following (order nondeterministic).  The
 /// thing to note is that you end up with two processes continuing execution
 /// immediately after the fork call but with different match arms.
 ///
@@ -303,8 +357,10 @@ pub fn getsid(pid: Option<Pid>) -> Result<Pid> {
     let res = unsafe { libc::getsid(pid.unwrap_or(Pid(0)).into()) };
     Errno::result(res).map(Pid)
 }
+}
 
-
+feature! {
+#![all(feature = "process", feature = "term")]
 /// Get the terminal foreground process group (see
 /// [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetpgrp.html)).
 ///
@@ -325,8 +381,10 @@ pub fn tcsetpgrp(fd: c_int, pgrp: Pid) -> Result<()> {
     let res = unsafe { libc::tcsetpgrp(fd, pgrp.into()) };
     Errno::result(res).map(drop)
 }
+}
 
-
+feature! {
+#![feature = "process"]
 /// Get the group id of the calling process (see
 ///[getpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgrp.html)).
 ///
@@ -352,11 +410,14 @@ pub fn getpgrp() -> Pid {
 pub fn gettid() -> Pid {
     Pid(unsafe { libc::syscall(libc::SYS_gettid) as pid_t })
 }
+}
 
+feature! {
+#![feature = "fs"]
 /// Create a copy of the specified file descriptor (see
 /// [dup(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html)).
 ///
-/// The new file descriptor will be have a new index but refer to the same
+/// The new file descriptor will have a new index but refer to the same
 /// resource as the old file descriptor and the old and new file descriptors may
 /// be used interchangeably.  The new and old file descriptor share the same
 /// underlying resource, offset, and file status flags.  The actual index used
@@ -524,7 +585,7 @@ pub fn mkfifo<P: ?Sized + NixPath>(path: &P, mode: Mode) -> Result<()> {
 // mkfifoat is not implemented in OSX or android
 #[inline]
 #[cfg(not(any(
-    target_os = "macos", target_os = "ios",
+    target_os = "macos", target_os = "ios", target_os = "haiku",
     target_os = "android", target_os = "redox")))]
 pub fn mkfifoat<P: ?Sized + NixPath>(dirfd: Option<RawFd>, path: &P, mode: Mode) -> Result<()> {
     let res = path.with_nix_path(|cstr| unsafe {
@@ -562,14 +623,16 @@ pub fn symlinkat<P1: ?Sized + NixPath, P2: ?Sized + NixPath>(
         })??;
     Errno::result(res).map(drop)
 }
+}
 
 // Double the buffer capacity up to limit. In case it already has
 // reached the limit, return Errno::ERANGE.
+#[cfg(any(feature = "fs", feature = "user"))]
 fn reserve_double_buffer_size<T>(buf: &mut Vec<T>, limit: usize) -> Result<()> {
     use std::cmp::min;
 
     if buf.capacity() >= limit {
-        return Err(Errno::ERANGE)
+        return Err(Errno::ERANGE);
     }
 
     let capacity = min(buf.capacity() * 2, limit);
@@ -578,6 +641,9 @@ fn reserve_double_buffer_size<T>(buf: &mut Vec<T>, limit: usize) -> Result<()> {
     Ok(())
 }
 
+feature! {
+#![feature = "fs"]
+
 /// Returns the current directory as a `PathBuf`
 ///
 /// Err is returned if the current user doesn't have the permission to read or search a component
@@ -621,6 +687,10 @@ pub fn getcwd() -> Result<PathBuf> {
         }
     }
 }
+}
+
+feature! {
+#![all(feature = "user", feature = "fs")]
 
 /// Computes the raw UID and GID values to pass to a `*chown` call.
 // The cast is not unnecessary on all platforms.
@@ -688,8 +758,8 @@ pub enum FchownatFlags {
 /// If `flag` is `FchownatFlags::NoFollowSymlink` and `path` names a symbolic link,
 /// then the mode of the symbolic link is changed.
 ///
-/// `fchownat(None, path, mode, FchownatFlags::NoFollowSymlink)` is identical to
-/// a call `libc::lchown(path, mode)`.  That's why `lchmod` is unimplemented in
+/// `fchownat(None, path, owner, group, FchownatFlags::NoFollowSymlink)` is identical to
+/// a call `libc::lchown(path, owner, group)`.  That's why `lchown` is unimplemented in
 /// the `nix` crate.
 ///
 /// # References
@@ -716,10 +786,16 @@ pub fn fchownat<P: ?Sized + NixPath>(
 
     Errno::result(res).map(drop)
 }
+}
 
+feature! {
+#![feature = "process"]
 fn to_exec_array<S: AsRef<CStr>>(args: &[S]) -> Vec<*const c_char> {
     use std::iter::once;
-    args.iter().map(|s| s.as_ref().as_ptr()).chain(once(ptr::null())).collect()
+    args.iter()
+        .map(|s| s.as_ref().as_ptr())
+        .chain(once(ptr::null()))
+        .collect()
 }
 
 /// Replace the current process image with a new one (see
@@ -815,11 +891,9 @@ pub fn execvpe<SA: AsRef<CStr>, SE: AsRef<CStr>>(filename: &CStr, args: &[SA], e
 ///
 /// This function is similar to `execve`, except that the program to be executed
 /// is referenced as a file descriptor instead of a path.
-// Note for NetBSD and OpenBSD: although rust-lang/libc includes it (under
-// unix/bsd/netbsdlike/) fexecve is not currently implemented on NetBSD nor on
-// OpenBSD.
 #[cfg(any(target_os = "android",
           target_os = "linux",
+          target_os = "dragonfly",
           target_os = "freebsd"))]
 #[inline]
 pub fn fexecve<SA: AsRef<CStr> ,SE: AsRef<CStr>>(fd: RawFd, args: &[SA], env: &[SE]) -> Result<Infallible> {
@@ -895,14 +969,18 @@ pub fn daemon(nochdir: bool, noclose: bool) -> Result<()> {
     let res = unsafe { libc::daemon(nochdir as c_int, noclose as c_int) };
     Errno::result(res).map(drop)
 }
+}
+
+feature! {
+#![feature = "hostname"]
 
 /// Set the system host name (see
 /// [sethostname(2)](https://man7.org/linux/man-pages/man2/gethostname.2.html)).
 ///
 /// Given a name, attempt to update the system host name to the given string.
 /// On some systems, the host name is limited to as few as 64 bytes.  An error
-/// will be return if the name is not valid or the current process does not have
-/// permissions to update the host name.
+/// will be returned if the name is not valid or the current process does not
+/// have permissions to update the host name.
 #[cfg(not(target_os = "redox"))]
 pub fn sethostname<S: AsRef<OsStr>>(name: S) -> Result<()> {
     // Handle some differences in type of the len arg across platforms.
@@ -925,36 +1003,37 @@ pub fn sethostname<S: AsRef<OsStr>>(name: S) -> Result<()> {
     Errno::result(res).map(drop)
 }
 
-/// Get the host name and store it in the provided buffer, returning a pointer
-/// the `CStr` in that buffer on success (see
+/// Get the host name and store it in an internally allocated buffer, returning an
+/// `OsString` on success (see
 /// [gethostname(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html)).
 ///
 /// This function call attempts to get the host name for the running system and
-/// store it in a provided buffer.  The buffer will be populated with bytes up
-/// to the length of the provided slice including a NUL terminating byte.  If
-/// the hostname is longer than the length provided, no error will be provided.
-/// The posix specification does not specify whether implementations will
-/// null-terminate in this case, but the nix implementation will ensure that the
-/// buffer is null terminated in this case.
+/// store it in an internal buffer, returning it as an `OsString` if successful.
 ///
 /// ```no_run
 /// use nix::unistd;
 ///
-/// let mut buf = [0u8; 64];
-/// let hostname_cstr = unistd::gethostname(&mut buf).expect("Failed getting hostname");
-/// let hostname = hostname_cstr.to_str().expect("Hostname wasn't valid UTF-8");
+/// let hostname = unistd::gethostname().expect("Failed getting hostname");
+/// let hostname = hostname.into_string().expect("Hostname wasn't valid UTF-8");
 /// println!("Hostname: {}", hostname);
 /// ```
-pub fn gethostname(buffer: &mut [u8]) -> Result<&CStr> {
+pub fn gethostname() -> Result<OsString> {
+    // The capacity is the max length of a hostname plus the NUL terminator.
+    let mut buffer: Vec<u8> = Vec::with_capacity(256);
     let ptr = buffer.as_mut_ptr() as *mut c_char;
-    let len = buffer.len() as size_t;
+    let len = buffer.capacity() as size_t;
 
     let res = unsafe { libc::gethostname(ptr, len) };
     Errno::result(res).map(|_| {
-        buffer[len - 1] = 0; // ensure always null-terminated
-        unsafe { CStr::from_ptr(buffer.as_ptr() as *const c_char) }
+        unsafe {
+            buffer.as_mut_ptr().wrapping_add(len - 1).write(0); // ensure always null-terminated
+            let len = CStr::from_ptr(buffer.as_ptr() as *const c_char).len();
+            buffer.set_len(len);
+        }
+        OsString::from_vec(buffer)
     })
 }
+}
 
 /// Close a raw file descriptor
 ///
@@ -990,7 +1069,9 @@ pub fn close(fd: RawFd) -> Result<()> {
 ///
 /// See also [read(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html)
 pub fn read(fd: RawFd, buf: &mut [u8]) -> Result<usize> {
-    let res = unsafe { libc::read(fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t) };
+    let res = unsafe {
+        libc::read(fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t)
+    };
 
     Errno::result(res).map(|r| r as usize)
 }
@@ -999,11 +1080,16 @@ pub fn read(fd: RawFd, buf: &mut [u8]) -> Result<usize> {
 ///
 /// See also [write(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html)
 pub fn write(fd: RawFd, buf: &[u8]) -> Result<usize> {
-    let res = unsafe { libc::write(fd, buf.as_ptr() as *const c_void, buf.len() as size_t) };
+    let res = unsafe {
+        libc::write(fd, buf.as_ptr() as *const c_void, buf.len() as size_t)
+    };
 
     Errno::result(res).map(|r| r as usize)
 }
 
+feature! {
+#![feature = "fs"]
+
 /// Directive that tells [`lseek`] and [`lseek64`] what the offset is relative to.
 ///
 /// [`lseek`]: ./fn.lseek.html
@@ -1054,22 +1140,23 @@ pub fn lseek64(fd: RawFd, offset: libc::off64_t, whence: Whence) -> Result<libc:
 
     Errno::result(res).map(|r| r as libc::off64_t)
 }
+}
 
 /// Create an interprocess channel.
 ///
 /// See also [pipe(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html)
 pub fn pipe() -> std::result::Result<(RawFd, RawFd), Error> {
-    unsafe {
-        let mut fds = mem::MaybeUninit::<[c_int; 2]>::uninit();
+    let mut fds = mem::MaybeUninit::<[c_int; 2]>::uninit();
 
-        let res = libc::pipe(fds.as_mut_ptr() as *mut c_int);
+    let res = unsafe { libc::pipe(fds.as_mut_ptr() as *mut c_int) };
 
-        Error::result(res)?;
+    Error::result(res)?;
 
-        Ok((fds.assume_init()[0], fds.assume_init()[1]))
-    }
+    unsafe { Ok((fds.assume_init()[0], fds.assume_init()[1])) }
 }
 
+feature! {
+#![feature = "fs"]
 /// Like `pipe`, but allows setting certain file descriptor flags.
 ///
 /// The following flags are supported, and will be set atomically as the pipe is
@@ -1267,6 +1354,17 @@ pub fn sync() {
     unsafe { libc::sync() };
 }
 
+/// Commit filesystem caches containing file referred to by the open file
+/// descriptor `fd` to disk
+///
+/// See also [syncfs(2)](https://man7.org/linux/man-pages/man2/sync.2.html)
+#[cfg(target_os = "linux")]
+pub fn syncfs(fd: RawFd) -> Result<()> {
+    let res = unsafe { libc::syncfs(fd) };
+
+    Errno::result(res).map(drop)
+}
+
 /// Synchronize changes to a file
 ///
 /// See also [fsync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html)
@@ -1281,11 +1379,13 @@ pub fn fsync(fd: RawFd) -> Result<()> {
 ///
 /// See also
 /// [fdatasync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fdatasync.html)
-// `fdatasync(2) is in POSIX, but in libc it is only defined in `libc::notbsd`.
-// TODO: exclude only Apple systems after https://github.com/rust-lang/libc/pull/211
 #[cfg(any(target_os = "linux",
           target_os = "android",
           target_os = "emscripten",
+          target_os = "freebsd",
+          target_os = "fuchsia",
+          target_os = "netbsd",
+          target_os = "openbsd",
           target_os = "illumos",
           target_os = "solaris"))]
 #[inline]
@@ -1294,6 +1394,10 @@ pub fn fdatasync(fd: RawFd) -> Result<()> {
 
     Errno::result(res).map(drop)
 }
+}
+
+feature! {
+#![feature = "user"]
 
 /// Get a real user ID
 ///
@@ -1374,7 +1478,10 @@ pub fn setgid(gid: Gid) -> Result<()> {
 
     Errno::result(res).map(drop)
 }
+}
 
+feature! {
+#![all(feature = "fs", feature = "user")]
 /// Set the user identity used for filesystem checks per-thread.
 /// On both success and failure, this call returns the previous filesystem user
 /// ID of the caller.
@@ -1396,6 +1503,10 @@ pub fn setfsgid(gid: Gid) -> Gid {
     let prev_fsgid = unsafe { libc::setfsgid(gid.into()) };
     Gid::from_raw(prev_fsgid as gid_t)
 }
+}
+
+feature! {
+#![feature = "user"]
 
 /// Get the list of supplementary group IDs of the calling process.
 ///
@@ -1472,7 +1583,7 @@ pub fn getgroups() -> Result<Vec<Gid>> {
 /// # use std::error::Error;
 /// # use nix::unistd::*;
 /// #
-/// # fn try_main() -> Result<(), Box<Error>> {
+/// # fn try_main() -> Result<(), Box<dyn Error>> {
 /// let uid = Uid::from_raw(33);
 /// let gid = Gid::from_raw(34);
 /// setgroups(&[gid])?;
@@ -1484,7 +1595,7 @@ pub fn getgroups() -> Result<Vec<Gid>> {
 /// #
 /// # try_main().unwrap();
 /// ```
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
+#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox", target_os = "haiku")))]
 pub fn setgroups(groups: &[Gid]) -> Result<()> {
     cfg_if! {
         if #[cfg(any(target_os = "dragonfly",
@@ -1598,7 +1709,7 @@ pub fn getgrouplist(user: &CStr, group: Gid) -> Result<Vec<Gid>> {
 /// # use std::ffi::CString;
 /// # use nix::unistd::*;
 /// #
-/// # fn try_main() -> Result<(), Box<Error>> {
+/// # fn try_main() -> Result<(), Box<dyn Error>> {
 /// let user = CString::new("www-data").unwrap();
 /// let uid = Uid::from_raw(33);
 /// let gid = Gid::from_raw(33);
@@ -1611,7 +1722,7 @@ pub fn getgrouplist(user: &CStr, group: Gid) -> Result<Vec<Gid>> {
 /// #
 /// # try_main().unwrap();
 /// ```
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
+#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox", target_os = "haiku")))]
 pub fn initgroups(user: &CStr, group: Gid) -> Result<()> {
     cfg_if! {
         if #[cfg(any(target_os = "ios", target_os = "macos"))] {
@@ -1625,6 +1736,10 @@ pub fn initgroups(user: &CStr, group: Gid) -> Result<()> {
 
     Errno::result(res).map(drop)
 }
+}
+
+feature! {
+#![feature = "signal"]
 
 /// Suspend the thread until a signal is received.
 ///
@@ -1722,6 +1837,7 @@ pub mod alarm {
         }
     }
 }
+}
 
 /// Suspend execution for an interval of time
 ///
@@ -1732,7 +1848,10 @@ pub fn sleep(seconds: c_uint) -> c_uint {
     unsafe { libc::sleep(seconds) }
 }
 
-#[cfg(not(target_os = "redox"))]
+feature! {
+#![feature = "acct"]
+
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 pub mod acct {
     use crate::{Result, NixPath};
     use crate::errno::Errno;
@@ -1756,7 +1875,10 @@ pub mod acct {
         Errno::result(res).map(drop)
     }
 }
+}
 
+feature! {
+#![feature = "fs"]
 /// Creates a regular file which persists even after process termination
 ///
 /// * `template`: a path whose 6 rightmost characters must be X, e.g. `/tmp/tmpfile_XXXXXX`
@@ -1792,6 +1914,10 @@ pub fn mkstemp<P: ?Sized + NixPath>(template: &P) -> Result<(RawFd, PathBuf)> {
     Errno::result(fd)?;
     Ok((fd, PathBuf::from(pathname)))
 }
+}
+
+feature! {
+#![all(feature = "fs", feature = "feature")]
 
 /// Variable names for `pathconf`
 ///
@@ -1817,6 +1943,7 @@ pub enum PathconfVar {
               target_os = "netbsd", target_os = "openbsd", target_os = "redox"))]
     /// Minimum number of bits needed to represent, as a signed integer value,
     /// the maximum size of a regular file allowed in the specified directory.
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     FILESIZEBITS = libc::_PC_FILESIZEBITS,
     /// Maximum number of links to a single file.
     LINK_MAX = libc::_PC_LINK_MAX,
@@ -1840,33 +1967,40 @@ pub enum PathconfVar {
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "illumos",
               target_os = "linux", target_os = "netbsd", target_os = "openbsd",
               target_os = "redox", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Symbolic links can be created.
     POSIX2_SYMLINKS = libc::_PC_2_SYMLINKS,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "linux", target_os = "openbsd", target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Minimum number of bytes of storage actually allocated for any portion of
     /// a file.
     POSIX_ALLOC_SIZE_MIN = libc::_PC_ALLOC_SIZE_MIN,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "linux", target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Recommended increment for file transfer sizes between the
     /// `POSIX_REC_MIN_XFER_SIZE` and `POSIX_REC_MAX_XFER_SIZE` values.
     POSIX_REC_INCR_XFER_SIZE = libc::_PC_REC_INCR_XFER_SIZE,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "linux", target_os = "openbsd", target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Maximum recommended file transfer size.
     POSIX_REC_MAX_XFER_SIZE = libc::_PC_REC_MAX_XFER_SIZE,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "linux", target_os = "openbsd", target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Minimum recommended file transfer size.
     POSIX_REC_MIN_XFER_SIZE = libc::_PC_REC_MIN_XFER_SIZE,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "linux", target_os = "openbsd", target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ///  Recommended file transfer buffer alignment.
     POSIX_REC_XFER_ALIGN = libc::_PC_REC_XFER_ALIGN,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "illumos", target_os = "linux", target_os = "netbsd",
               target_os = "openbsd", target_os = "redox", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Maximum number of bytes in a symbolic link.
     SYMLINK_MAX = libc::_PC_SYMLINK_MAX,
     /// The use of `chown` and `fchown` is restricted to a process with
@@ -1882,22 +2016,26 @@ pub enum PathconfVar {
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "illumos", target_os = "linux", target_os = "openbsd",
               target_os = "redox", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Asynchronous input or output operations may be performed for the
     /// associated file.
     _POSIX_ASYNC_IO = libc::_PC_ASYNC_IO,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "illumos", target_os = "linux", target_os = "openbsd",
               target_os = "redox", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Prioritized input or output operations may be performed for the
     /// associated file.
     _POSIX_PRIO_IO = libc::_PC_PRIO_IO,
     #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd",
               target_os = "illumos", target_os = "linux", target_os = "netbsd",
               target_os = "openbsd", target_os = "redox", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Synchronized input or output operations may be performed for the
     /// associated file.
     _POSIX_SYNC_IO = libc::_PC_SYNC_IO,
     #[cfg(any(target_os = "dragonfly", target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The resolution in nanoseconds for all file timestamps.
     _POSIX_TIMESTAMP_RESOLUTION = libc::_PC_TIMESTAMP_RESOLUTION
 }
@@ -1972,6 +2110,10 @@ pub fn pathconf<P: ?Sized + NixPath>(path: &P, var: PathconfVar) -> Result<Optio
         Ok(Some(raw))
     }
 }
+}
+
+feature! {
+#![feature = "feature"]
 
 /// Variable names for `sysconf`
 ///
@@ -1995,15 +2137,18 @@ pub fn pathconf<P: ?Sized + NixPath>(path: &P, var: PathconfVar) -> Result<Optio
 pub enum SysconfVar {
     /// Maximum number of I/O operations in a single list I/O call supported by
     /// the implementation.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AIO_LISTIO_MAX = libc::_SC_AIO_LISTIO_MAX,
     /// Maximum number of outstanding asynchronous I/O operations supported by
     /// the implementation.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     AIO_MAX = libc::_SC_AIO_MAX,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The maximum amount by which a process can decrease its asynchronous I/O
     /// priority level from its own scheduling priority.
     AIO_PRIO_DELTA_MAX = libc::_SC_AIO_PRIO_DELTA_MAX,
@@ -2011,18 +2156,23 @@ pub enum SysconfVar {
     ARG_MAX = libc::_SC_ARG_MAX,
     /// Maximum number of functions that may be registered with `atexit`.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     ATEXIT_MAX = libc::_SC_ATEXIT_MAX,
     /// Maximum obase values allowed by the bc utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     BC_BASE_MAX = libc::_SC_BC_BASE_MAX,
     /// Maximum number of elements permitted in an array by the bc utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     BC_DIM_MAX = libc::_SC_BC_DIM_MAX,
     /// Maximum scale value allowed by the bc utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     BC_SCALE_MAX = libc::_SC_BC_SCALE_MAX,
     /// Maximum length of a string constant accepted by the bc utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     BC_STRING_MAX = libc::_SC_BC_STRING_MAX,
     /// Maximum number of simultaneous processes per real user ID.
     CHILD_MAX = libc::_SC_CHILD_MAX,
@@ -2030,242 +2180,305 @@ pub enum SysconfVar {
     CLK_TCK = libc::_SC_CLK_TCK,
     /// Maximum number of weights that can be assigned to an entry of the
     /// LC_COLLATE order keyword in the locale definition file
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     COLL_WEIGHTS_MAX = libc::_SC_COLL_WEIGHTS_MAX,
     /// Maximum number of timer expiration overruns.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     DELAYTIMER_MAX = libc::_SC_DELAYTIMER_MAX,
     /// Maximum number of expressions that can be nested within parentheses by
     /// the expr utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     EXPR_NEST_MAX = libc::_SC_EXPR_NEST_MAX,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Maximum length of a host name (not including the terminating null) as
     /// returned from the `gethostname` function
     HOST_NAME_MAX = libc::_SC_HOST_NAME_MAX,
     /// Maximum number of iovec structures that one process has available for
     /// use with `readv` or `writev`.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     IOV_MAX = libc::_SC_IOV_MAX,
     /// Unless otherwise noted, the maximum length, in bytes, of a utility's
     /// input line (either standard input or another file), when the utility is
     /// described as processing text files. The length includes room for the
-    /// trailing <newline>.
-    #[cfg(not(target_os = "redox"))]
+    /// trailing newline.
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     LINE_MAX = libc::_SC_LINE_MAX,
     /// Maximum length of a login name.
+    #[cfg(not(target_os = "haiku"))]
     LOGIN_NAME_MAX = libc::_SC_LOGIN_NAME_MAX,
     /// Maximum number of simultaneous supplementary group IDs per process.
     NGROUPS_MAX = libc::_SC_NGROUPS_MAX,
     /// Initial size of `getgrgid_r` and `getgrnam_r` data buffers
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     GETGR_R_SIZE_MAX = libc::_SC_GETGR_R_SIZE_MAX,
     /// Initial size of `getpwuid_r` and `getpwnam_r` data buffers
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     GETPW_R_SIZE_MAX = libc::_SC_GETPW_R_SIZE_MAX,
     /// The maximum number of open message queue descriptors a process may hold.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     MQ_OPEN_MAX = libc::_SC_MQ_OPEN_MAX,
     /// The maximum number of message priorities supported by the implementation.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     MQ_PRIO_MAX = libc::_SC_MQ_PRIO_MAX,
     /// A value one greater than the maximum value that the system may assign to
     /// a newly-created file descriptor.
     OPEN_MAX = libc::_SC_OPEN_MAX,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Advisory Information option.
     _POSIX_ADVISORY_INFO = libc::_SC_ADVISORY_INFO,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports barriers.
     _POSIX_BARRIERS = libc::_SC_BARRIERS,
     /// The implementation supports asynchronous input and output.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_ASYNCHRONOUS_IO = libc::_SC_ASYNCHRONOUS_IO,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports clock selection.
     _POSIX_CLOCK_SELECTION = libc::_SC_CLOCK_SELECTION,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Process CPU-Time Clocks option.
     _POSIX_CPUTIME = libc::_SC_CPUTIME,
     /// The implementation supports the File Synchronization option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_FSYNC = libc::_SC_FSYNC,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the IPv6 option.
     _POSIX_IPV6 = libc::_SC_IPV6,
     /// The implementation supports job control.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_JOB_CONTROL = libc::_SC_JOB_CONTROL,
     /// The implementation supports memory mapped Files.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MAPPED_FILES = libc::_SC_MAPPED_FILES,
     /// The implementation supports the Process Memory Locking option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MEMLOCK = libc::_SC_MEMLOCK,
     /// The implementation supports the Range Memory Locking option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MEMLOCK_RANGE = libc::_SC_MEMLOCK_RANGE,
     /// The implementation supports memory protection.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MEMORY_PROTECTION = libc::_SC_MEMORY_PROTECTION,
     /// The implementation supports the Message Passing option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MESSAGE_PASSING = libc::_SC_MESSAGE_PASSING,
     /// The implementation supports the Monotonic Clock option.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_MONOTONIC_CLOCK = libc::_SC_MONOTONIC_CLOCK,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "illumos", target_os = "ios", target_os="linux",
               target_os = "macos", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Prioritized Input and Output option.
     _POSIX_PRIORITIZED_IO = libc::_SC_PRIORITIZED_IO,
     /// The implementation supports the Process Scheduling option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_PRIORITY_SCHEDULING = libc::_SC_PRIORITY_SCHEDULING,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Raw Sockets option.
     _POSIX_RAW_SOCKETS = libc::_SC_RAW_SOCKETS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports read-write locks.
     _POSIX_READER_WRITER_LOCKS = libc::_SC_READER_WRITER_LOCKS,
     #[cfg(any(target_os = "android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports realtime signals.
     _POSIX_REALTIME_SIGNALS = libc::_SC_REALTIME_SIGNALS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "illumos",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd", target_os = "solaris"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Regular Expression Handling option.
     _POSIX_REGEXP = libc::_SC_REGEXP,
     /// Each process has a saved set-user-ID and a saved set-group-ID.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_SAVED_IDS = libc::_SC_SAVED_IDS,
     /// The implementation supports semaphores.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_SEMAPHORES = libc::_SC_SEMAPHORES,
     /// The implementation supports the Shared Memory Objects option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_SHARED_MEMORY_OBJECTS = libc::_SC_SHARED_MEMORY_OBJECTS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the POSIX shell.
     _POSIX_SHELL = libc::_SC_SHELL,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Spawn option.
     _POSIX_SPAWN = libc::_SC_SPAWN,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports spin locks.
     _POSIX_SPIN_LOCKS = libc::_SC_SPIN_LOCKS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Process Sporadic Server option.
     _POSIX_SPORADIC_SERVER = libc::_SC_SPORADIC_SERVER,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_SS_REPL_MAX = libc::_SC_SS_REPL_MAX,
     /// The implementation supports the Synchronized Input and Output option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_SYNCHRONIZED_IO = libc::_SC_SYNCHRONIZED_IO,
     /// The implementation supports the Thread Stack Address Attribute option.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_ATTR_STACKADDR = libc::_SC_THREAD_ATTR_STACKADDR,
     /// The implementation supports the Thread Stack Size Attribute option.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_ATTR_STACKSIZE = libc::_SC_THREAD_ATTR_STACKSIZE,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="netbsd", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Thread CPU-Time Clocks option.
     _POSIX_THREAD_CPUTIME = libc::_SC_THREAD_CPUTIME,
     /// The implementation supports the Non-Robust Mutex Priority Inheritance
     /// option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_PRIO_INHERIT = libc::_SC_THREAD_PRIO_INHERIT,
     /// The implementation supports the Non-Robust Mutex Priority Protection option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_PRIO_PROTECT = libc::_SC_THREAD_PRIO_PROTECT,
     /// The implementation supports the Thread Execution Scheduling option.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_PRIORITY_SCHEDULING = libc::_SC_THREAD_PRIORITY_SCHEDULING,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Thread Process-Shared Synchronization
     /// option.
     _POSIX_THREAD_PROCESS_SHARED = libc::_SC_THREAD_PROCESS_SHARED,
     #[cfg(any(target_os="dragonfly", target_os="linux", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Robust Mutex Priority Inheritance option.
     _POSIX_THREAD_ROBUST_PRIO_INHERIT = libc::_SC_THREAD_ROBUST_PRIO_INHERIT,
     #[cfg(any(target_os="dragonfly", target_os="linux", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Robust Mutex Priority Protection option.
     _POSIX_THREAD_ROBUST_PRIO_PROTECT = libc::_SC_THREAD_ROBUST_PRIO_PROTECT,
     /// The implementation supports thread-safe functions.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREAD_SAFE_FUNCTIONS = libc::_SC_THREAD_SAFE_FUNCTIONS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Thread Sporadic Server option.
     _POSIX_THREAD_SPORADIC_SERVER = libc::_SC_THREAD_SPORADIC_SERVER,
     /// The implementation supports threads.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_THREADS = libc::_SC_THREADS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports timeouts.
     _POSIX_TIMEOUTS = libc::_SC_TIMEOUTS,
     /// The implementation supports timers.
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_TIMERS = libc::_SC_TIMERS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Trace option.
     _POSIX_TRACE = libc::_SC_TRACE,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Trace Event Filter option.
     _POSIX_TRACE_EVENT_FILTER = libc::_SC_TRACE_EVENT_FILTER,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_TRACE_EVENT_NAME_MAX = libc::_SC_TRACE_EVENT_NAME_MAX,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Trace Inherit option.
     _POSIX_TRACE_INHERIT = libc::_SC_TRACE_INHERIT,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Trace Log option.
     _POSIX_TRACE_LOG = libc::_SC_TRACE_LOG,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_TRACE_NAME_MAX = libc::_SC_TRACE_NAME_MAX,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_TRACE_SYS_MAX = libc::_SC_TRACE_SYS_MAX,
     #[cfg(any(target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX_TRACE_USER_EVENT_MAX = libc::_SC_TRACE_USER_EVENT_MAX,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Typed Memory Objects option.
     _POSIX_TYPED_MEMORY_OBJECTS = libc::_SC_TYPED_MEMORY_OBJECTS,
     /// Integer value indicating version of this standard (C-language binding)
@@ -2275,12 +2488,14 @@ pub enum SysconfVar {
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation provides a C-language compilation environment with
     /// 32-bit `int`, `long`, `pointer`, and `off_t` types.
     _POSIX_V6_ILP32_OFF32 = libc::_SC_V6_ILP32_OFF32,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation provides a C-language compilation environment with
     /// 32-bit `int`, `long`, and pointer types and an `off_t` type using at
     /// least 64 bits.
@@ -2288,157 +2503,207 @@ pub enum SysconfVar {
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation provides a C-language compilation environment with
     /// 32-bit `int` and 64-bit `long`, `pointer`, and `off_t` types.
     _POSIX_V6_LP64_OFF64 = libc::_SC_V6_LP64_OFF64,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation provides a C-language compilation environment with an
     /// `int` type using at least 32 bits and `long`, pointer, and `off_t` types
     /// using at least 64 bits.
     _POSIX_V6_LPBIG_OFFBIG = libc::_SC_V6_LPBIG_OFFBIG,
     /// The implementation supports the C-Language Binding option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_C_BIND = libc::_SC_2_C_BIND,
     /// The implementation supports the C-Language Development Utilities option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_C_DEV = libc::_SC_2_C_DEV,
     /// The implementation supports the Terminal Characteristics option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_CHAR_TERM = libc::_SC_2_CHAR_TERM,
     /// The implementation supports the FORTRAN Development Utilities option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_FORT_DEV = libc::_SC_2_FORT_DEV,
     /// The implementation supports the FORTRAN Runtime Utilities option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_FORT_RUN = libc::_SC_2_FORT_RUN,
     /// The implementation supports the creation of locales by the localedef
     /// utility.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_LOCALEDEF = libc::_SC_2_LOCALEDEF,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Batch Environment Services and Utilities
     /// option.
     _POSIX2_PBS = libc::_SC_2_PBS,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Batch Accounting option.
     _POSIX2_PBS_ACCOUNTING = libc::_SC_2_PBS_ACCOUNTING,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Batch Checkpoint/Restart option.
     _POSIX2_PBS_CHECKPOINT = libc::_SC_2_PBS_CHECKPOINT,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Locate Batch Job Request option.
     _POSIX2_PBS_LOCATE = libc::_SC_2_PBS_LOCATE,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Batch Job Message Request option.
     _POSIX2_PBS_MESSAGE = libc::_SC_2_PBS_MESSAGE,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Track Batch Job Request option.
     _POSIX2_PBS_TRACK = libc::_SC_2_PBS_TRACK,
     /// The implementation supports the Software Development Utilities option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_SW_DEV = libc::_SC_2_SW_DEV,
     /// The implementation supports the User Portability Utilities option.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_UPE = libc::_SC_2_UPE,
     /// Integer value indicating version of the Shell and Utilities volume of
     /// POSIX.1 to which the implementation conforms.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _POSIX2_VERSION = libc::_SC_2_VERSION,
     /// The size of a system page in bytes.
     ///
     /// POSIX also defines an alias named `PAGESIZE`, but Rust does not allow two
     /// enum constants to have the same value, so nix omits `PAGESIZE`.
     PAGE_SIZE = libc::_SC_PAGE_SIZE,
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PTHREAD_DESTRUCTOR_ITERATIONS = libc::_SC_THREAD_DESTRUCTOR_ITERATIONS,
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PTHREAD_KEYS_MAX = libc::_SC_THREAD_KEYS_MAX,
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PTHREAD_STACK_MIN = libc::_SC_THREAD_STACK_MIN,
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     PTHREAD_THREADS_MAX = libc::_SC_THREAD_THREADS_MAX,
+    #[cfg(not(target_os = "haiku"))]
     RE_DUP_MAX = libc::_SC_RE_DUP_MAX,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     RTSIG_MAX = libc::_SC_RTSIG_MAX,
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SEM_NSEMS_MAX = libc::_SC_SEM_NSEMS_MAX,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SEM_VALUE_MAX = libc::_SC_SEM_VALUE_MAX,
     #[cfg(any(target_os = "android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os = "openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SIGQUEUE_MAX = libc::_SC_SIGQUEUE_MAX,
     STREAM_MAX = libc::_SC_STREAM_MAX,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="netbsd",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     SYMLOOP_MAX = libc::_SC_SYMLOOP_MAX,
     #[cfg(not(target_os = "redox"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     TIMER_MAX = libc::_SC_TIMER_MAX,
     TTY_NAME_MAX = libc::_SC_TTY_NAME_MAX,
     TZNAME_MAX = libc::_SC_TZNAME_MAX,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the X/Open Encryption Option Group.
     _XOPEN_CRYPT = libc::_SC_XOPEN_CRYPT,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the Issue 4, Version 2 Enhanced
     /// Internationalization Option Group.
     _XOPEN_ENH_I18N = libc::_SC_XOPEN_ENH_I18N,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _XOPEN_LEGACY = libc::_SC_XOPEN_LEGACY,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the X/Open Realtime Option Group.
     _XOPEN_REALTIME = libc::_SC_XOPEN_REALTIME,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the X/Open Realtime Threads Option Group.
     _XOPEN_REALTIME_THREADS = libc::_SC_XOPEN_REALTIME_THREADS,
     /// The implementation supports the Issue 4, Version 2 Shared Memory Option
     /// Group.
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     _XOPEN_SHM = libc::_SC_XOPEN_SHM,
     #[cfg(any(target_os="dragonfly", target_os="freebsd", target_os = "ios",
               target_os="linux", target_os = "macos", target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the XSI STREAMS Option Group.
     _XOPEN_STREAMS = libc::_SC_XOPEN_STREAMS,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// The implementation supports the XSI option
     _XOPEN_UNIX = libc::_SC_XOPEN_UNIX,
     #[cfg(any(target_os="android", target_os="dragonfly", target_os="freebsd",
               target_os = "ios", target_os="linux", target_os = "macos",
               target_os="openbsd"))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     /// Integer value indicating version of the X/Open Portability Guide to
     /// which the implementation conforms.
     _XOPEN_VERSION = libc::_SC_XOPEN_VERSION,
+    /// The number of pages of physical memory. Note that it is possible for
+    /// the product of this value to overflow.
+    #[cfg(any(target_os="android", target_os="linux"))]
+    _PHYS_PAGES = libc::_SC_PHYS_PAGES,
+    /// The number of currently available pages of physical memory.
+    #[cfg(any(target_os="android", target_os="linux"))]
+    _AVPHYS_PAGES = libc::_SC_AVPHYS_PAGES,
+    /// The number of processors configured.
+    #[cfg(any(target_os="android", target_os="linux"))]
+    _NPROCESSORS_CONF = libc::_SC_NPROCESSORS_CONF,
+    /// The number of processors currently online (available).
+    #[cfg(any(target_os="android", target_os="linux"))]
+    _NPROCESSORS_ONLN = libc::_SC_NPROCESSORS_ONLN,
 }
 
 /// Get configurable system variables (see
@@ -2472,6 +2737,10 @@ pub fn sysconf(var: SysconfVar) -> Result<Option<c_long>> {
         Ok(Some(raw))
     }
 }
+}
+
+feature! {
+#![feature = "fs"]
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod pivot_root {
@@ -2491,10 +2760,19 @@ mod pivot_root {
         Errno::result(res).map(drop)
     }
 }
+}
 
-#[cfg(any(target_os = "android", target_os = "freebsd",
-          target_os = "linux", target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 mod setres {
+    feature! {
+    #![feature = "user"]
+
     use crate::Result;
     use crate::errno::Errno;
     use super::{Uid, Gid};
@@ -2530,10 +2808,20 @@ mod setres {
 
         Errno::result(res).map(drop)
     }
+    }
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 mod getres {
+    feature! {
+    #![feature = "user"]
+
     use crate::Result;
     use crate::errno::Errno;
     use super::{Uid, Gid};
@@ -2591,10 +2879,13 @@ mod getres {
 
         Errno::result(res).map(|_| ResGid { real: Gid(rgid), effective: Gid(egid), saved: Gid(sgid) } )
     }
+    }
 }
 
-libc_bitflags!{
+#[cfg(feature = "fs")]
+libc_bitflags! {
     /// Options for access()
+    #[cfg_attr(docsrs, doc(cfg(feature = "fs")))]
     pub struct AccessFlags : c_int {
         /// Test for existence of file.
         F_OK;
@@ -2607,6 +2898,9 @@ libc_bitflags!{
     }
 }
 
+feature! {
+#![feature = "fs"]
+
 /// Checks the file named by `path` for accessibility according to the flags given by `amode`
 /// See [access(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html)
 pub fn access<P: ?Sized + NixPath>(path: &P, amode: AccessFlags) -> Result<()> {
@@ -2618,6 +2912,51 @@ pub fn access<P: ?Sized + NixPath>(path: &P, amode: AccessFlags) -> Result<()> {
     Errno::result(res).map(drop)
 }
 
+/// Checks the file named by `path` for accessibility according to the flags given by `mode`
+///
+/// If `dirfd` has a value, then `path` is relative to directory associated with the file descriptor.
+///
+/// If `dirfd` is `None`, then `path` is relative to the current working directory.
+///
+/// # References
+///
+/// [faccessat(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/faccessat.html)
+// redox: does not appear to support the *at family of syscalls.
+#[cfg(not(target_os = "redox"))]
+pub fn faccessat<P: ?Sized + NixPath>(dirfd: Option<RawFd>, path: &P, mode: AccessFlags, flags: AtFlags) -> Result<()> {
+    let res = path.with_nix_path(|cstr| {
+        unsafe {
+            libc::faccessat(at_rawfd(dirfd), cstr.as_ptr(), mode.bits(), flags.bits())
+        }
+    })?;
+    Errno::result(res).map(drop)
+}
+
+/// Checks the file named by `path` for accessibility according to the flags given
+/// by `mode` using effective UID, effective GID and supplementary group lists.
+///
+/// # References
+///
+/// * [FreeBSD man page](https://www.freebsd.org/cgi/man.cgi?query=eaccess&sektion=2&n=1)
+/// * [Linux man page](https://man7.org/linux/man-pages/man3/euidaccess.3.html)
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "freebsd",
+    target_os = "dragonfly"
+))]
+pub fn eaccess<P: ?Sized + NixPath>(path: &P, mode: AccessFlags) -> Result<()> {
+    let res = path.with_nix_path(|cstr| {
+        unsafe {
+            libc::eaccess(cstr.as_ptr(), mode.bits)
+        }
+    })?;
+    Errno::result(res).map(drop)
+}
+}
+
+feature! {
+#![feature = "user"]
+
 /// Representation of a User, based on `libc::passwd`
 ///
 /// The reason some fields in this struct are `String` and others are `CString` is because some
@@ -2625,11 +2964,11 @@ pub fn access<P: ?Sized + NixPath>(path: &P, amode: AccessFlags) -> Result<()> {
 /// guaranteed to conform to [`NAME_REGEX`](https://serverfault.com/a/73101/407341), which only
 /// contains ASCII.
 #[cfg(not(target_os = "redox"))] // RedoxFS does not support passwd
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct User {
     /// Username
     pub name: String,
-    /// User password (probably encrypted)
+    /// User password (probably hashed)
     pub passwd: CString,
     /// User ID
     pub uid: Uid,
@@ -2645,57 +2984,66 @@ pub struct User {
     /// Login class
     #[cfg(not(any(target_os = "android",
                   target_os = "fuchsia",
+                  target_os = "haiku",
                   target_os = "illumos",
                   target_os = "linux",
                   target_os = "solaris")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub class: CString,
     /// Last password change
     #[cfg(not(any(target_os = "android",
                   target_os = "fuchsia",
+                  target_os = "haiku",
                   target_os = "illumos",
                   target_os = "linux",
                   target_os = "solaris")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub change: libc::time_t,
     /// Expiration time of account
     #[cfg(not(any(target_os = "android",
                   target_os = "fuchsia",
+                  target_os = "haiku",
                   target_os = "illumos",
                   target_os = "linux",
                   target_os = "solaris")))]
+    #[cfg_attr(docsrs, doc(cfg(all())))]
     pub expire: libc::time_t
 }
 
-#[cfg(not(target_os = "redox"))] // RedoxFS does not support passwd
+#[cfg(not(target_os = "redox"))] //RedoxFS does not support passwd
 impl From<&libc::passwd> for User {
     fn from(pw: &libc::passwd) -> User {
         unsafe {
             User {
-                name: CStr::from_ptr((*pw).pw_name).to_string_lossy().into_owned(),
-                passwd: CString::new(CStr::from_ptr((*pw).pw_passwd).to_bytes()).unwrap(),
+                name: if pw.pw_name.is_null() { Default::default() } else { CStr::from_ptr(pw.pw_name).to_string_lossy().into_owned() },
+                passwd: if pw.pw_passwd.is_null() { Default::default() } else { CString::new(CStr::from_ptr(pw.pw_passwd).to_bytes()).unwrap() },
                 #[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
-                gecos: CString::new(CStr::from_ptr((*pw).pw_gecos).to_bytes()).unwrap(),
-                dir: PathBuf::from(OsStr::from_bytes(CStr::from_ptr((*pw).pw_dir).to_bytes())),
-                shell: PathBuf::from(OsStr::from_bytes(CStr::from_ptr((*pw).pw_shell).to_bytes())),
-                uid: Uid::from_raw((*pw).pw_uid),
-                gid: Gid::from_raw((*pw).pw_gid),
+                gecos: if pw.pw_gecos.is_null() { Default::default() } else { CString::new(CStr::from_ptr(pw.pw_gecos).to_bytes()).unwrap() },
+                dir: if pw.pw_dir.is_null() { Default::default() } else { PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_dir).to_bytes())) },
+                shell: if pw.pw_shell.is_null() { Default::default() } else { PathBuf::from(OsStr::from_bytes(CStr::from_ptr(pw.pw_shell).to_bytes())) },
+                uid: Uid::from_raw(pw.pw_uid),
+                gid: Gid::from_raw(pw.pw_gid),
                 #[cfg(not(any(target_os = "android",
                               target_os = "fuchsia",
+                              target_os = "haiku",
                               target_os = "illumos",
                               target_os = "linux",
                               target_os = "solaris")))]
-                class: CString::new(CStr::from_ptr((*pw).pw_class).to_bytes()).unwrap(),
+                class: CString::new(CStr::from_ptr(pw.pw_class).to_bytes()).unwrap(),
                 #[cfg(not(any(target_os = "android",
                               target_os = "fuchsia",
+                              target_os = "haiku",
                               target_os = "illumos",
                               target_os = "linux",
                               target_os = "solaris")))]
-                change: (*pw).pw_change,
+                change: pw.pw_change,
                 #[cfg(not(any(target_os = "android",
                               target_os = "fuchsia",
+                              target_os = "haiku",
                               target_os = "illumos",
                               target_os = "linux",
                               target_os = "solaris")))]
-                expire: (*pw).pw_expire
+                expire: pw.pw_expire
             }
         }
     }
@@ -2727,18 +3075,21 @@ impl From<User> for libc::passwd {
             pw_gid: u.gid.0,
             #[cfg(not(any(target_os = "android",
                           target_os = "fuchsia",
+                          target_os = "haiku",
                           target_os = "illumos",
                           target_os = "linux",
                           target_os = "solaris")))]
             pw_class: u.class.into_raw(),
             #[cfg(not(any(target_os = "android",
                           target_os = "fuchsia",
+                          target_os = "haiku",
                           target_os = "illumos",
                           target_os = "linux",
                           target_os = "solaris")))]
             pw_change: u.change,
             #[cfg(not(any(target_os = "android",
                           target_os = "fuchsia",
+                          target_os = "haiku",
                           target_os = "illumos",
                           target_os = "linux",
                           target_os = "solaris")))]
@@ -2758,7 +3109,7 @@ impl User {
     fn from_anything<F>(f: F) -> Result<Option<Self>>
     where
         F: Fn(*mut libc::passwd,
-              *mut libc::c_char,
+              *mut c_char,
               libc::size_t,
               *mut *mut libc::passwd) -> libc::c_int
     {
@@ -2801,7 +3152,7 @@ impl User {
     /// use nix::unistd::{Uid, User};
     /// // Returns an Result<Option<User>>, thus the double unwrap.
     /// let res = User::from_uid(Uid::from_raw(0)).unwrap().unwrap();
-    /// assert!(res.name == "root");
+    /// assert_eq!(res.name, "root");
     /// ```
     pub fn from_uid(uid: Uid) -> Result<Option<Self>> {
         User::from_anything(|pwd, cbuf, cap, res| {
@@ -2820,10 +3171,13 @@ impl User {
     /// use nix::unistd::User;
     /// // Returns an Result<Option<User>>, thus the double unwrap.
     /// let res = User::from_name("root").unwrap().unwrap();
-    /// assert!(res.name == "root");
+    /// assert_eq!(res.name, "root");
     /// ```
     pub fn from_name(name: &str) -> Result<Option<Self>> {
-        let name = CString::new(name).unwrap();
+        let name = match CString::new(name) {
+            Ok(c_str) => c_str,
+            Err(_nul_error) => return Ok(None),
+        };
         User::from_anything(|pwd, cbuf, cap, res| {
             unsafe { libc::getpwnam_r(name.as_ptr(), pwd, cbuf, cap, res) }
         })
@@ -2832,7 +3186,7 @@ impl User {
 
 /// Representation of a Group, based on `libc::group`
 #[cfg(not(target_os = "redox"))] // RedoxFS does not support passwd
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Group {
     /// Group name
     pub name: String,
@@ -2849,10 +3203,10 @@ impl From<&libc::group> for Group {
     fn from(gr: &libc::group) -> Group {
         unsafe {
             Group {
-                name: CStr::from_ptr((*gr).gr_name).to_string_lossy().into_owned(),
-                passwd: CString::new(CStr::from_ptr((*gr).gr_passwd).to_bytes()).unwrap(),
-                gid: Gid::from_raw((*gr).gr_gid),
-                mem: Group::members((*gr).gr_mem)
+                name: CStr::from_ptr(gr.gr_name).to_string_lossy().into_owned(),
+                passwd: CString::new(CStr::from_ptr(gr.gr_passwd).to_bytes()).unwrap(),
+                gid: Gid::from_raw(gr.gr_gid),
+                mem: Group::members(gr.gr_mem)
             }
         }
     }
@@ -2879,7 +3233,7 @@ impl Group {
     fn from_anything<F>(f: F) -> Result<Option<Self>>
     where
         F: Fn(*mut libc::group,
-              *mut libc::c_char,
+              *mut c_char,
               libc::size_t,
               *mut *mut libc::group) -> libc::c_int
     {
@@ -2948,12 +3302,19 @@ impl Group {
     /// assert!(res.name == "root");
     /// ```
     pub fn from_name(name: &str) -> Result<Option<Self>> {
-        let name = CString::new(name).unwrap();
+        let name = match CString::new(name) {
+            Ok(c_str) => c_str,
+            Err(_nul_error) => return Ok(None),
+        };
         Group::from_anything(|grp, cbuf, cap, res| {
             unsafe { libc::getgrnam_r(name.as_ptr(), grp, cbuf, cap, res) }
         })
     }
 }
+}
+
+feature! {
+#![feature = "term"]
 
 /// Get the name of the terminal device that is open on file descriptor fd
 /// (see [`ttyname(3)`](https://man7.org/linux/man-pages/man3/ttyname.3.html)).
@@ -2972,6 +3333,10 @@ pub fn ttyname(fd: RawFd) -> Result<PathBuf> {
     buf.truncate(nul);
     Ok(OsString::from_vec(buf).into())
 }
+}
+
+feature! {
+#![all(feature = "socket", feature = "user")]
 
 /// Get the effective user ID and group ID associated with a Unix domain socket.
 ///
@@ -2992,3 +3357,27 @@ pub fn getpeereid(fd: RawFd) -> Result<(Uid, Gid)> {
 
     Errno::result(ret).map(|_| (Uid(uid), Gid(gid)))
 }
+}
+
+feature! {
+#![all(feature = "fs")]
+
+/// Set the file flags.
+///
+/// See also [chflags(2)](https://www.freebsd.org/cgi/man.cgi?query=chflags&sektion=2)
+#[cfg(any(
+    target_os = "openbsd",
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "dragonfly",
+    target_os = "macos",
+    target_os = "ios"
+))]
+pub fn chflags<P: ?Sized + NixPath>(path: &P, flags: FileFlag) -> Result<()> {
+    let res = path.with_nix_path(|cstr| unsafe {
+        libc::chflags(cstr.as_ptr(), flags.bits())
+    })?;
+
+    Errno::result(res).map(drop)
+}
+}
diff --git a/test/common/mod.rs b/test/common/mod.rs
index 84a0b4f..bb056aa 100644
--- a/test/common/mod.rs
+++ b/test/common/mod.rs
@@ -1,6 +1,7 @@
 use cfg_if::cfg_if;
 
-#[macro_export] macro_rules! skip {
+#[macro_export]
+macro_rules! skip {
     ($($reason: expr),+) => {
         use ::std::io::{self, Write};
 
@@ -33,42 +34,49 @@ cfg_if! {
 
 /// Skip the test if we don't have the ability to mount file systems.
 #[cfg(target_os = "freebsd")]
-#[macro_export] macro_rules! require_mount {
+#[macro_export]
+macro_rules! require_mount {
     ($name:expr) => {
-        use ::sysctl::CtlValue;
+        use ::sysctl::{CtlValue, Sysctl};
         use nix::unistd::Uid;
 
-        if !Uid::current().is_root() && CtlValue::Int(0) == ::sysctl::value("vfs.usermount").unwrap()
+        let ctl = ::sysctl::Ctl::new("vfs.usermount").unwrap();
+        if !Uid::current().is_root() && CtlValue::Int(0) == ctl.value().unwrap()
         {
-            skip!("{} requires the ability to mount file systems. Skipping test.", $name);
+            skip!(
+                "{} requires the ability to mount file systems. Skipping test.",
+                $name
+            );
         }
-    }
+    };
 }
 
-#[cfg(any(target_os = "linux", target_os= "android"))]
-#[macro_export] macro_rules! skip_if_cirrus {
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[macro_export]
+macro_rules! skip_if_cirrus {
     ($reason:expr) => {
         if std::env::var_os("CIRRUS_CI").is_some() {
             skip!("{}", $reason);
         }
-    }
+    };
 }
 
 #[cfg(target_os = "freebsd")]
-#[macro_export] macro_rules! skip_if_jailed {
+#[macro_export]
+macro_rules! skip_if_jailed {
     ($name:expr) => {
-        use ::sysctl::CtlValue;
+        use ::sysctl::{CtlValue, Sysctl};
 
-        if let CtlValue::Int(1) = ::sysctl::value("security.jail.jailed")
-            .unwrap()
-        {
+        let ctl = ::sysctl::Ctl::new("security.jail.jailed").unwrap();
+        if let CtlValue::Int(1) = ctl.value().unwrap() {
             skip!("{} cannot run in a jail. Skipping test.", $name);
         }
-    }
+    };
 }
 
 #[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-#[macro_export] macro_rules! skip_if_not_root {
+#[macro_export]
+macro_rules! skip_if_not_root {
     ($name:expr) => {
         use nix::unistd::Uid;
 
@@ -111,15 +119,15 @@ cfg_if! {
                 let version_requirement = VersionReq::parse($version_requirement)
                         .expect("Bad match_version provided");
 
-                let uname = nix::sys::utsname::uname();
-                println!("{}", uname.sysname());
-                println!("{}", uname.nodename());
-                println!("{}", uname.release());
-                println!("{}", uname.version());
-                println!("{}", uname.machine());
+                let uname = nix::sys::utsname::uname().unwrap();
+                println!("{}", uname.sysname().to_str().unwrap());
+                println!("{}", uname.nodename().to_str().unwrap());
+                println!("{}", uname.release().to_str().unwrap());
+                println!("{}", uname.version().to_str().unwrap());
+                println!("{}", uname.machine().to_str().unwrap());
 
                 // Fix stuff that the semver parser can't handle
-                let fixed_release = &uname.release().to_string()
+                let fixed_release = &uname.release().to_str().unwrap().to_string()
                     // Fedora 33 reports version as 4.18.el8_2.x86_64 or
                     // 5.18.200-fc33.x86_64.  Remove the underscore.
                     .replace("_", "-")
diff --git a/test/sys/mod.rs b/test/sys/mod.rs
index e73d9b1..2031212 100644
--- a/test/sys/mod.rs
+++ b/test/sys/mod.rs
@@ -5,43 +5,56 @@ mod test_signal;
 // works or not heavily depends on which pthread implementation is chosen
 // by the user at link time. For this reason we do not want to run aio test
 // cases on DragonFly.
-#[cfg(any(target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd"))]
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "ios",
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "macos",
+    target_os = "netbsd"
+))]
 mod test_aio;
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
+mod test_ioctl;
 #[cfg(not(target_os = "redox"))]
 mod test_mman;
+#[cfg(not(target_os = "redox"))]
+mod test_select;
 #[cfg(target_os = "linux")]
 mod test_signalfd;
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 mod test_socket;
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox")))]
 mod test_sockopt;
-#[cfg(not(target_os = "redox"))]
-mod test_select;
+mod test_stat;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod test_sysinfo;
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 mod test_termios;
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-mod test_ioctl;
-mod test_wait;
 mod test_uio;
+mod test_wait;
 
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "android", target_os = "linux"))]
 mod test_epoll;
 #[cfg(target_os = "linux")]
 mod test_inotify;
 mod test_pthread;
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "linux",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 mod test_ptrace;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod test_timerfd;
diff --git a/test/sys/test_aio.rs b/test/sys/test_aio.rs
index 80cd053..84086f8 100644
--- a/test/sys/test_aio.rs
+++ b/test/sys/test_aio.rs
@@ -1,415 +1,516 @@
-use libc::{c_int, c_void};
-use nix::Result;
-use nix::errno::*;
-use nix::sys::aio::*;
-use nix::sys::signal::{SaFlags, SigAction, sigaction, SigevNotify, SigHandler, Signal, SigSet};
-use nix::sys::time::{TimeSpec, TimeValLike};
-use std::io::{Write, Read, Seek, SeekFrom};
-use std::ops::Deref;
-use std::os::unix::io::AsRawFd;
-use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::{thread, time};
+use std::{
+    io::{Read, Seek, Write},
+    ops::Deref,
+    os::unix::io::AsRawFd,
+    pin::Pin,
+    sync::atomic::{AtomicBool, Ordering},
+    thread, time,
+};
+
+use libc::c_int;
+use nix::{
+    errno::*,
+    sys::{
+        aio::*,
+        signal::{
+            sigaction, SaFlags, SigAction, SigHandler, SigSet, SigevNotify,
+            Signal,
+        },
+        time::{TimeSpec, TimeValLike},
+    },
+};
 use tempfile::tempfile;
 
-// Helper that polls an AioCb for completion or error
-fn poll_aio(aiocb: &mut Pin<Box<AioCb>>) -> Result<()> {
-    loop {
-        let err = aiocb.error();
-        if err != Err(Errno::EINPROGRESS) { return err; };
-        thread::sleep(time::Duration::from_millis(10));
-    }
+lazy_static! {
+    pub static ref SIGNALED: AtomicBool = AtomicBool::new(false);
 }
 
-// Helper that polls a component of an LioCb for completion or error
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-fn poll_lio(liocb: &mut LioCb, i: usize) -> Result<()> {
-    loop {
-        let err = liocb.error(i);
-        if err != Err(Errno::EINPROGRESS) { return err; };
-        thread::sleep(time::Duration::from_millis(10));
-    }
+extern "C" fn sigfunc(_: c_int) {
+    SIGNALED.store(true, Ordering::Relaxed);
 }
 
-#[test]
-fn test_accessors() {
-    let mut rbuf = vec![0; 4];
-    let aiocb = AioCb::from_mut_slice( 1001,
-                           2,   //offset
-                           &mut rbuf,
-                           42,   //priority
-                           SigevNotify::SigevSignal {
-                               signal: Signal::SIGUSR2,
-                               si_value: 99
-                           },
-                           LioOpcode::LIO_NOP);
-    assert_eq!(1001, aiocb.fd());
-    assert_eq!(Some(LioOpcode::LIO_NOP), aiocb.lio_opcode());
-    assert_eq!(4, aiocb.nbytes());
-    assert_eq!(2, aiocb.offset());
-    assert_eq!(42, aiocb.priority());
-    let sev = aiocb.sigevent().sigevent();
-    assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
-    assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+// Helper that polls an AioCb for completion or error
+macro_rules! poll_aio {
+    ($aiocb: expr) => {
+        loop {
+            let err = $aiocb.as_mut().error();
+            if err != Err(Errno::EINPROGRESS) {
+                break err;
+            };
+            thread::sleep(time::Duration::from_millis(10));
+        }
+    };
 }
 
-// Tests AioCb.cancel.  We aren't trying to test the OS's implementation, only
-// our bindings.  So it's sufficient to check that AioCb.cancel returned any
-// AioCancelStat value.
-#[test]
-#[cfg_attr(target_env = "musl", ignore)]
-fn test_cancel() {
-    let wbuf: &[u8] = b"CDEF";
-
-    let f = tempfile().unwrap();
-    let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-                            0,   //offset
-                            wbuf,
-                            0,   //priority
-                            SigevNotify::SigevNone,
-                            LioOpcode::LIO_NOP);
-    aiocb.write().unwrap();
-    let err = aiocb.error();
-    assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+mod aio_fsync {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let aiocb = AioFsync::new(
+            1001,
+            AioFsyncMode::O_SYNC,
+            42,
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(1001, aiocb.fd());
+        assert_eq!(AioFsyncMode::O_SYNC, aiocb.mode());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
 
-    let cancelstat = aiocb.cancel();
-    assert!(cancelstat.is_ok());
+    /// `AioFsync::submit` should not modify the `AioCb` object if
+    /// `libc::aio_fsync` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg(any(target_os = "freebsd", target_os = "macos"))]
+    fn error() {
+        use std::mem;
+
+        const INITIAL: &[u8] = b"abcdef123456";
+        // Create an invalid AioFsyncMode
+        let mode = unsafe { mem::transmute(666) };
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiof = Box::pin(AioFsync::new(
+            f.as_raw_fd(),
+            mode,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        let err = aiof.as_mut().submit();
+        err.expect_err("assertion failed");
+    }
 
-    // Wait for aiocb to complete, but don't care whether it succeeded
-    let _ = poll_aio(&mut aiocb);
-    let _ = aiocb.aio_return();
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let fd = f.as_raw_fd();
+        let mut aiof = Box::pin(AioFsync::new(
+            fd,
+            AioFsyncMode::O_SYNC,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiof.as_mut().submit().unwrap();
+        poll_aio!(&mut aiof).unwrap();
+        aiof.as_mut().aio_return().unwrap();
+    }
 }
 
-// Tests using aio_cancel_all for all outstanding IOs.
-#[test]
-#[cfg_attr(target_env = "musl", ignore)]
-fn test_aio_cancel_all() {
-    let wbuf: &[u8] = b"CDEF";
-
-    let f = tempfile().unwrap();
-    let mut aiocb = AioCb::from_slice(f.as_raw_fd(),
-                            0,   //offset
-                            wbuf,
-                            0,   //priority
-                            SigevNotify::SigevNone,
-                            LioOpcode::LIO_NOP);
-    aiocb.write().unwrap();
-    let err = aiocb.error();
-    assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
+mod aio_read {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let mut rbuf = vec![0; 4];
+        let aiocb = AioRead::new(
+            1001,
+            2, //offset
+            &mut rbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(1001, aiocb.fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
 
-    let cancelstat = aio_cancel_all(f.as_raw_fd());
-    assert!(cancelstat.is_ok());
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn cancel() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let fd = f.as_raw_fd();
+        let mut aior =
+            Box::pin(AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone));
+        aior.as_mut().submit().unwrap();
+
+        aior.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aior);
+        let _ = aior.as_mut().aio_return();
+    }
 
-    // Wait for aiocb to complete, but don't care whether it succeeded
-    let _ = poll_aio(&mut aiocb);
-    let _ = aiocb.aio_return();
-}
+    /// `AioRead::submit` should not modify the `AioCb` object if
+    /// `libc::aio_read` returns an error
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg(any(target_os = "freebsd", target_os = "macos"))]
+    fn error() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aior = Box::pin(AioRead::new(
+            f.as_raw_fd(),
+            -1, //an invalid offset
+            &mut rbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aior.as_mut().submit().expect_err("assertion failed");
+    }
 
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_fsync() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    let mut aiocb = AioCb::from_fd( f.as_raw_fd(),
-                            0,   //priority
-                            SigevNotify::SigevNone);
-    let err = aiocb.fsync(AioFsyncMode::O_SYNC);
-    assert!(err.is_ok());
-    poll_aio(&mut aiocb).unwrap();
-    aiocb.aio_return().unwrap();
-}
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_raw_fd();
+            let mut aior = Box::pin(AioRead::new(
+                fd,
+                2,
+                &mut rbuf,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
 
-/// `AioCb::fsync` should not modify the `AioCb` object if `libc::aio_fsync` returns
-/// an error
-// Skip on Linux, because Linux's AIO implementation can't detect errors
-// synchronously
-#[test]
-#[cfg(any(target_os = "freebsd", target_os = "macos"))]
-fn test_fsync_error() {
-    use std::mem;
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref().deref());
+    }
 
-    const INITIAL: &[u8] = b"abcdef123456";
-    // Create an invalid AioFsyncMode
-    let mode = unsafe { mem::transmute(666) };
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    let mut aiocb = AioCb::from_fd( f.as_raw_fd(),
-                            0,   //priority
-                            SigevNotify::SigevNone);
-    let err = aiocb.fsync(mode);
-    assert!(err.is_err());
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf = vec![0; 4];
+        const EXPECT: &[u8] = b"cdef";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        {
+            let fd = f.as_raw_fd();
+            let mut aior =
+                AioRead::new(fd, 2, &mut rbuf, 0, SigevNotify::SigevNone);
+            let mut aior = unsafe { Pin::new_unchecked(&mut aior) };
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(aior.as_mut().aio_return().unwrap(), EXPECT.len());
+        }
+        assert_eq!(EXPECT, rbuf.deref().deref());
+    }
 }
 
-#[test]
-// On Cirrus on Linux, this test fails due to a glibc bug.
-// https://github.com/nix-rust/nix/issues/1099
-#[cfg_attr(target_os = "linux", ignore)]
-// On Cirrus, aio_suspend is failing with EINVAL
-// https://github.com/nix-rust/nix/issues/1361
-#[cfg_attr(target_os = "macos", ignore)]
-fn test_aio_suspend() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    const WBUF: &[u8] = b"CDEFG";
-    let timeout = TimeSpec::seconds(10);
-    let mut rbuf = vec![0; 4];
-    let rlen = rbuf.len();
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_readv {
+    use std::io::IoSliceMut;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 8];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        let aiocb = AioReadv::new(
+            1001,
+            2, //offset
+            &mut rbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(1001, aiocb.fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
 
-    let mut wcb = AioCb::from_slice( f.as_raw_fd(),
-                           2,   //offset
-                           WBUF,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_WRITE);
-
-    let mut rcb = AioCb::from_mut_slice( f.as_raw_fd(),
-                            8,   //offset
-                            &mut rbuf,
-                            0,   //priority
-                            SigevNotify::SigevNone,
-                            LioOpcode::LIO_READ);
-    wcb.write().unwrap();
-    rcb.read().unwrap();
-    loop {
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let mut rbuf0 = vec![0; 4];
+        let mut rbuf1 = vec![0; 2];
+        let mut rbufs =
+            [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];
+        const EXPECT0: &[u8] = b"cdef";
+        const EXPECT1: &[u8] = b"12";
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
         {
-            let cbbuf = [wcb.as_ref(), rcb.as_ref()];
-            let r = aio_suspend(&cbbuf[..], Some(timeout));
-            match r {
-                Err(Errno::EINTR) => continue,
-                Err(e) => panic!("aio_suspend returned {:?}", e),
-                Ok(_) => ()
-            };
-        }
-        if rcb.error() != Err(Errno::EINPROGRESS) &&
-           wcb.error() != Err(Errno::EINPROGRESS) {
-            break
+            let fd = f.as_raw_fd();
+            let mut aior = Box::pin(AioReadv::new(
+                fd,
+                2,
+                &mut rbufs,
+                0,
+                SigevNotify::SigevNone,
+            ));
+            aior.as_mut().submit().unwrap();
+
+            let err = poll_aio!(&mut aior);
+            assert_eq!(err, Ok(()));
+            assert_eq!(
+                aior.as_mut().aio_return().unwrap(),
+                EXPECT0.len() + EXPECT1.len()
+            );
         }
+        assert_eq!(&EXPECT0, &rbuf0);
+        assert_eq!(&EXPECT1, &rbuf1);
     }
-
-    assert_eq!(wcb.aio_return().unwrap() as usize, WBUF.len());
-    assert_eq!(rcb.aio_return().unwrap() as usize, rlen);
 }
 
-// Test a simple aio operation with no completion notification.  We must poll
-// for completion
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_read() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let mut rbuf = vec![0; 4];
-    const EXPECT: &[u8] = b"cdef";
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    {
-        let mut aiocb = AioCb::from_mut_slice( f.as_raw_fd(),
-                               2,   //offset
-                               &mut rbuf,
-                               0,   //priority
-                               SigevNotify::SigevNone,
-                               LioOpcode::LIO_NOP);
-        aiocb.read().unwrap();
-
-        let err = poll_aio(&mut aiocb);
-        assert_eq!(err, Ok(()));
-        assert_eq!(aiocb.aio_return().unwrap() as usize, EXPECT.len());
+mod aio_write {
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let wbuf = vec![0; 4];
+        let aiocb = AioWrite::new(
+            1001,
+            2, //offset
+            &wbuf,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(1001, aiocb.fd());
+        assert_eq!(4, aiocb.nbytes());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
     }
 
-    assert_eq!(EXPECT, rbuf.deref().deref());
-}
+    // Tests AioWrite.cancel.  We aren't trying to test the OS's implementation,
+    // only our bindings.  So it's sufficient to check that cancel
+    // returned any AioCancelStat value.
+    #[test]
+    #[cfg_attr(target_env = "musl", ignore)]
+    fn cancel() {
+        let wbuf: &[u8] = b"CDEF";
 
-/// `AioCb::read` should not modify the `AioCb` object if `libc::aio_read`
-/// returns an error
-// Skip on Linux, because Linux's AIO implementation can't detect errors
-// synchronously
-#[test]
-#[cfg(any(target_os = "freebsd", target_os = "macos"))]
-fn test_read_error() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let mut rbuf = vec![0; 4];
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    let mut aiocb = AioCb::from_mut_slice( f.as_raw_fd(),
-                           -1,   //an invalid offset
-                           &mut rbuf,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_NOP);
-    assert!(aiocb.read().is_err());
-}
+        let f = tempfile().unwrap();
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_raw_fd(),
+            0,
+            wbuf,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().unwrap();
+        let err = aiow.as_mut().error();
+        assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
 
-// Tests from_mut_slice
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_read_into_mut_slice() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let mut rbuf = vec![0; 4];
-    const EXPECT: &[u8] = b"cdef";
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    {
-        let mut aiocb = AioCb::from_mut_slice( f.as_raw_fd(),
-                               2,   //offset
-                               &mut rbuf,
-                               0,   //priority
-                               SigevNotify::SigevNone,
-                               LioOpcode::LIO_NOP);
-        aiocb.read().unwrap();
-
-        let err = poll_aio(&mut aiocb);
-        assert_eq!(err, Ok(()));
-        assert_eq!(aiocb.aio_return().unwrap() as usize, EXPECT.len());
+        aiow.as_mut().cancel().unwrap();
+
+        // Wait for aiow to complete, but don't care whether it succeeded
+        let _ = poll_aio!(&mut aiow);
+        let _ = aiow.as_mut().aio_return();
     }
 
-    assert_eq!(rbuf, EXPECT);
-}
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiow = Box::pin(AioWrite::new(
+            f.as_raw_fd(),
+            2,
+            &wbuf,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().unwrap();
 
-// Tests from_ptr
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_read_into_pointer() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let mut rbuf = vec![0; 4];
-    const EXPECT: &[u8] = b"cdef";
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    {
-        // Safety: ok because rbuf lives until after poll_aio
-        let mut aiocb = unsafe {
-            AioCb::from_mut_ptr( f.as_raw_fd(),
-                                 2,   //offset
-                                 rbuf.as_mut_ptr() as *mut c_void,
-                                 rbuf.len(),
-                                 0,   //priority
-                                 SigevNotify::SigevNone,
-                                 LioOpcode::LIO_NOP)
-        };
-        aiocb.read().unwrap();
-
-        let err = poll_aio(&mut aiocb);
+        let err = poll_aio!(&mut aiow);
         assert_eq!(err, Ok(()));
-        assert_eq!(aiocb.aio_return().unwrap() as usize, EXPECT.len());
-    }
+        assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
 
-    assert_eq!(rbuf, EXPECT);
-}
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
 
-// Test reading into an immutable buffer.  It should fail
-// FIXME: This test fails to panic on Linux/musl
-#[test]
-#[should_panic(expected = "Can't read into an immutable buffer")]
-#[cfg_attr(target_env = "musl", ignore)]
-fn test_read_immutable_buffer() {
-    let rbuf: &[u8] = b"CDEF";
-    let f = tempfile().unwrap();
-    let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-                           2,   //offset
-                           rbuf,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_NOP);
-    aiocb.read().unwrap();
-}
+    // Like ok, but allocates the structure on the stack.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn on_stack() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"abCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiow = AioWrite::new(
+            f.as_raw_fd(),
+            2, //offset
+            &wbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        );
+        let mut aiow = unsafe { Pin::new_unchecked(&mut aiow) };
+        aiow.as_mut().submit().unwrap();
 
+        let err = poll_aio!(&mut aiow);
+        assert_eq!(err, Ok(()));
+        assert_eq!(aiow.as_mut().aio_return().unwrap(), wbuf.len());
 
-// Test a simple aio operation with no completion notification.  We must poll
-// for completion.  Unlike test_aio_read, this test uses AioCb::from_slice
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_write() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let wbuf = "CDEF".to_string().into_bytes();
-    let mut rbuf = Vec::new();
-    const EXPECT: &[u8] = b"abCDEF123456";
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
 
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-                           2,   //offset
-                           &wbuf,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_NOP);
-    aiocb.write().unwrap();
-
-    let err = poll_aio(&mut aiocb);
-    assert_eq!(err, Ok(()));
-    assert_eq!(aiocb.aio_return().unwrap() as usize, wbuf.len());
-
-    f.seek(SeekFrom::Start(0)).unwrap();
-    let len = f.read_to_end(&mut rbuf).unwrap();
-    assert_eq!(len, EXPECT.len());
-    assert_eq!(rbuf, EXPECT);
+    /// `AioWrite::write` should not modify the `AioCb` object if
+    /// `libc::aio_write` returns an error.
+    // Skip on Linux, because Linux's AIO implementation can't detect errors
+    // synchronously
+    #[test]
+    #[cfg(any(target_os = "freebsd", target_os = "macos"))]
+    fn error() {
+        let wbuf = "CDEF".to_string().into_bytes();
+        let mut aiow = Box::pin(AioWrite::new(
+            666, // An invalid file descriptor
+            0,   //offset
+            &wbuf,
+            0, //priority
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().expect_err("assertion failed");
+        // Dropping the AioWrite at this point should not panic
+    }
 }
 
-// Tests `AioCb::from_ptr`
-#[test]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_write_from_pointer() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    let wbuf = "CDEF".to_string().into_bytes();
-    let mut rbuf = Vec::new();
-    const EXPECT: &[u8] = b"abCDEF123456";
-
-    let mut f = tempfile().unwrap();
-    f.write_all(INITIAL).unwrap();
-    // Safety: ok because aiocb outlives poll_aio
-    let mut aiocb = unsafe {
-        AioCb::from_ptr( f.as_raw_fd(),
-                         2,   //offset
-                         wbuf.as_ptr() as *const c_void,
-                         wbuf.len(),
-                         0,   //priority
-                         SigevNotify::SigevNone,
-                         LioOpcode::LIO_NOP)
-    };
-    aiocb.write().unwrap();
-
-    let err = poll_aio(&mut aiocb);
-    assert_eq!(err, Ok(()));
-    assert_eq!(aiocb.aio_return().unwrap() as usize, wbuf.len());
-
-    f.seek(SeekFrom::Start(0)).unwrap();
-    let len = f.read_to_end(&mut rbuf).unwrap();
-    assert_eq!(len, EXPECT.len());
-    assert_eq!(rbuf, EXPECT);
-}
+#[cfg(target_os = "freebsd")]
+#[cfg(fbsd14)]
+mod aio_writev {
+    use std::io::IoSlice;
+
+    use super::*;
+
+    #[test]
+    fn test_accessors() {
+        let wbuf0 = vec![0; 4];
+        let wbuf1 = vec![0; 8];
+        let wbufs = [IoSlice::new(&wbuf0), IoSlice::new(&wbuf1)];
+        let aiocb = AioWritev::new(
+            1001,
+            2, //offset
+            &wbufs,
+            42, //priority
+            SigevNotify::SigevSignal {
+                signal: Signal::SIGUSR2,
+                si_value: 99,
+            },
+        );
+        assert_eq!(1001, aiocb.fd());
+        assert_eq!(2, aiocb.iovlen());
+        assert_eq!(2, aiocb.offset());
+        assert_eq!(42, aiocb.priority());
+        let sev = aiocb.sigevent().sigevent();
+        assert_eq!(Signal::SIGUSR2 as i32, sev.sigev_signo);
+        assert_eq!(99, sev.sigev_value.sival_ptr as i64);
+    }
 
-/// `AioCb::write` should not modify the `AioCb` object if `libc::aio_write`
-/// returns an error
-// Skip on Linux, because Linux's AIO implementation can't detect errors
-// synchronously
-#[test]
-#[cfg(any(target_os = "freebsd", target_os = "macos"))]
-fn test_write_error() {
-    let wbuf = "CDEF".to_string().into_bytes();
-    let mut aiocb = AioCb::from_slice( 666, // An invalid file descriptor
-                           0,   //offset
-                           &wbuf,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_NOP);
-    assert!(aiocb.write().is_err());
-}
+    // Test a simple aio operation with no completion notification.  We must
+    // poll for completion.
+    #[test]
+    #[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
+    fn ok() {
+        const INITIAL: &[u8] = b"abcdef123456";
+        let wbuf0 = b"BC";
+        let wbuf1 = b"DEF";
+        let wbufs = [IoSlice::new(wbuf0), IoSlice::new(wbuf1)];
+        let wlen = wbuf0.len() + wbuf1.len();
+        let mut rbuf = Vec::new();
+        const EXPECT: &[u8] = b"aBCDEF123456";
+
+        let mut f = tempfile().unwrap();
+        f.write_all(INITIAL).unwrap();
+        let mut aiow = Box::pin(AioWritev::new(
+            f.as_raw_fd(),
+            1,
+            &wbufs,
+            0,
+            SigevNotify::SigevNone,
+        ));
+        aiow.as_mut().submit().unwrap();
 
-lazy_static! {
-    pub static ref SIGNALED: AtomicBool = AtomicBool::new(false);
-}
+        let err = poll_aio!(&mut aiow);
+        assert_eq!(err, Ok(()));
+        assert_eq!(aiow.as_mut().aio_return().unwrap(), wlen);
 
-extern fn sigfunc(_: c_int) {
-    SIGNALED.store(true, Ordering::Relaxed);
+        f.rewind().unwrap();
+        let len = f.read_to_end(&mut rbuf).unwrap();
+        assert_eq!(len, EXPECT.len());
+        assert_eq!(rbuf, EXPECT);
+    }
 }
 
 // Test an aio operation with completion delivered by a signal
-// FIXME: This test is ignored on mips because of failures in qemu in CI
 #[test]
-#[cfg_attr(any(all(target_env = "musl", target_arch = "x86_64"), target_arch = "mips", target_arch = "mips64"), ignore)]
-fn test_write_sigev_signal() {
+#[cfg_attr(
+    any(
+        all(target_env = "musl", target_arch = "x86_64"),
+        target_arch = "mips",
+        target_arch = "mips64"
+    ),
+    ignore
+)]
+fn sigev_signal() {
     let _m = crate::SIGNAL_MTX.lock();
-    let sa = SigAction::new(SigHandler::Handler(sigfunc),
-                            SaFlags::SA_RESETHAND,
-                            SigSet::empty());
+    let sa = SigAction::new(
+        SigHandler::Handler(sigfunc),
+        SaFlags::SA_RESETHAND,
+        SigSet::empty(),
+    );
     SIGNALED.store(false, Ordering::Relaxed);
     unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();
 
@@ -420,201 +521,106 @@ fn test_write_sigev_signal() {
 
     let mut f = tempfile().unwrap();
     f.write_all(INITIAL).unwrap();
-    let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-                           2,   //offset
-                           WBUF,
-                           0,   //priority
-                           SigevNotify::SigevSignal {
-                               signal: Signal::SIGUSR2,
-                               si_value: 0  //TODO: validate in sigfunc
-                           },
-                           LioOpcode::LIO_NOP);
-    aiocb.write().unwrap();
+    let mut aiow = Box::pin(AioWrite::new(
+        f.as_raw_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevSignal {
+            signal: Signal::SIGUSR2,
+            si_value: 0, //TODO: validate in sigfunc
+        },
+    ));
+    aiow.as_mut().submit().unwrap();
     while !SIGNALED.load(Ordering::Relaxed) {
         thread::sleep(time::Duration::from_millis(10));
     }
 
-    assert_eq!(aiocb.aio_return().unwrap() as usize, WBUF.len());
-    f.seek(SeekFrom::Start(0)).unwrap();
+    assert_eq!(aiow.as_mut().aio_return().unwrap(), WBUF.len());
+    f.rewind().unwrap();
     let len = f.read_to_end(&mut rbuf).unwrap();
     assert_eq!(len, EXPECT.len());
     assert_eq!(rbuf, EXPECT);
 }
 
-// Test LioCb::listio with LIO_WAIT, so all AIO ops should be complete by the
-// time listio returns.
-#[test]
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_liocb_listio_wait() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    const WBUF: &[u8] = b"CDEF";
-    let mut rbuf = vec![0; 4];
-    let rlen = rbuf.len();
-    let mut rbuf2 = Vec::new();
-    const EXPECT: &[u8] = b"abCDEF123456";
-    let mut f = tempfile().unwrap();
-
-    f.write_all(INITIAL).unwrap();
-
-    {
-        let mut liocb = LioCbBuilder::with_capacity(2)
-            .emplace_slice(
-                f.as_raw_fd(),
-                2,   //offset
-                WBUF,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_WRITE
-            ).emplace_mut_slice(
-                f.as_raw_fd(),
-                8,   //offset
-                &mut rbuf,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_READ
-            ).finish();
-        let err = liocb.listio(LioMode::LIO_WAIT, SigevNotify::SigevNone);
-        err.expect("lio_listio");
-
-        assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());
-        assert_eq!(liocb.aio_return(1).unwrap() as usize, rlen);
-    }
-    assert_eq!(rbuf.deref().deref(), b"3456");
-
-    f.seek(SeekFrom::Start(0)).unwrap();
-    let len = f.read_to_end(&mut rbuf2).unwrap();
-    assert_eq!(len, EXPECT.len());
-    assert_eq!(rbuf2, EXPECT);
-}
-
-// Test LioCb::listio with LIO_NOWAIT and no SigEvent, so we must use some other
-// mechanism to check for the individual AioCb's completion.
+// Tests using aio_cancel_all for all outstanding IOs.
 #[test]
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[cfg_attr(all(target_env = "musl", target_arch = "x86_64"), ignore)]
-fn test_liocb_listio_nowait() {
-    const INITIAL: &[u8] = b"abcdef123456";
-    const WBUF: &[u8] = b"CDEF";
-    let mut rbuf = vec![0; 4];
-    let rlen = rbuf.len();
-    let mut rbuf2 = Vec::new();
-    const EXPECT: &[u8] = b"abCDEF123456";
-    let mut f = tempfile().unwrap();
+#[cfg_attr(target_env = "musl", ignore)]
+fn test_aio_cancel_all() {
+    let wbuf: &[u8] = b"CDEF";
 
-    f.write_all(INITIAL).unwrap();
+    let f = tempfile().unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_raw_fd(),
+        0, //offset
+        wbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
+    let err = aiocb.as_mut().error();
+    assert!(err == Ok(()) || err == Err(Errno::EINPROGRESS));
 
-    {
-        let mut liocb = LioCbBuilder::with_capacity(2)
-            .emplace_slice(
-                f.as_raw_fd(),
-                2,   //offset
-                WBUF,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_WRITE
-            ).emplace_mut_slice(
-                f.as_raw_fd(),
-                8,   //offset
-                &mut rbuf,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_READ
-            ).finish();
-        let err = liocb.listio(LioMode::LIO_NOWAIT, SigevNotify::SigevNone);
-        err.expect("lio_listio");
-
-        poll_lio(&mut liocb, 0).unwrap();
-        poll_lio(&mut liocb, 1).unwrap();
-        assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());
-        assert_eq!(liocb.aio_return(1).unwrap() as usize, rlen);
-    }
-    assert_eq!(rbuf.deref().deref(), b"3456");
+    aio_cancel_all(f.as_raw_fd()).unwrap();
 
-    f.seek(SeekFrom::Start(0)).unwrap();
-    let len = f.read_to_end(&mut rbuf2).unwrap();
-    assert_eq!(len, EXPECT.len());
-    assert_eq!(rbuf2, EXPECT);
+    // Wait for aiocb to complete, but don't care whether it succeeded
+    let _ = poll_aio!(&mut aiocb);
+    let _ = aiocb.as_mut().aio_return();
 }
 
-// Test LioCb::listio with LIO_NOWAIT and a SigEvent to indicate when all
-// AioCb's are complete.
-// FIXME: This test is ignored on mips/mips64 because of failures in qemu in CI.
 #[test]
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[cfg_attr(any(target_arch = "mips", target_arch = "mips64", target_env = "musl"), ignore)]
-fn test_liocb_listio_signal() {
-    let _m = crate::SIGNAL_MTX.lock();
+// On Cirrus on Linux, this test fails due to a glibc bug.
+// https://github.com/nix-rust/nix/issues/1099
+#[cfg_attr(target_os = "linux", ignore)]
+// On Cirrus, aio_suspend is failing with EINVAL
+// https://github.com/nix-rust/nix/issues/1361
+#[cfg_attr(target_os = "macos", ignore)]
+fn test_aio_suspend() {
     const INITIAL: &[u8] = b"abcdef123456";
-    const WBUF: &[u8] = b"CDEF";
+    const WBUF: &[u8] = b"CDEFG";
+    let timeout = TimeSpec::seconds(10);
     let mut rbuf = vec![0; 4];
     let rlen = rbuf.len();
-    let mut rbuf2 = Vec::new();
-    const EXPECT: &[u8] = b"abCDEF123456";
     let mut f = tempfile().unwrap();
-    let sa = SigAction::new(SigHandler::Handler(sigfunc),
-                            SaFlags::SA_RESETHAND,
-                            SigSet::empty());
-    let sigev_notify = SigevNotify::SigevSignal { signal: Signal::SIGUSR2,
-                                                  si_value: 0 };
-
     f.write_all(INITIAL).unwrap();
 
-    {
-        let mut liocb = LioCbBuilder::with_capacity(2)
-            .emplace_slice(
-                f.as_raw_fd(),
-                2,   //offset
-                WBUF,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_WRITE
-            ).emplace_mut_slice(
-                f.as_raw_fd(),
-                8,   //offset
-                &mut rbuf,
-                0,   //priority
-                SigevNotify::SigevNone,
-                LioOpcode::LIO_READ
-            ).finish();
-        SIGNALED.store(false, Ordering::Relaxed);
-        unsafe { sigaction(Signal::SIGUSR2, &sa) }.unwrap();
-        let err = liocb.listio(LioMode::LIO_NOWAIT, sigev_notify);
-        err.expect("lio_listio");
-        while !SIGNALED.load(Ordering::Relaxed) {
-            thread::sleep(time::Duration::from_millis(10));
+    let mut wcb = Box::pin(AioWrite::new(
+        f.as_raw_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+
+    let mut rcb = Box::pin(AioRead::new(
+        f.as_raw_fd(),
+        8, //offset
+        &mut rbuf,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    wcb.as_mut().submit().unwrap();
+    rcb.as_mut().submit().unwrap();
+    loop {
+        {
+            let cbbuf = [
+                &*wcb as &dyn AsRef<libc::aiocb>,
+                &*rcb as &dyn AsRef<libc::aiocb>,
+            ];
+            let r = aio_suspend(&cbbuf[..], Some(timeout));
+            match r {
+                Err(Errno::EINTR) => continue,
+                Err(e) => panic!("aio_suspend returned {:?}", e),
+                Ok(_) => (),
+            };
+        }
+        if rcb.as_mut().error() != Err(Errno::EINPROGRESS)
+            && wcb.as_mut().error() != Err(Errno::EINPROGRESS)
+        {
+            break;
         }
-
-        assert_eq!(liocb.aio_return(0).unwrap() as usize, WBUF.len());
-        assert_eq!(liocb.aio_return(1).unwrap() as usize, rlen);
     }
-    assert_eq!(rbuf.deref().deref(), b"3456");
-
-    f.seek(SeekFrom::Start(0)).unwrap();
-    let len = f.read_to_end(&mut rbuf2).unwrap();
-    assert_eq!(len, EXPECT.len());
-    assert_eq!(rbuf2, EXPECT);
-}
 
-// Try to use LioCb::listio to read into an immutable buffer.  It should fail
-// FIXME: This test fails to panic on Linux/musl
-#[test]
-#[cfg(not(any(target_os = "ios", target_os = "macos")))]
-#[should_panic(expected = "Can't read into an immutable buffer")]
-#[cfg_attr(target_env = "musl", ignore)]
-fn test_liocb_listio_read_immutable() {
-    let rbuf: &[u8] = b"abcd";
-    let f = tempfile().unwrap();
-
-
-    let mut liocb = LioCbBuilder::with_capacity(1)
-        .emplace_slice(
-            f.as_raw_fd(),
-            2,   //offset
-            rbuf,
-            0,   //priority
-            SigevNotify::SigevNone,
-            LioOpcode::LIO_READ
-        ).finish();
-    let _ = liocb.listio(LioMode::LIO_NOWAIT, SigevNotify::SigevNone);
+    assert_eq!(wcb.as_mut().aio_return().unwrap(), WBUF.len());
+    assert_eq!(rcb.as_mut().aio_return().unwrap(), rlen);
 }
diff --git a/test/sys/test_aio_drop.rs b/test/sys/test_aio_drop.rs
index 71a2183..bbe6623 100644
--- a/test/sys/test_aio_drop.rs
+++ b/test/sys/test_aio_drop.rs
@@ -3,12 +3,17 @@
 // the AIO subsystem and causes subsequent tests to fail
 #[test]
 #[should_panic(expected = "Dropped an in-progress AioCb")]
-#[cfg(all(not(target_env = "musl"),
-          any(target_os = "linux",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "freebsd",
-              target_os = "netbsd")))]
+#[cfg(all(
+    not(target_env = "musl"),
+    not(target_env = "uclibc"),
+    any(
+        target_os = "linux",
+        target_os = "ios",
+        target_os = "macos",
+        target_os = "freebsd",
+        target_os = "netbsd"
+    )
+))]
 fn test_drop() {
     use nix::sys::aio::*;
     use nix::sys::signal::*;
@@ -19,11 +24,12 @@ fn test_drop() {
 
     let f = tempfile().unwrap();
     f.set_len(6).unwrap();
-    let mut aiocb = AioCb::from_slice( f.as_raw_fd(),
-                           2,   //offset
-                           WBUF,
-                           0,   //priority
-                           SigevNotify::SigevNone,
-                           LioOpcode::LIO_NOP);
-    aiocb.write().unwrap();
+    let mut aiocb = Box::pin(AioWrite::new(
+        f.as_raw_fd(),
+        2, //offset
+        WBUF,
+        0, //priority
+        SigevNotify::SigevNone,
+    ));
+    aiocb.as_mut().submit().unwrap();
 }
diff --git a/test/sys/test_epoll.rs b/test/sys/test_epoll.rs
index 8d44cd0..9156915 100644
--- a/test/sys/test_epoll.rs
+++ b/test/sys/test_epoll.rs
@@ -1,23 +1,24 @@
-use nix::sys::epoll::{EpollCreateFlags, EpollFlags, EpollOp, EpollEvent};
-use nix::sys::epoll::{epoll_create1, epoll_ctl};
 use nix::errno::Errno;
+use nix::sys::epoll::{epoll_create1, epoll_ctl};
+use nix::sys::epoll::{EpollCreateFlags, EpollEvent, EpollFlags, EpollOp};
 
 #[test]
 pub fn test_epoll_errno() {
     let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
     let result = epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None);
-    assert!(result.is_err());
+    result.expect_err("assertion failed");
     assert_eq!(result.unwrap_err(), Errno::ENOENT);
 
     let result = epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, None);
-    assert!(result.is_err());
+    result.expect_err("assertion failed");
     assert_eq!(result.unwrap_err(), Errno::EINVAL);
 }
 
 #[test]
 pub fn test_epoll_ctl() {
     let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
-    let mut event = EpollEvent::new(EpollFlags::EPOLLIN | EpollFlags::EPOLLERR, 1);
+    let mut event =
+        EpollEvent::new(EpollFlags::EPOLLIN | EpollFlags::EPOLLERR, 1);
     epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, &mut event).unwrap();
     epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None).unwrap();
 }
diff --git a/test/sys/test_inotify.rs b/test/sys/test_inotify.rs
index 137816a..bb5851a 100644
--- a/test/sys/test_inotify.rs
+++ b/test/sys/test_inotify.rs
@@ -1,15 +1,16 @@
-use nix::sys::inotify::{AddWatchFlags,InitFlags,Inotify};
 use nix::errno::Errno;
+use nix::sys::inotify::{AddWatchFlags, InitFlags, Inotify};
 use std::ffi::OsString;
 use std::fs::{rename, File};
 
 #[test]
 pub fn test_inotify() {
-    let instance = Inotify::init(InitFlags::IN_NONBLOCK)
-        .unwrap();
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
     let tempdir = tempfile::tempdir().unwrap();
 
-    instance.add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS).unwrap();
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
 
     let events = instance.read_events();
     assert_eq!(events.unwrap_err(), Errno::EAGAIN);
@@ -22,11 +23,12 @@ pub fn test_inotify() {
 
 #[test]
 pub fn test_inotify_multi_events() {
-    let instance = Inotify::init(InitFlags::IN_NONBLOCK)
-        .unwrap();
+    let instance = Inotify::init(InitFlags::IN_NONBLOCK).unwrap();
     let tempdir = tempfile::tempdir().unwrap();
 
-    instance.add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS).unwrap();
+    instance
+        .add_watch(tempdir.path(), AddWatchFlags::IN_ALL_EVENTS)
+        .unwrap();
 
     let events = instance.read_events();
     assert_eq!(events.unwrap_err(), Errno::EAGAIN);
diff --git a/test/sys/test_ioctl.rs b/test/sys/test_ioctl.rs
index 236d242..40f60cf 100644
--- a/test/sys/test_ioctl.rs
+++ b/test/sys/test_ioctl.rs
@@ -30,9 +30,16 @@ ioctl_readwrite_buf!(readwritebuf_test, 0, 0, u32);
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux {
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_none() {
-        if cfg!(any(target_arch = "mips", target_arch = "mips64", target_arch="powerpc", target_arch="powerpc64")){
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
             assert_eq!(request_code_none!(b'q', 10) as u32, 0x2000_710A);
             assert_eq!(request_code_none!(b'a', 255) as u32, 0x2000_61FF);
         } else {
@@ -41,9 +48,16 @@ mod linux {
         }
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_write() {
-        if cfg!(any(target_arch = "mips", target_arch = "mips64", target_arch="powerpc", target_arch="powerpc64")){
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
             assert_eq!(request_code_write!(b'z', 10, 1) as u32, 0x8001_7A0A);
             assert_eq!(request_code_write!(b'z', 10, 512) as u32, 0x8200_7A0A);
         } else {
@@ -55,19 +69,29 @@ mod linux {
     #[cfg(target_pointer_width = "64")]
     #[test]
     fn test_op_write_64() {
-        if cfg!(any(target_arch = "mips64", target_arch="powerpc64")){
-            assert_eq!(request_code_write!(b'z', 10, 1u64 << 32) as u32,
-                       0x8000_7A0A);
+        if cfg!(any(target_arch = "mips64", target_arch = "powerpc64")) {
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
         } else {
-            assert_eq!(request_code_write!(b'z', 10, 1u64 << 32) as u32,
-                       0x4000_7A0A);
+            assert_eq!(
+                request_code_write!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
         }
-
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_read() {
-        if cfg!(any(target_arch = "mips", target_arch = "mips64", target_arch="powerpc", target_arch="powerpc64")){
+        if cfg!(any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc",
+            target_arch = "powerpc64"
+        )) {
             assert_eq!(request_code_read!(b'z', 10, 1) as u32, 0x4001_7A0A);
             assert_eq!(request_code_read!(b'z', 10, 512) as u32, 0x4200_7A0A);
         } else {
@@ -79,15 +103,21 @@ mod linux {
     #[cfg(target_pointer_width = "64")]
     #[test]
     fn test_op_read_64() {
-        if cfg!(any(target_arch = "mips64", target_arch="powerpc64")){
-            assert_eq!(request_code_read!(b'z', 10, 1u64 << 32) as u32,
-                       0x4000_7A0A);
+        if cfg!(any(target_arch = "mips64", target_arch = "powerpc64")) {
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x4000_7A0A
+            );
         } else {
-            assert_eq!(request_code_read!(b'z', 10, 1u64 << 32) as u32,
-                       0x8000_7A0A);
+            assert_eq!(
+                request_code_read!(b'z', 10, 1u64 << 32) as u32,
+                0x8000_7A0A
+            );
         }
     }
 
+    // The cast is not unnecessary on all platforms.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_op_read_write() {
         assert_eq!(request_code_readwrite!(b'z', 10, 1) as u32, 0xC001_7A0A);
@@ -97,17 +127,21 @@ mod linux {
     #[cfg(target_pointer_width = "64")]
     #[test]
     fn test_op_read_write_64() {
-        assert_eq!(request_code_readwrite!(b'z', 10, 1u64 << 32) as u32,
-                   0xC000_7A0A);
+        assert_eq!(
+            request_code_readwrite!(b'z', 10, 1u64 << 32) as u32,
+            0xC000_7A0A
+        );
     }
 }
 
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "netbsd",
-          target_os = "openbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 mod bsd {
     #[test]
     fn test_op_none() {
@@ -164,8 +198,8 @@ mod linux_ioctls {
     use std::mem;
     use std::os::unix::io::AsRawFd;
 
+    use libc::{termios, TCGETS, TCSBRK, TCSETS, TIOCNXCL};
     use tempfile::tempfile;
-    use libc::{TCGETS, TCSBRK, TCSETS, TIOCNXCL, termios};
 
     use nix::errno::Errno;
 
@@ -255,7 +289,7 @@ mod linux_ioctls {
     }
 
     // From linux/videodev2.h
-    ioctl_readwrite!(enum_audio,  b'V', 65, v4l2_audio);
+    ioctl_readwrite!(enum_audio, b'V', 65, v4l2_audio);
     #[test]
     fn test_ioctl_readwrite() {
         let file = tempfile().unwrap();
@@ -281,7 +315,12 @@ mod linux_ioctls {
     }
 
     // From linux/spi/spidev.h
-    ioctl_write_buf!(spi_ioc_message, super::SPI_IOC_MAGIC, super::SPI_IOC_MESSAGE, spi_ioc_transfer);
+    ioctl_write_buf!(
+        spi_ioc_message,
+        super::SPI_IOC_MAGIC,
+        super::SPI_IOC_MESSAGE,
+        spi_ioc_transfer
+    );
     #[test]
     fn test_ioctl_write_buf() {
         let file = tempfile().unwrap();
@@ -298,8 +337,8 @@ mod freebsd_ioctls {
     use std::mem;
     use std::os::unix::io::AsRawFd;
 
-    use tempfile::tempfile;
     use libc::termios;
+    use tempfile::tempfile;
 
     use nix::errno::Errno;
 
diff --git a/test/sys/test_lio_listio_resubmit.rs b/test/sys/test_lio_listio_resubmit.rs
deleted file mode 100644
index c907789..0000000
--- a/test/sys/test_lio_listio_resubmit.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-// vim: tw=80
-
-// Annoyingly, Cargo is unable to conditionally build an entire test binary.  So
-// we must disable the test here rather than in Cargo.toml
-#![cfg(target_os = "freebsd")]
-
-use nix::errno::*;
-use nix::libc::off_t;
-use nix::sys::aio::*;
-use nix::sys::signal::SigevNotify;
-use nix::unistd::{SysconfVar, sysconf};
-use std::os::unix::io::AsRawFd;
-use std::{thread, time};
-use sysctl::CtlValue;
-use tempfile::tempfile;
-
-const BYTES_PER_OP: usize = 512;
-
-/// Attempt to collect final status for all of `liocb`'s operations, freeing
-/// system resources
-fn finish_liocb(liocb: &mut LioCb) {
-    for j in 0..liocb.len() {
-        loop {
-            let e = liocb.error(j);
-            match e {
-                Ok(()) => break,
-                Err(Errno::EINPROGRESS) =>
-                    thread::sleep(time::Duration::from_millis(10)),
-                Err(x) => panic!("aio_error({:?})", x)
-            }
-        }
-        assert_eq!(liocb.aio_return(j).unwrap(), BYTES_PER_OP as isize);
-    }
-}
-
-// Deliberately exceed system resource limits, causing lio_listio to return EIO.
-// This test must run in its own process since it deliberately uses all AIO
-// resources.  ATM it is only enabled on FreeBSD, because I don't know how to
-// check system AIO limits on other operating systems.
-#[test]
-fn test_lio_listio_resubmit() {
-    let mut resubmit_count = 0;
-
-    // Lookup system resource limits
-    let alm = sysconf(SysconfVar::AIO_LISTIO_MAX)
-        .expect("sysconf").unwrap() as usize;
-    let maqpp = if let CtlValue::Int(x) = sysctl::value(
-            "vfs.aio.max_aio_queue_per_proc").unwrap(){
-        x as usize
-    } else {
-        panic!("unknown sysctl");
-    };
-
-    // Find lio_listio sizes that satisfy the AIO_LISTIO_MAX constraint and also
-    // result in a final lio_listio call that can only partially be queued
-    let target_ops = maqpp + alm / 2;
-    let num_listios = (target_ops + alm - 3) / (alm - 2);
-    let ops_per_listio = (target_ops + num_listios - 1) / num_listios;
-    assert!((num_listios - 1) * ops_per_listio < maqpp,
-        "the last lio_listio won't make any progress; fix the algorithm");
-    println!("Using {:?} LioCbs of {:?} operations apiece", num_listios,
-             ops_per_listio);
-
-    let f = tempfile().unwrap();
-    let buffer_set = (0..num_listios).map(|_| {
-        (0..ops_per_listio).map(|_| {
-            vec![0u8; BYTES_PER_OP]
-        }).collect::<Vec<_>>()
-    }).collect::<Vec<_>>();
-
-    let mut liocbs = (0..num_listios).map(|i| {
-        let mut builder = LioCbBuilder::with_capacity(ops_per_listio);
-        for j in 0..ops_per_listio {
-            let offset = (BYTES_PER_OP * (i * ops_per_listio + j)) as off_t;
-            builder = builder.emplace_slice(f.as_raw_fd(),
-                                offset,
-                                &buffer_set[i][j][..],
-                                0,   //priority
-                                SigevNotify::SigevNone,
-                                LioOpcode::LIO_WRITE);
-        }
-        let mut liocb = builder.finish();
-        let mut err = liocb.listio(LioMode::LIO_NOWAIT, SigevNotify::SigevNone);
-        while err == Err(Errno::EIO) ||
-              err == Err(Errno::EAGAIN) ||
-              err == Err(Errno::EINTR) {
-            // 
-            thread::sleep(time::Duration::from_millis(10));
-            resubmit_count += 1;
-            err = liocb.listio_resubmit(LioMode::LIO_NOWAIT,
-                                        SigevNotify::SigevNone);
-        }
-        liocb
-    }).collect::<Vec<_>>();
-
-    // Ensure that every AioCb completed
-    for liocb in liocbs.iter_mut() {
-        finish_liocb(liocb);
-    }
-
-    if resubmit_count > 0 {
-        println!("Resubmitted {:?} times, test passed", resubmit_count);
-    } else {
-        println!("Never resubmitted.  Test ambiguous");
-    }
-}
diff --git a/test/sys/test_mman.rs b/test/sys/test_mman.rs
index a7ceedc..e748427 100644
--- a/test/sys/test_mman.rs
+++ b/test/sys/test_mman.rs
@@ -1,55 +1,78 @@
 use nix::sys::mman::{mmap, MapFlags, ProtFlags};
+use std::num::NonZeroUsize;
 
 #[test]
 fn test_mmap_anonymous() {
     unsafe {
-        let ptr = mmap(std::ptr::null_mut(), 1,
-                       ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
-                       MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS, -1, 0)
-                      .unwrap() as *mut u8;
-        assert_eq !(*ptr, 0x00u8);
+        let ptr = mmap(
+            None,
+            NonZeroUsize::new(1).unwrap(),
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_PRIVATE | MapFlags::MAP_ANONYMOUS,
+            -1,
+            0,
+        )
+        .unwrap() as *mut u8;
+        assert_eq!(*ptr, 0x00u8);
         *ptr = 0xffu8;
-        assert_eq !(*ptr, 0xffu8);
+        assert_eq!(*ptr, 0xffu8);
     }
 }
 
 #[test]
 #[cfg(any(target_os = "linux", target_os = "netbsd"))]
 fn test_mremap_grow() {
-    use nix::sys::mman::{mremap, MRemapFlags};
     use nix::libc::{c_void, size_t};
+    use nix::sys::mman::{mremap, MRemapFlags};
 
-    const ONE_K : size_t = 1024;
-    let slice : &mut[u8] = unsafe {
-        let mem = mmap(std::ptr::null_mut(), ONE_K,
-                       ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
-                       MapFlags::MAP_ANONYMOUS | MapFlags::MAP_PRIVATE, -1, 0)
-                      .unwrap();
-        std::slice::from_raw_parts_mut(mem as * mut u8, ONE_K)
+    const ONE_K: size_t = 1024;
+    let one_k_non_zero = NonZeroUsize::new(ONE_K).unwrap();
+
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap(
+            None,
+            one_k_non_zero,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_ANONYMOUS | MapFlags::MAP_PRIVATE,
+            -1,
+            0,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)
     };
-    assert_eq !(slice[ONE_K - 1], 0x00);
+    assert_eq!(slice[ONE_K - 1], 0x00);
     slice[ONE_K - 1] = 0xFF;
-    assert_eq !(slice[ONE_K - 1], 0xFF);
+    assert_eq!(slice[ONE_K - 1], 0xFF);
 
-    let slice : &mut[u8] = unsafe {
+    let slice: &mut [u8] = unsafe {
         #[cfg(target_os = "linux")]
-        let mem = mremap(slice.as_mut_ptr() as * mut c_void, ONE_K, 10 * ONE_K,
-                         MRemapFlags::MREMAP_MAYMOVE, None)
-                      .unwrap();
+        let mem = mremap(
+            slice.as_mut_ptr() as *mut c_void,
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MREMAP_MAYMOVE,
+            None,
+        )
+        .unwrap();
         #[cfg(target_os = "netbsd")]
-        let mem = mremap(slice.as_mut_ptr() as * mut c_void, ONE_K, 10 * ONE_K,
-                         MRemapFlags::MAP_REMAPDUP, None)
-                      .unwrap();
-        std::slice::from_raw_parts_mut(mem as * mut u8, 10 * ONE_K)
+        let mem = mremap(
+            slice.as_mut_ptr() as *mut c_void,
+            ONE_K,
+            10 * ONE_K,
+            MRemapFlags::MAP_REMAPDUP,
+            None,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem as *mut u8, 10 * ONE_K)
     };
 
     // The first KB should still have the old data in it.
-    assert_eq !(slice[ONE_K - 1], 0xFF);
+    assert_eq!(slice[ONE_K - 1], 0xFF);
 
     // The additional range should be zero-init'd and accessible.
-    assert_eq !(slice[10 * ONE_K - 1], 0x00);
+    assert_eq!(slice[10 * ONE_K - 1], 0x00);
     slice[10 * ONE_K - 1] = 0xFF;
-    assert_eq !(slice[10 * ONE_K - 1], 0xFF);
+    assert_eq!(slice[10 * ONE_K - 1], 0xFF);
 }
 
 #[test]
@@ -57,36 +80,43 @@ fn test_mremap_grow() {
 // Segfaults for unknown reasons under QEMU for 32-bit targets
 #[cfg_attr(all(target_pointer_width = "32", qemu), ignore)]
 fn test_mremap_shrink() {
-    use nix::sys::mman::{mremap, MRemapFlags};
     use nix::libc::{c_void, size_t};
+    use nix::sys::mman::{mremap, MRemapFlags};
+    use std::num::NonZeroUsize;
 
-    const ONE_K : size_t = 1024;
-    let slice : &mut[u8] = unsafe {
-        let mem = mmap(std::ptr::null_mut(), 10 * ONE_K,
-                       ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
-                       MapFlags::MAP_ANONYMOUS | MapFlags::MAP_PRIVATE, -1, 0)
-                      .unwrap();
-        std::slice::from_raw_parts_mut(mem as * mut u8, ONE_K)
+    const ONE_K: size_t = 1024;
+    let ten_one_k = NonZeroUsize::new(10 * ONE_K).unwrap();
+    let slice: &mut [u8] = unsafe {
+        let mem = mmap(
+            None,
+            ten_one_k,
+            ProtFlags::PROT_READ | ProtFlags::PROT_WRITE,
+            MapFlags::MAP_ANONYMOUS | MapFlags::MAP_PRIVATE,
+            -1,
+            0,
+        )
+        .unwrap();
+        std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)
     };
-    assert_eq !(slice[ONE_K - 1], 0x00);
+    assert_eq!(slice[ONE_K - 1], 0x00);
     slice[ONE_K - 1] = 0xFF;
-    assert_eq !(slice[ONE_K - 1], 0xFF);
+    assert_eq!(slice[ONE_K - 1], 0xFF);
 
-    let slice : &mut[u8] = unsafe {
-        #[cfg(target_os = "linux")]
-        let mem = mremap(slice.as_mut_ptr() as * mut c_void, 10 * ONE_K, ONE_K,
-                         MRemapFlags::empty(), None)
-                      .unwrap();
+    let slice: &mut [u8] = unsafe {
+        let mem = mremap(
+            slice.as_mut_ptr() as *mut c_void,
+            ten_one_k.into(),
+            ONE_K,
+            MRemapFlags::empty(),
+            None,
+        )
+        .unwrap();
         // Since we didn't supply MREMAP_MAYMOVE, the address should be the
         // same.
-        #[cfg(target_os = "netbsd")]
-        let mem = mremap(slice.as_mut_ptr() as * mut c_void, 10 * ONE_K, ONE_K,
-                         MRemapFlags::MAP_FIXED, None)
-                      .unwrap();
-        assert_eq !(mem, slice.as_mut_ptr() as * mut c_void);
-        std::slice::from_raw_parts_mut(mem as * mut u8, ONE_K)
+        assert_eq!(mem, slice.as_mut_ptr() as *mut c_void);
+        std::slice::from_raw_parts_mut(mem as *mut u8, ONE_K)
     };
 
     // The first KB should still be accessible and have the old data in it.
-    assert_eq !(slice[ONE_K - 1], 0xFF);
+    assert_eq!(slice[ONE_K - 1], 0xFF);
 }
diff --git a/test/sys/test_pthread.rs b/test/sys/test_pthread.rs
index fa9b510..ce048ba 100644
--- a/test/sys/test_pthread.rs
+++ b/test/sys/test_pthread.rs
@@ -4,14 +4,14 @@ use nix::sys::pthread::*;
 #[test]
 fn test_pthread_self() {
     let tid = pthread_self();
-    assert!(tid != ::std::ptr::null_mut());
+    assert!(!tid.is_null());
 }
 
 #[cfg(not(any(target_env = "musl", target_os = "redox")))]
 #[test]
 fn test_pthread_self() {
     let tid = pthread_self();
-    assert!(tid != 0);
+    assert_ne!(tid, 0);
 }
 
 #[test]
diff --git a/test/sys/test_ptrace.rs b/test/sys/test_ptrace.rs
index 83fff9a..530560f 100644
--- a/test/sys/test_ptrace.rs
+++ b/test/sys/test_ptrace.rs
@@ -1,8 +1,14 @@
+#[cfg(all(
+    target_os = "linux",
+    any(target_arch = "x86_64", target_arch = "x86"),
+    target_env = "gnu"
+))]
+use memoffset::offset_of;
 use nix::errno::Errno;
-use nix::unistd::getpid;
 use nix::sys::ptrace;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use nix::sys::ptrace::Options;
+use nix::unistd::getpid;
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use std::mem;
@@ -15,8 +21,9 @@ fn test_ptrace() {
     // FIXME: qemu-user doesn't implement ptrace on all arches, so permit ENOSYS
     require_capability!("test_ptrace", CAP_SYS_PTRACE);
     let err = ptrace::attach(getpid()).unwrap_err();
-    assert!(err == Errno::EPERM || err == Errno::EINVAL ||
-            err == Errno::ENOSYS);
+    assert!(
+        err == Errno::EPERM || err == Errno::EINVAL || err == Errno::ENOSYS
+    );
 }
 
 // Just make sure ptrace_setoptions can be called at all, for now.
@@ -24,8 +31,9 @@ fn test_ptrace() {
 #[cfg(any(target_os = "android", target_os = "linux"))]
 fn test_ptrace_setoptions() {
     require_capability!("test_ptrace_setoptions", CAP_SYS_PTRACE);
-    let err = ptrace::setoptions(getpid(), Options::PTRACE_O_TRACESYSGOOD).unwrap_err();
-    assert!(err != Errno::EOPNOTSUPP);
+    let err = ptrace::setoptions(getpid(), Options::PTRACE_O_TRACESYSGOOD)
+        .unwrap_err();
+    assert_ne!(err, Errno::EOPNOTSUPP);
 }
 
 // Just make sure ptrace_getevent can be called at all, for now.
@@ -34,7 +42,7 @@ fn test_ptrace_setoptions() {
 fn test_ptrace_getevent() {
     require_capability!("test_ptrace_getevent", CAP_SYS_PTRACE);
     let err = ptrace::getevent(getpid()).unwrap_err();
-    assert!(err != Errno::EOPNOTSUPP);
+    assert_ne!(err, Errno::EOPNOTSUPP);
 }
 
 // Just make sure ptrace_getsiginfo can be called at all, for now.
@@ -58,7 +66,6 @@ fn test_ptrace_setsiginfo() {
     }
 }
 
-
 #[test]
 fn test_ptrace_cont() {
     use nix::sys::ptrace;
@@ -72,7 +79,7 @@ fn test_ptrace_cont() {
     let _m = crate::FORK_MTX.lock();
 
     // FIXME: qemu-user doesn't implement ptrace on all architectures
-    // and retunrs ENOSYS in this case.
+    // and returns ENOSYS in this case.
     // We (ab)use this behavior to detect the affected platforms
     // and skip the test then.
     // On valid platforms the ptrace call should return Errno::EPERM, this
@@ -82,7 +89,7 @@ fn test_ptrace_cont() {
         return;
     }
 
-    match unsafe{fork()}.expect("Error: Fork Failed") {
+    match unsafe { fork() }.expect("Error: Fork Failed") {
         Child => {
             ptrace::traceme().unwrap();
             // As recommended by ptrace(2), raise SIGTRAP to pause the child
@@ -90,15 +97,22 @@ fn test_ptrace_cont() {
             loop {
                 raise(Signal::SIGTRAP).unwrap();
             }
-
-        },
+        }
         Parent { child } => {
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::Stopped(child, Signal::SIGTRAP)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
             ptrace::cont(child, None).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::Stopped(child, Signal::SIGTRAP)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTRAP))
+            );
             ptrace::cont(child, Some(Signal::SIGKILL)).unwrap();
             match waitpid(child, None) {
-                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _)) if pid == child => {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
                     // FIXME It's been observed on some systems (apple) the
                     // tracee may not be killed but remain as a zombie process
                     // affecting other wait based tests. Add an extra kill just
@@ -110,7 +124,7 @@ fn test_ptrace_cont() {
                 }
                 _ => panic!("The process should have been killed"),
             }
-        },
+        }
     }
 }
 
@@ -129,22 +143,28 @@ fn test_ptrace_interrupt() {
 
     let _m = crate::FORK_MTX.lock();
 
-    match unsafe{fork()}.expect("Error: Fork Failed") {
-        Child => {
-            loop {
-                sleep(Duration::from_millis(1000));
-            }
-
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => loop {
+            sleep(Duration::from_millis(1000));
         },
         Parent { child } => {
-            ptrace::seize(child, ptrace::Options::PTRACE_O_TRACESYSGOOD).unwrap();
+            ptrace::seize(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
             ptrace::interrupt(child).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceEvent(child, Signal::SIGTRAP, 128)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceEvent(child, Signal::SIGTRAP, 128))
+            );
             ptrace::syscall(child, None).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
             ptrace::detach(child, Some(Signal::SIGKILL)).unwrap();
             match waitpid(child, None) {
-                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _)) if pid == child => {
+                Ok(WaitStatus::Signaled(pid, Signal::SIGKILL, _))
+                    if pid == child =>
+                {
                     let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
                     while ptrace::cont(child, Some(Signal::SIGKILL)).is_ok() {
                         let _ = waitpid(child, Some(WaitPidFlag::WNOHANG));
@@ -152,19 +172,20 @@ fn test_ptrace_interrupt() {
                 }
                 _ => panic!("The process should have been killed"),
             }
-        },
+        }
     }
 }
 
 // ptrace::{setoptions, getregs} are only available in these platforms
-#[cfg(all(target_os = "linux",
-          any(target_arch = "x86_64",
-              target_arch = "x86"),
-          target_env = "gnu"))]
+#[cfg(all(
+    target_os = "linux",
+    any(target_arch = "x86_64", target_arch = "x86"),
+    target_env = "gnu"
+))]
 #[test]
 fn test_ptrace_syscall() {
-    use nix::sys::signal::kill;
     use nix::sys::ptrace;
+    use nix::sys::signal::kill;
     use nix::sys::signal::Signal;
     use nix::sys::wait::{waitpid, WaitStatus};
     use nix::unistd::fork;
@@ -175,45 +196,80 @@ fn test_ptrace_syscall() {
 
     let _m = crate::FORK_MTX.lock();
 
-    match unsafe{fork()}.expect("Error: Fork Failed") {
+    match unsafe { fork() }.expect("Error: Fork Failed") {
         Child => {
             ptrace::traceme().unwrap();
             // first sigstop until parent is ready to continue
             let pid = getpid();
             kill(pid, Signal::SIGSTOP).unwrap();
             kill(pid, Signal::SIGTERM).unwrap();
-            unsafe { ::libc::_exit(0); }
-        },
+            unsafe {
+                ::libc::_exit(0);
+            }
+        }
 
         Parent { child } => {
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::Stopped(child, Signal::SIGSTOP)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGSTOP))
+            );
 
             // set this option to recognize syscall-stops
-            ptrace::setoptions(child, ptrace::Options::PTRACE_O_TRACESYSGOOD).unwrap();
+            ptrace::setoptions(child, ptrace::Options::PTRACE_O_TRACESYSGOOD)
+                .unwrap();
 
             #[cfg(target_arch = "x86_64")]
-            let get_syscall_id = || ptrace::getregs(child).unwrap().orig_rax as libc::c_long;
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_rax as libc::c_long;
 
             #[cfg(target_arch = "x86")]
-            let get_syscall_id = || ptrace::getregs(child).unwrap().orig_eax as libc::c_long;
+            let get_syscall_id =
+                || ptrace::getregs(child).unwrap().orig_eax as libc::c_long;
+
+            // this duplicates `get_syscall_id` for the purpose of testing `ptrace::read_user`.
+            #[cfg(target_arch = "x86_64")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_rax);
+            #[cfg(target_arch = "x86")]
+            let rax_offset = offset_of!(libc::user_regs_struct, orig_eax);
+
+            let get_syscall_from_user_area = || {
+                // Find the offset of `user.regs.rax` (or `user.regs.eax` for x86)
+                let rax_offset = offset_of!(libc::user, regs) + rax_offset;
+                ptrace::read_user(child, rax_offset as _).unwrap()
+                    as libc::c_long
+            };
 
             // kill entry
             ptrace::syscall(child, None).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
             assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
 
             // kill exit
             ptrace::syscall(child, None).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::PtraceSyscall(child))
+            );
             assert_eq!(get_syscall_id(), ::libc::SYS_kill);
+            assert_eq!(get_syscall_from_user_area(), ::libc::SYS_kill);
 
             // receive signal
             ptrace::syscall(child, None).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::Stopped(child, Signal::SIGTERM)));
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Stopped(child, Signal::SIGTERM))
+            );
 
             // inject signal
             ptrace::syscall(child, Signal::SIGTERM).unwrap();
-            assert_eq!(waitpid(child, None), Ok(WaitStatus::Signaled(child, Signal::SIGTERM, false)));
-        },
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, Signal::SIGTERM, false))
+            );
+        }
     }
 }
diff --git a/test/sys/test_select.rs b/test/sys/test_select.rs
index 2f7396b..40bda4d 100644
--- a/test/sys/test_select.rs
+++ b/test/sys/test_select.rs
@@ -1,7 +1,7 @@
 use nix::sys::select::*;
-use nix::unistd::{pipe, write};
 use nix::sys::signal::SigSet;
 use nix::sys::time::{TimeSpec, TimeValLike};
+use nix::unistd::{pipe, write};
 
 #[test]
 pub fn test_pselect() {
@@ -45,7 +45,8 @@ pub fn test_pselect_nfds2() {
             None,
             &timeout,
             None
-        ).unwrap()
+        )
+        .unwrap()
     );
     assert!(fd_set.contains(r1));
     assert!(!fd_set.contains(r2));
diff --git a/test/sys/test_signal.rs b/test/sys/test_signal.rs
index fdd2568..3ad14f4 100644
--- a/test/sys/test_signal.rs
+++ b/test/sys/test_signal.rs
@@ -52,9 +52,12 @@ fn test_sigprocmask() {
 
     // Make sure the old set doesn't contain the signal, otherwise the following
     // test don't make sense.
-    assert!(!old_signal_set.contains(SIGNAL),
-            "the {:?} signal is already blocked, please change to a \
-             different one", SIGNAL);
+    assert!(
+        !old_signal_set.contains(SIGNAL),
+        "the {:?} signal is already blocked, please change to a \
+             different one",
+        SIGNAL
+    );
 
     // Now block the signal.
     let mut signal_set = SigSet::empty();
@@ -66,8 +69,11 @@ fn test_sigprocmask() {
     old_signal_set.clear();
     sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set))
         .expect("expect to be able to retrieve old signals");
-    assert!(old_signal_set.contains(SIGNAL),
-            "expected the {:?} to be blocked", SIGNAL);
+    assert!(
+        old_signal_set.contains(SIGNAL),
+        "expected the {:?} to be blocked",
+        SIGNAL
+    );
 
     // Reset the signal.
     sigprocmask(SigmaskHow::SIG_UNBLOCK, Some(&signal_set), None)
@@ -78,13 +84,18 @@ lazy_static! {
     static ref SIGNALED: AtomicBool = AtomicBool::new(false);
 }
 
-extern fn test_sigaction_handler(signal: libc::c_int) {
+extern "C" fn test_sigaction_handler(signal: libc::c_int) {
     let signal = Signal::try_from(signal).unwrap();
     SIGNALED.store(signal == Signal::SIGINT, Ordering::Relaxed);
 }
 
 #[cfg(not(target_os = "redox"))]
-extern fn test_sigaction_action(_: libc::c_int, _: *mut libc::siginfo_t, _: *mut libc::c_void) {}
+extern "C" fn test_sigaction_action(
+    _: libc::c_int,
+    _: *mut libc::siginfo_t,
+    _: *mut libc::c_void,
+) {
+}
 
 #[test]
 #[cfg(not(target_os = "redox"))]
@@ -92,7 +103,10 @@ fn test_signal_sigaction() {
     let _m = crate::SIGNAL_MTX.lock();
 
     let action_handler = SigHandler::SigAction(test_sigaction_action);
-    assert_eq!(unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(), Errno::ENOTSUP);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, action_handler) }.unwrap_err(),
+        Errno::ENOTSUP
+    );
 }
 
 #[test]
@@ -101,20 +115,32 @@ fn test_signal() {
 
     unsafe { signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();
     raise(Signal::SIGINT).unwrap();
-    assert_eq!(unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(), SigHandler::SigIgn);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigIgn
+    );
 
     let handler = SigHandler::Handler(test_sigaction_handler);
-    assert_eq!(unsafe { signal(Signal::SIGINT, handler) }.unwrap(), SigHandler::SigDfl);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, handler) }.unwrap(),
+        SigHandler::SigDfl
+    );
     raise(Signal::SIGINT).unwrap();
     assert!(SIGNALED.load(Ordering::Relaxed));
 
     #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
-    assert_eq!(unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(), handler);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        handler
+    );
 
     // System V based OSes (e.g. illumos and Solaris) always resets the
     // disposition to SIG_DFL prior to calling the signal handler
     #[cfg(any(target_os = "illumos", target_os = "solaris"))]
-    assert_eq!(unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(), SigHandler::SigDfl);
+    assert_eq!(
+        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
+        SigHandler::SigDfl
+    );
 
     // Restore default signal handler
     unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
diff --git a/test/sys/test_signalfd.rs b/test/sys/test_signalfd.rs
index b6f748b..87153c9 100644
--- a/test/sys/test_signalfd.rs
+++ b/test/sys/test_signalfd.rs
@@ -2,8 +2,8 @@ use std::convert::TryFrom;
 
 #[test]
 fn test_signalfd() {
+    use nix::sys::signal::{self, raise, SigSet, Signal};
     use nix::sys::signalfd::SignalFd;
-    use nix::sys::signal::{self, raise, Signal, SigSet};
 
     // Grab the mutex for altering signals so we don't interfere with other tests.
     let _m = crate::SIGNAL_MTX.lock();
diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs
index 0f6fac6..5adc77e 100644
--- a/test/sys/test_socket.rs
+++ b/test/sys/test_socket.rs
@@ -1,16 +1,21 @@
-use nix::sys::socket::{AddressFamily, InetAddr, SockAddr, UnixAddr, getsockname, sockaddr, sockaddr_in6, sockaddr_storage_to_addr};
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use crate::*;
+use libc::{c_char, sockaddr_storage};
+#[allow(deprecated)]
+use nix::sys::socket::InetAddr;
+use nix::sys::socket::{
+    getsockname, sockaddr, sockaddr_in6, AddressFamily, UnixAddr,
+};
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::mem::{self, MaybeUninit};
-use std::net::{self, Ipv6Addr, SocketAddr, SocketAddrV6};
+use std::net::{self, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::os::unix::io::RawFd;
 use std::path::Path;
 use std::slice;
 use std::str::FromStr;
-use libc::{c_char, sockaddr_storage};
-#[cfg(any(target_os = "linux", target_os= "android"))]
-use crate::*;
 
+#[allow(deprecated)]
 #[test]
 pub fn test_inetv4_addr_to_sock_addr() {
     let actual: net::SocketAddr = FromStr::from_str("127.0.0.1:3000").unwrap();
@@ -34,8 +39,11 @@ pub fn test_inetv4_addr_to_sock_addr() {
     assert_eq!(actual, inet);
 }
 
+#[allow(deprecated)]
 #[test]
 pub fn test_inetv4_addr_roundtrip_sockaddr_storage_to_addr() {
+    use nix::sys::socket::{sockaddr_storage_to_addr, SockAddr};
+
     let actual: net::SocketAddr = FromStr::from_str("127.0.0.1:3000").unwrap();
     let addr = InetAddr::from_std(&actual);
     let sockaddr = SockAddr::new_inet(addr);
@@ -51,41 +59,87 @@ pub fn test_inetv4_addr_roundtrip_sockaddr_storage_to_addr() {
         }
     };
 
-    let from_storage = sockaddr_storage_to_addr(&storage, ffi_size as usize).unwrap();
+    let from_storage =
+        sockaddr_storage_to_addr(&storage, ffi_size as usize).unwrap();
     assert_eq!(from_storage, sockaddr);
-    let from_storage = sockaddr_storage_to_addr(&storage, mem::size_of::<sockaddr_storage>()).unwrap();
+    let from_storage =
+        sockaddr_storage_to_addr(&storage, mem::size_of::<sockaddr_storage>())
+            .unwrap();
     assert_eq!(from_storage, sockaddr);
 }
 
+#[cfg(any(target_os = "linux"))]
+#[cfg_attr(qemu, ignore)]
 #[test]
-pub fn test_inetv6_addr_to_sock_addr() {
-    let port: u16 = 3000;
-    let flowinfo: u32 = 1;
-    let scope_id: u32 = 2;
-    let ip: Ipv6Addr = "fe80::1".parse().unwrap();
+pub fn test_timestamping() {
+    use nix::sys::socket::{
+        recvmsg, sendmsg, setsockopt, socket, sockopt::Timestamping,
+        ControlMessageOwned, MsgFlags, SockFlag, SockType, SockaddrIn,
+        TimestampingFlag,
+    };
+    use std::io::{IoSlice, IoSliceMut};
 
-    let actual = SocketAddr::V6(SocketAddrV6::new(ip, port, flowinfo, scope_id));
-    let addr = InetAddr::from_std(&actual);
+    let sock_addr = SockaddrIn::from_str("127.0.0.1:6790").unwrap();
 
-    match addr {
-        InetAddr::V6(addr) => {
-            assert_eq!(addr.sin6_port, port.to_be());
-            assert_eq!(addr.sin6_flowinfo, flowinfo);
-            assert_eq!(addr.sin6_scope_id, scope_id);
+    let ssock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("send socket failed");
+
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    nix::sys::socket::bind(rsock, &sock_addr).unwrap();
+
+    setsockopt(rsock, Timestamping, &TimestampingFlag::all()).unwrap();
+
+    let sbuf = [0u8; 2048];
+    let mut rbuf = [0u8; 2048];
+    let flags = MsgFlags::empty();
+    let iov1 = [IoSlice::new(&sbuf)];
+    let mut iov2 = [IoSliceMut::new(&mut rbuf)];
+
+    let mut cmsg = cmsg_space!(nix::sys::socket::Timestamps);
+    sendmsg(ssock, &iov1, &[], flags, Some(&sock_addr)).unwrap();
+    let recv = recvmsg::<()>(rsock, &mut iov2, Some(&mut cmsg), flags).unwrap();
+
+    let mut ts = None;
+    for c in recv.cmsgs() {
+        if let ControlMessageOwned::ScmTimestampsns(timestamps) = c {
+            ts = Some(timestamps.system);
         }
-        _ => panic!("nope"),
     }
-
-    assert_eq!(actual, addr.to_std());
+    let ts = ts.expect("ScmTimestampns is present");
+    let sys_time =
+        ::nix::time::clock_gettime(::nix::time::ClockId::CLOCK_REALTIME)
+            .unwrap();
+    let diff = if ts > sys_time {
+        ts - sys_time
+    } else {
+        sys_time - ts
+    };
+    assert!(std::time::Duration::from(diff).as_secs() < 60);
 }
+
+#[allow(deprecated)]
 #[test]
 pub fn test_inetv6_addr_roundtrip_sockaddr_storage_to_addr() {
+    use nix::sys::socket::{sockaddr_storage_to_addr, SockAddr};
+
     let port: u16 = 3000;
     let flowinfo: u32 = 1;
     let scope_id: u32 = 2;
     let ip: Ipv6Addr = "fe80::1".parse().unwrap();
 
-    let actual = SocketAddr::V6(SocketAddrV6::new(ip, port, flowinfo, scope_id));
+    let actual =
+        SocketAddr::V6(SocketAddrV6::new(ip, port, flowinfo, scope_id));
     let addr = InetAddr::from_std(&actual);
     let sockaddr = SockAddr::new_inet(addr);
 
@@ -95,14 +149,20 @@ pub fn test_inetv6_addr_roundtrip_sockaddr_storage_to_addr() {
         let (ffi_ptr, ffi_size) = sockaddr.as_ffi_pair();
         assert_eq!(mem::size_of::<sockaddr_in6>(), ffi_size as usize);
         unsafe {
-            storage_ptr.copy_from_nonoverlapping((ffi_ptr as *const sockaddr).cast::<sockaddr_in6>(), 1);
+            storage_ptr.copy_from_nonoverlapping(
+                (ffi_ptr as *const sockaddr).cast::<sockaddr_in6>(),
+                1,
+            );
             (storage.assume_init(), ffi_size)
         }
     };
 
-    let from_storage = sockaddr_storage_to_addr(&storage, ffi_size as usize).unwrap();
+    let from_storage =
+        sockaddr_storage_to_addr(&storage, ffi_size as usize).unwrap();
     assert_eq!(from_storage, sockaddr);
-    let from_storage = sockaddr_storage_to_addr(&storage, mem::size_of::<sockaddr_storage>()).unwrap();
+    let from_storage =
+        sockaddr_storage_to_addr(&storage, mem::size_of::<sockaddr_storage>())
+            .unwrap();
     assert_eq!(from_storage, sockaddr);
 }
 
@@ -144,7 +204,7 @@ pub fn test_addr_equality_path() {
 pub fn test_abstract_sun_path_too_long() {
     let name = String::from("nix\0abstract\0tesnix\0abstract\0tesnix\0abstract\0tesnix\0abstract\0tesnix\0abstract\0testttttnix\0abstract\0test\0make\0sure\0this\0is\0long\0enough");
     let addr = UnixAddr::new_abstract(name.as_bytes());
-    assert!(addr.is_err());
+    addr.expect_err("assertion failed");
 }
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
@@ -163,7 +223,7 @@ pub fn test_addr_equality_abstract() {
 }
 
 // Test getting/setting abstract addresses (without unix socket creation)
-#[cfg(target_os = "linux")]
+#[cfg(any(target_os = "android", target_os = "linux"))]
 #[test]
 pub fn test_abstract_uds_addr() {
     let empty = String::new();
@@ -174,7 +234,8 @@ pub fn test_abstract_uds_addr() {
     let name = String::from("nix\0abstract\0test");
     let addr = UnixAddr::new_abstract(name.as_bytes()).unwrap();
     let sun_path = [
-        110u8, 105, 120, 0, 97, 98, 115, 116, 114, 97, 99, 116, 0, 116, 101, 115, 116
+        110u8, 105, 120, 0, 97, 98, 115, 116, 114, 97, 99, 116, 0, 116, 101,
+        115, 116,
     ];
     assert_eq!(addr.as_abstract(), Some(&sun_path[..]));
     assert_eq!(addr.path(), None);
@@ -183,46 +244,90 @@ pub fn test_abstract_uds_addr() {
     assert_eq!(unsafe { (*addr.as_ptr()).sun_path[0] }, 0);
 }
 
+// Test getting an unnamed address (without unix socket creation)
+#[cfg(any(target_os = "android", target_os = "linux"))]
+#[test]
+pub fn test_unnamed_uds_addr() {
+    use crate::nix::sys::socket::SockaddrLike;
+
+    let addr = UnixAddr::new_unnamed();
+
+    assert!(addr.is_unnamed());
+    assert_eq!(addr.len(), 2);
+    assert!(addr.path().is_none());
+    assert_eq!(addr.path_len(), 0);
+
+    assert!(addr.as_abstract().is_none());
+}
+
 #[test]
 pub fn test_getsockname() {
-    use nix::sys::socket::{socket, AddressFamily, SockType, SockFlag};
-    use nix::sys::socket::{bind, SockAddr};
+    use nix::sys::socket::bind;
+    use nix::sys::socket::{socket, AddressFamily, SockFlag, SockType};
 
     let tempdir = tempfile::tempdir().unwrap();
     let sockname = tempdir.path().join("sock");
-    let sock = socket(AddressFamily::Unix, SockType::Stream, SockFlag::empty(), None)
-               .expect("socket failed");
-    let sockaddr = SockAddr::new_unix(&sockname).unwrap();
+    let sock = socket(
+        AddressFamily::Unix,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
+    let sockaddr = UnixAddr::new(&sockname).unwrap();
     bind(sock, &sockaddr).expect("bind failed");
     assert_eq!(sockaddr, getsockname(sock).expect("getsockname failed"));
 }
 
 #[test]
 pub fn test_socketpair() {
+    use nix::sys::socket::{socketpair, AddressFamily, SockFlag, SockType};
     use nix::unistd::{read, write};
-    use nix::sys::socket::{socketpair, AddressFamily, SockType, SockFlag};
 
-    let (fd1, fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty())
-                     .unwrap();
+    let (fd1, fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     write(fd1, b"hello").unwrap();
-    let mut buf = [0;5];
+    let mut buf = [0; 5];
     read(fd2, &mut buf).unwrap();
 
     assert_eq!(&buf[..], b"hello");
 }
 
+#[test]
+pub fn test_std_conversions() {
+    use nix::sys::socket::*;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:6789").unwrap();
+    let sock_addr = SockaddrIn::from(std_sa);
+    assert_eq!(std_sa, sock_addr.into());
+
+    let std_sa = SocketAddrV6::from_str("[::1]:6000").unwrap();
+    let sock_addr: SockaddrIn6 = SockaddrIn6::from(std_sa);
+    assert_eq!(std_sa, sock_addr.into());
+}
+
 mod recvfrom {
-    use nix::Result;
+    use super::*;
     use nix::sys::socket::*;
+    use nix::{errno::Errno, Result};
     use std::thread;
-    use super::*;
 
     const MSG: &[u8] = b"Hello, World!";
 
-    fn sendrecv<Fs, Fr>(rsock: RawFd, ssock: RawFd, f_send: Fs, mut f_recv: Fr) -> Option<SockAddr>
-        where
-            Fs: Fn(RawFd, &[u8], MsgFlags) -> Result<usize> + Send + 'static,
-            Fr: FnMut(usize, Option<SockAddr>),
+    fn sendrecv<Fs, Fr>(
+        rsock: RawFd,
+        ssock: RawFd,
+        f_send: Fs,
+        mut f_recv: Fr,
+    ) -> Option<SockaddrStorage>
+    where
+        Fs: Fn(RawFd, &[u8], MsgFlags) -> Result<usize> + Send + 'static,
+        Fr: FnMut(usize, Option<SockaddrStorage>),
     {
         let mut buf: [u8; 13] = [0u8; 13];
         let mut l = 0;
@@ -248,43 +353,51 @@ mod recvfrom {
 
     #[test]
     pub fn stream() {
-        let (fd2, fd1) = socketpair(AddressFamily::Unix, SockType::Stream,
-                                    None, SockFlag::empty()).unwrap();
+        let (fd2, fd1) = socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
         // Ignore from for stream sockets
-        let _ = sendrecv(fd1, fd2, |s, m, flags| {
-            send(s, m, flags)
-        }, |_, _| {});
+        let _ = sendrecv(fd1, fd2, send, |_, _| {});
     }
 
     #[test]
     pub fn udp() {
-        let std_sa = SocketAddr::from_str("127.0.0.1:6789").unwrap();
-        let inet_addr = InetAddr::from_std(&std_sa);
-        let sock_addr = SockAddr::new_inet(inet_addr);
-        let rsock = socket(AddressFamily::Inet,
+        let std_sa = SocketAddrV4::from_str("127.0.0.1:6789").unwrap();
+        let sock_addr = SockaddrIn::from(std_sa);
+        let rsock = socket(
+            AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
-            None
-        ).unwrap();
+            None,
+        )
+        .unwrap();
         bind(rsock, &sock_addr).unwrap();
         let ssock = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
-        let from = sendrecv(rsock, ssock, move |s, m, flags| {
-            sendto(s, m, &sock_addr, flags)
-        },|_, _| {});
+        )
+        .expect("send socket failed");
+        let from = sendrecv(
+            rsock,
+            ssock,
+            move |s, m, flags| sendto(s, m, &sock_addr, flags),
+            |_, _| {},
+        );
         // UDP sockets should set the from address
-        assert_eq!(AddressFamily::Inet, from.unwrap().family());
+        assert_eq!(AddressFamily::Inet, from.unwrap().family().unwrap());
     }
 
     #[cfg(target_os = "linux")]
     mod udp_offload {
         use super::*;
-        use nix::sys::uio::IoVec;
         use nix::sys::socket::sockopt::{UdpGroSegment, UdpGsoSegment};
+        use std::io::IoSlice;
 
         #[test]
         // Disable the test under emulation because it fails in Cirrus-CI.  Lack
@@ -298,14 +411,14 @@ mod recvfrom {
             // with size 2 and two UDP packet with size 1 will be sent.
             let segment_size: u16 = 2;
 
-            let std_sa = SocketAddr::from_str("127.0.0.1:6791").unwrap();
-            let inet_addr = InetAddr::from_std(&std_sa);
-            let sock_addr = SockAddr::new_inet(inet_addr);
-            let rsock = socket(AddressFamily::Inet,
-                               SockType::Datagram,
-                               SockFlag::empty(),
-                               None
-            ).unwrap();
+            let sock_addr = SockaddrIn::new(127, 0, 0, 1, 6791);
+            let rsock = socket(
+                AddressFamily::Inet,
+                SockType::Datagram,
+                SockFlag::empty(),
+                None,
+            )
+            .unwrap();
 
             setsockopt(rsock, UdpGsoSegment, &(segment_size as _))
                 .expect("setsockopt UDP_SEGMENT failed");
@@ -316,24 +429,30 @@ mod recvfrom {
                 SockType::Datagram,
                 SockFlag::empty(),
                 None,
-            ).expect("send socket failed");
+            )
+            .expect("send socket failed");
 
             let mut num_packets_received: i32 = 0;
 
-            sendrecv(rsock, ssock, move |s, m, flags| {
-                let iov = [IoVec::from_slice(m)];
-                let cmsg = ControlMessage::UdpGsoSegments(&segment_size);
-                sendmsg(s, &iov, &[cmsg], flags, Some(&sock_addr))
-            }, {
-                let num_packets_received_ref = &mut num_packets_received;
-
-                move |len, _| {
-                    // check that we receive UDP packets with payload size
-                    // less or equal to segment size
-                    assert!(len <= segment_size as usize);
-                    *num_packets_received_ref += 1;
-                }
-            });
+            sendrecv(
+                rsock,
+                ssock,
+                move |s, m, flags| {
+                    let iov = [IoSlice::new(m)];
+                    let cmsg = ControlMessage::UdpGsoSegments(&segment_size);
+                    sendmsg(s, &iov, &[cmsg], flags, Some(&sock_addr))
+                },
+                {
+                    let num_packets_received_ref = &mut num_packets_received;
+
+                    move |len, _| {
+                        // check that we receive UDP packets with payload size
+                        // less or equal to segment size
+                        assert!(len <= segment_size as usize);
+                        *num_packets_received_ref += 1;
+                    }
+                },
+            );
 
             // Buffer size is 13, we will receive six packets of size 2,
             // and one packet of size 1.
@@ -350,11 +469,13 @@ mod recvfrom {
             // It's hard to guarantee receiving GRO packets. Just checking
             // that `setsockopt` doesn't fail with error
 
-            let rsock = socket(AddressFamily::Inet,
-                               SockType::Datagram,
-                               SockFlag::empty(),
-                               None
-            ).unwrap();
+            let rsock = socket(
+                AddressFamily::Inet,
+                SockType::Datagram,
+                SockFlag::empty(),
+                None,
+            )
+            .unwrap();
 
             setsockopt(rsock, UdpGroSegment, &true)
                 .expect("setsockopt UDP_GRO failed");
@@ -369,62 +490,63 @@ mod recvfrom {
     ))]
     #[test]
     pub fn udp_sendmmsg() {
-        use nix::sys::uio::IoVec;
+        use std::io::IoSlice;
 
-        let std_sa = SocketAddr::from_str("127.0.0.1:6793").unwrap();
-        let std_sa2 = SocketAddr::from_str("127.0.0.1:6794").unwrap();
-        let inet_addr = InetAddr::from_std(&std_sa);
-        let inet_addr2 = InetAddr::from_std(&std_sa2);
-        let sock_addr = SockAddr::new_inet(inet_addr);
-        let sock_addr2 = SockAddr::new_inet(inet_addr2);
+        let std_sa = SocketAddrV4::from_str("127.0.0.1:6793").unwrap();
+        let std_sa2 = SocketAddrV4::from_str("127.0.0.1:6794").unwrap();
+        let sock_addr = SockaddrIn::from(std_sa);
+        let sock_addr2 = SockaddrIn::from(std_sa2);
 
-        let rsock = socket(AddressFamily::Inet,
+        let rsock = socket(
+            AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
-            None
-        ).unwrap();
+            None,
+        )
+        .unwrap();
         bind(rsock, &sock_addr).unwrap();
         let ssock = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
-
-        let from = sendrecv(rsock, ssock, move |s, m, flags| {
-            let iov = [IoVec::from_slice(m)];
-            let mut msgs = vec![
-                SendMmsgData {
-                    iov: &iov,
-                    cmsgs: &[],
-                    addr: Some(sock_addr),
-                    _lt: Default::default(),
+        )
+        .expect("send socket failed");
+
+        let from = sendrecv(
+            rsock,
+            ssock,
+            move |s, m, flags| {
+                let batch_size = 15;
+                let mut iovs = Vec::with_capacity(1 + batch_size);
+                let mut addrs = Vec::with_capacity(1 + batch_size);
+                let mut data = MultiHeaders::preallocate(1 + batch_size, None);
+                let iov = IoSlice::new(m);
+                // first chunk:
+                iovs.push([iov]);
+                addrs.push(Some(sock_addr));
+
+                for _ in 0..batch_size {
+                    iovs.push([iov]);
+                    addrs.push(Some(sock_addr2));
                 }
-            ];
 
-            let batch_size = 15;
-
-            for _ in 0..batch_size {
-                msgs.push(
-                    SendMmsgData {
-                        iov: &iov,
-                        cmsgs: &[],
-                        addr: Some(sock_addr2),
-                        _lt: Default::default(),
-                    }
-                );
-            }
-            sendmmsg(s, msgs.iter(), flags)
-                .map(move |sent_bytes| {
-                    assert!(!sent_bytes.is_empty());
-                    for sent in &sent_bytes {
-                        assert_eq!(*sent, m.len());
-                    }
-                    sent_bytes.len()
-                })
-        }, |_, _ | {});
+                let res = sendmmsg(s, &mut data, &iovs, addrs, [], flags)?;
+                let mut sent_messages = 0;
+                let mut sent_bytes = 0;
+                for item in res {
+                    sent_messages += 1;
+                    sent_bytes += item.bytes;
+                }
+                //
+                assert_eq!(sent_messages, iovs.len());
+                assert_eq!(sent_bytes, sent_messages * m.len());
+                Ok(sent_messages)
+            },
+            |_, _| {},
+        );
         // UDP sockets should set the from address
-        assert_eq!(AddressFamily::Inet, from.unwrap().family());
+        assert_eq!(AddressFamily::Inet, from.unwrap().family().unwrap());
     }
 
     #[cfg(any(
@@ -435,32 +557,35 @@ mod recvfrom {
     ))]
     #[test]
     pub fn udp_recvmmsg() {
-        use nix::sys::uio::IoVec;
-        use nix::sys::socket::{MsgFlags, recvmmsg};
+        use nix::sys::socket::{recvmmsg, MsgFlags};
+        use std::io::IoSliceMut;
 
         const NUM_MESSAGES_SENT: usize = 2;
-        const DATA: [u8; 2] = [1,2];
+        const DATA: [u8; 2] = [1, 2];
 
-        let std_sa = SocketAddr::from_str("127.0.0.1:6798").unwrap();
-        let inet_addr = InetAddr::from_std(&std_sa);
-        let sock_addr = SockAddr::new_inet(inet_addr);
+        let inet_addr = SocketAddrV4::from_str("127.0.0.1:6798").unwrap();
+        let sock_addr = SockaddrIn::from(inet_addr);
 
-        let rsock = socket(AddressFamily::Inet,
+        let rsock = socket(
+            AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
-            None
-        ).unwrap();
+            None,
+        )
+        .unwrap();
         bind(rsock, &sock_addr).unwrap();
         let ssock = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
+        )
+        .expect("send socket failed");
 
         let send_thread = thread::spawn(move || {
             for _ in 0..NUM_MESSAGES_SENT {
-                sendto(ssock, &DATA[..], &sock_addr, MsgFlags::empty()).unwrap();
+                sendto(ssock, &DATA[..], &sock_addr, MsgFlags::empty())
+                    .unwrap();
             }
         });
 
@@ -468,22 +593,23 @@ mod recvfrom {
 
         // Buffers to receive exactly `NUM_MESSAGES_SENT` messages
         let mut receive_buffers = [[0u8; 32]; NUM_MESSAGES_SENT];
-        let iovs: Vec<_> = receive_buffers.iter_mut().map(|buf| {
-            [IoVec::from_mut_slice(&mut buf[..])]
-        }).collect();
-
-        for iov in &iovs {
-            msgs.push_back(RecvMmsgData {
-                iov,
-                cmsg_buffer: None,
-            })
-        };
+        msgs.extend(
+            receive_buffers
+                .iter_mut()
+                .map(|buf| [IoSliceMut::new(&mut buf[..])]),
+        );
+
+        let mut data =
+            MultiHeaders::<SockaddrIn>::preallocate(msgs.len(), None);
 
-        let res = recvmmsg(rsock, &mut msgs, MsgFlags::empty(), None).expect("recvmmsg");
+        let res: Vec<RecvMsg<SockaddrIn>> =
+            recvmmsg(rsock, &mut data, msgs.iter(), MsgFlags::empty(), None)
+                .expect("recvmmsg")
+                .collect();
         assert_eq!(res.len(), DATA.len());
 
         for RecvMsg { address, bytes, .. } in res.into_iter() {
-            assert_eq!(AddressFamily::Inet, address.unwrap().family());
+            assert_eq!(AddressFamily::Inet, address.unwrap().family().unwrap());
             assert_eq!(DATA.len(), bytes);
         }
 
@@ -502,32 +628,35 @@ mod recvfrom {
     ))]
     #[test]
     pub fn udp_recvmmsg_dontwait_short_read() {
-        use nix::sys::uio::IoVec;
-        use nix::sys::socket::{MsgFlags, recvmmsg};
+        use nix::sys::socket::{recvmmsg, MsgFlags};
+        use std::io::IoSliceMut;
 
         const NUM_MESSAGES_SENT: usize = 2;
-        const DATA: [u8; 4] = [1,2,3,4];
+        const DATA: [u8; 4] = [1, 2, 3, 4];
 
-        let std_sa = SocketAddr::from_str("127.0.0.1:6799").unwrap();
-        let inet_addr = InetAddr::from_std(&std_sa);
-        let sock_addr = SockAddr::new_inet(inet_addr);
+        let inet_addr = SocketAddrV4::from_str("127.0.0.1:6799").unwrap();
+        let sock_addr = SockaddrIn::from(inet_addr);
 
-        let rsock = socket(AddressFamily::Inet,
+        let rsock = socket(
+            AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
-            None
-        ).unwrap();
+            None,
+        )
+        .unwrap();
         bind(rsock, &sock_addr).unwrap();
         let ssock = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
+        )
+        .expect("send socket failed");
 
         let send_thread = thread::spawn(move || {
             for _ in 0..NUM_MESSAGES_SENT {
-                sendto(ssock, &DATA[..], &sock_addr, MsgFlags::empty()).unwrap();
+                sendto(ssock, &DATA[..], &sock_addr, MsgFlags::empty())
+                    .unwrap();
             }
         });
         // Ensure we've sent all the messages before continuing so `recvmmsg`
@@ -540,22 +669,30 @@ mod recvfrom {
         // will return when there are fewer than requested messages in the
         // kernel buffers when using `MSG_DONTWAIT`.
         let mut receive_buffers = [[0u8; 32]; NUM_MESSAGES_SENT + 2];
-        let iovs: Vec<_> = receive_buffers.iter_mut().map(|buf| {
-            [IoVec::from_mut_slice(&mut buf[..])]
-        }).collect();
-
-        for iov in &iovs {
-            msgs.push_back(RecvMmsgData {
-                iov,
-                cmsg_buffer: None,
-            })
-        };
+        msgs.extend(
+            receive_buffers
+                .iter_mut()
+                .map(|buf| [IoSliceMut::new(&mut buf[..])]),
+        );
+
+        let mut data = MultiHeaders::<SockaddrIn>::preallocate(
+            NUM_MESSAGES_SENT + 2,
+            None,
+        );
 
-        let res = recvmmsg(rsock, &mut msgs, MsgFlags::MSG_DONTWAIT, None).expect("recvmmsg");
+        let res: Vec<RecvMsg<SockaddrIn>> = recvmmsg(
+            rsock,
+            &mut data,
+            msgs.iter(),
+            MsgFlags::MSG_DONTWAIT,
+            None,
+        )
+        .expect("recvmmsg")
+        .collect();
         assert_eq!(res.len(), NUM_MESSAGES_SENT);
 
         for RecvMsg { address, bytes, .. } in res.into_iter() {
-            assert_eq!(AddressFamily::Inet, address.unwrap().family());
+            assert_eq!(AddressFamily::Inet, address.unwrap().family().unwrap());
             assert_eq!(DATA.len(), bytes);
         }
 
@@ -563,19 +700,66 @@ mod recvfrom {
             assert_eq!(&buf[..DATA.len()], DATA);
         }
     }
+
+    #[test]
+    pub fn udp_inet6() {
+        let addr = std::net::Ipv6Addr::from_str("::1").unwrap();
+        let rport = 6789;
+        let rstd_sa = SocketAddrV6::new(addr, rport, 0, 0);
+        let raddr = SockaddrIn6::from(rstd_sa);
+        let sport = 6790;
+        let sstd_sa = SocketAddrV6::new(addr, sport, 0, 0);
+        let saddr = SockaddrIn6::from(sstd_sa);
+        let rsock = socket(
+            AddressFamily::Inet6,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("receive socket failed");
+        match bind(rsock, &raddr) {
+            Err(Errno::EADDRNOTAVAIL) => {
+                println!("IPv6 not available, skipping test.");
+                return;
+            }
+            Err(e) => panic!("bind: {}", e),
+            Ok(()) => (),
+        }
+        let ssock = socket(
+            AddressFamily::Inet6,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("send socket failed");
+        bind(ssock, &saddr).unwrap();
+        let from = sendrecv(
+            rsock,
+            ssock,
+            move |s, m, flags| sendto(s, m, &raddr, flags),
+            |_, _| {},
+        );
+        assert_eq!(AddressFamily::Inet6, from.unwrap().family().unwrap());
+        let osent_addr = from.unwrap();
+        let sent_addr = osent_addr.as_sockaddr_in6().unwrap();
+        assert_eq!(sent_addr.ip(), addr);
+        assert_eq!(sent_addr.port(), sport);
+    }
 }
 
 // Test error handling of our recvmsg wrapper
 #[test]
 pub fn test_recvmsg_ebadf() {
     use nix::errno::Errno;
-    use nix::sys::socket::{MsgFlags, recvmsg};
-    use nix::sys::uio::IoVec;
+    use nix::sys::socket::{recvmsg, MsgFlags};
+    use std::io::IoSliceMut;
 
     let mut buf = [0u8; 5];
-    let iov = [IoVec::from_mut_slice(&mut buf[..])];
-    let fd = -1;    // Bad file descriptor
-    let r = recvmsg(fd, &iov, None, MsgFlags::empty());
+    let mut iov = [IoSliceMut::new(&mut buf[..])];
+
+    let fd = -1; // Bad file descriptor
+    let r = recvmsg::<()>(fd, &mut iov, None, MsgFlags::empty());
+
     assert_eq!(r.err().unwrap(), Errno::EBADF);
 }
 
@@ -584,31 +768,47 @@ pub fn test_recvmsg_ebadf() {
 #[cfg_attr(qemu, ignore)]
 #[test]
 pub fn test_scm_rights() {
-    use nix::sys::uio::IoVec;
-    use nix::unistd::{pipe, read, write, close};
-    use nix::sys::socket::{socketpair, sendmsg, recvmsg,
-                           AddressFamily, SockType, SockFlag,
-                           ControlMessage, ControlMessageOwned, MsgFlags};
-
-    let (fd1, fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty())
-                     .unwrap();
+    use nix::sys::socket::{
+        recvmsg, sendmsg, socketpair, AddressFamily, ControlMessage,
+        ControlMessageOwned, MsgFlags, SockFlag, SockType,
+    };
+    use nix::unistd::{close, pipe, read, write};
+    use std::io::{IoSlice, IoSliceMut};
+
+    let (fd1, fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     let (r, w) = pipe().unwrap();
     let mut received_r: Option<RawFd> = None;
 
     {
-        let iov = [IoVec::from_slice(b"hello")];
+        let iov = [IoSlice::new(b"hello")];
         let fds = [r];
         let cmsg = ControlMessage::ScmRights(&fds);
-        assert_eq!(sendmsg(fd1, &iov, &[cmsg], MsgFlags::empty(), None).unwrap(), 5);
+        assert_eq!(
+            sendmsg::<()>(fd1, &iov, &[cmsg], MsgFlags::empty(), None).unwrap(),
+            5
+        );
         close(r).unwrap();
         close(fd1).unwrap();
     }
 
     {
         let mut buf = [0u8; 5];
-        let iov = [IoVec::from_mut_slice(&mut buf[..])];
+
+        let mut iov = [IoSliceMut::new(&mut buf[..])];
         let mut cmsgspace = cmsg_space!([RawFd; 1]);
-        let msg = recvmsg(fd2, &iov, Some(&mut cmsgspace), MsgFlags::empty()).unwrap();
+        let msg = recvmsg::<()>(
+            fd2,
+            &mut iov,
+            Some(&mut cmsgspace),
+            MsgFlags::empty(),
+        )
+        .unwrap();
 
         for cmsg in msg.cmsgs() {
             if let ControlMessageOwned::ScmRights(fd) = cmsg {
@@ -620,7 +820,9 @@ pub fn test_scm_rights() {
             }
         }
         assert_eq!(msg.bytes, 5);
-        assert!(!msg.flags.intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
         close(fd2).unwrap();
     }
 
@@ -635,16 +837,17 @@ pub fn test_scm_rights() {
 }
 
 // Disable the test on emulated platforms due to not enabled support of AF_ALG in QEMU from rust cross
-#[cfg(any(target_os = "linux", target_os= "android"))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[cfg_attr(qemu, ignore)]
 #[test]
 pub fn test_af_alg_cipher() {
-    use nix::sys::uio::IoVec;
-    use nix::unistd::read;
-    use nix::sys::socket::{socket, sendmsg, bind, accept, setsockopt,
-                           AddressFamily, SockType, SockFlag, SockAddr,
-                           ControlMessage, MsgFlags};
     use nix::sys::socket::sockopt::AlgSetKey;
+    use nix::sys::socket::{
+        accept, bind, sendmsg, setsockopt, socket, AddressFamily, AlgAddr,
+        ControlMessage, MsgFlags, SockFlag, SockType,
+    };
+    use nix::unistd::read;
+    use std::io::IoSlice;
 
     skip_if_cirrus!("Fails for an unknown reason Cirrus CI.  Bug #1352");
     // Travis's seccomp profile blocks AF_ALG
@@ -662,37 +865,46 @@ pub fn test_af_alg_cipher() {
     let payload_len = 256;
     let payload = vec![2u8; payload_len];
 
-    let sock = socket(AddressFamily::Alg, SockType::SeqPacket, SockFlag::empty(), None)
-        .expect("socket failed");
+    let sock = socket(
+        AddressFamily::Alg,
+        SockType::SeqPacket,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
 
-    let sockaddr = SockAddr::new_alg(alg_type, alg_name);
+    let sockaddr = AlgAddr::new(alg_type, alg_name);
     bind(sock, &sockaddr).expect("bind failed");
 
-    if let SockAddr::Alg(alg) = sockaddr {
-        assert_eq!(alg.alg_name().to_string_lossy(), alg_name);
-        assert_eq!(alg.alg_type().to_string_lossy(), alg_type);
-    } else {
-        panic!("unexpected SockAddr");
-    }
+    assert_eq!(sockaddr.alg_name().to_string_lossy(), alg_name);
+    assert_eq!(sockaddr.alg_type().to_string_lossy(), alg_type);
 
     setsockopt(sock, AlgSetKey::default(), &key).expect("setsockopt");
     let session_socket = accept(sock).expect("accept failed");
 
-    let msgs = [ControlMessage::AlgSetOp(&libc::ALG_OP_ENCRYPT), ControlMessage::AlgSetIv(iv.as_slice())];
-    let iov = IoVec::from_slice(&payload);
-    sendmsg(session_socket, &[iov], &msgs, MsgFlags::empty(), None).expect("sendmsg encrypt");
+    let msgs = [
+        ControlMessage::AlgSetOp(&libc::ALG_OP_ENCRYPT),
+        ControlMessage::AlgSetIv(iv.as_slice()),
+    ];
+    let iov = IoSlice::new(&payload);
+    sendmsg::<()>(session_socket, &[iov], &msgs, MsgFlags::empty(), None)
+        .expect("sendmsg encrypt");
 
     // allocate buffer for encrypted data
     let mut encrypted = vec![0u8; payload_len];
     let num_bytes = read(session_socket, &mut encrypted).expect("read encrypt");
     assert_eq!(num_bytes, payload_len);
 
-    let iov = IoVec::from_slice(&encrypted);
+    let iov = IoSlice::new(&encrypted);
 
     let iv = vec![1u8; iv_len];
 
-    let msgs = [ControlMessage::AlgSetOp(&libc::ALG_OP_DECRYPT), ControlMessage::AlgSetIv(iv.as_slice())];
-    sendmsg(session_socket, &[iov], &msgs, MsgFlags::empty(), None).expect("sendmsg decrypt");
+    let msgs = [
+        ControlMessage::AlgSetOp(&libc::ALG_OP_DECRYPT),
+        ControlMessage::AlgSetIv(iv.as_slice()),
+    ];
+    sendmsg::<()>(session_socket, &[iov], &msgs, MsgFlags::empty(), None)
+        .expect("sendmsg decrypt");
 
     // allocate buffer for decrypted data
     let mut decrypted = vec![0u8; payload_len];
@@ -704,18 +916,19 @@ pub fn test_af_alg_cipher() {
 
 // Disable the test on emulated platforms due to not enabled support of AF_ALG
 // in QEMU from rust cross
-#[cfg(any(target_os = "linux", target_os= "android"))]
+#[cfg(any(target_os = "linux", target_os = "android"))]
 #[cfg_attr(qemu, ignore)]
 #[test]
 pub fn test_af_alg_aead() {
     use libc::{ALG_OP_DECRYPT, ALG_OP_ENCRYPT};
     use nix::fcntl::{fcntl, FcntlArg, OFlag};
-    use nix::sys::uio::IoVec;
-    use nix::unistd::{read, close};
-    use nix::sys::socket::{socket, sendmsg, bind, accept, setsockopt,
-                           AddressFamily, SockType, SockFlag, SockAddr,
-                           ControlMessage, MsgFlags};
-    use nix::sys::socket::sockopt::{AlgSetKey, AlgSetAeadAuthSize};
+    use nix::sys::socket::sockopt::{AlgSetAeadAuthSize, AlgSetKey};
+    use nix::sys::socket::{
+        accept, bind, sendmsg, setsockopt, socket, AddressFamily, AlgAddr,
+        ControlMessage, MsgFlags, SockFlag, SockType,
+    };
+    use nix::unistd::{close, read};
+    use std::io::IoSlice;
 
     skip_if_cirrus!("Fails for an unknown reason Cirrus CI.  Bug #1352");
     // Travis's seccomp profile blocks AF_ALG
@@ -734,7 +947,8 @@ pub fn test_af_alg_aead() {
     let iv = vec![1u8; iv_len];
     // 256-bytes plain payload
     let payload_len = 256;
-    let mut payload = vec![2u8; payload_len + (assoc_size as usize) + auth_size];
+    let mut payload =
+        vec![2u8; payload_len + (assoc_size as usize) + auth_size];
 
     for i in 0..assoc_size {
         payload[i as usize] = 10;
@@ -746,25 +960,35 @@ pub fn test_af_alg_aead() {
         payload[len - 1 - i] = 0;
     }
 
-    let sock = socket(AddressFamily::Alg, SockType::SeqPacket, SockFlag::empty(), None)
-        .expect("socket failed");
+    let sock = socket(
+        AddressFamily::Alg,
+        SockType::SeqPacket,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
 
-    let sockaddr = SockAddr::new_alg(alg_type, alg_name);
+    let sockaddr = AlgAddr::new(alg_type, alg_name);
     bind(sock, &sockaddr).expect("bind failed");
 
-    setsockopt(sock, AlgSetAeadAuthSize, &auth_size).expect("setsockopt AlgSetAeadAuthSize");
+    setsockopt(sock, AlgSetAeadAuthSize, &auth_size)
+        .expect("setsockopt AlgSetAeadAuthSize");
     setsockopt(sock, AlgSetKey::default(), &key).expect("setsockopt AlgSetKey");
     let session_socket = accept(sock).expect("accept failed");
 
     let msgs = [
         ControlMessage::AlgSetOp(&ALG_OP_ENCRYPT),
         ControlMessage::AlgSetIv(iv.as_slice()),
-        ControlMessage::AlgSetAeadAssoclen(&assoc_size)];
-    let iov = IoVec::from_slice(&payload);
-    sendmsg(session_socket, &[iov], &msgs, MsgFlags::empty(), None).expect("sendmsg encrypt");
+        ControlMessage::AlgSetAeadAssoclen(&assoc_size),
+    ];
+
+    let iov = IoSlice::new(&payload);
+    sendmsg::<()>(session_socket, &[iov], &msgs, MsgFlags::empty(), None)
+        .expect("sendmsg encrypt");
 
     // allocate buffer for encrypted data
-    let mut encrypted = vec![0u8; (assoc_size as usize) + payload_len + auth_size];
+    let mut encrypted =
+        vec![0u8; (assoc_size as usize) + payload_len + auth_size];
     let num_bytes = read(session_socket, &mut encrypted).expect("read encrypt");
     assert_eq!(num_bytes, payload_len + auth_size + (assoc_size as usize));
     close(session_socket).expect("close");
@@ -773,7 +997,7 @@ pub fn test_af_alg_aead() {
         encrypted[i as usize] = 10;
     }
 
-    let iov = IoVec::from_slice(&encrypted);
+    let iov = IoSlice::new(&encrypted);
 
     let iv = vec![1u8; iv_len];
 
@@ -784,19 +1008,25 @@ pub fn test_af_alg_aead() {
         ControlMessage::AlgSetIv(iv.as_slice()),
         ControlMessage::AlgSetAeadAssoclen(&assoc_size),
     ];
-    sendmsg(session_socket, &[iov], &msgs, MsgFlags::empty(), None).expect("sendmsg decrypt");
+    sendmsg::<()>(session_socket, &[iov], &msgs, MsgFlags::empty(), None)
+        .expect("sendmsg decrypt");
 
     // allocate buffer for decrypted data
-    let mut decrypted = vec![0u8; payload_len + (assoc_size as usize) + auth_size];
+    let mut decrypted =
+        vec![0u8; payload_len + (assoc_size as usize) + auth_size];
     // Starting with kernel 4.9, the interface changed slightly such that the
     // authentication tag memory is only needed in the output buffer for encryption
     // and in the input buffer for decryption.
     // Do not block on read, as we may have fewer bytes than buffer size
-    fcntl(session_socket,FcntlArg::F_SETFL(OFlag::O_NONBLOCK)).expect("fcntl non_blocking");
+    fcntl(session_socket, FcntlArg::F_SETFL(OFlag::O_NONBLOCK))
+        .expect("fcntl non_blocking");
     let num_bytes = read(session_socket, &mut decrypted).expect("read decrypt");
 
     assert!(num_bytes >= payload_len + (assoc_size as usize));
-    assert_eq!(decrypted[(assoc_size as usize)..(payload_len + (assoc_size as usize))], payload[(assoc_size as usize)..payload_len + (assoc_size as usize)]);
+    assert_eq!(
+        decrypted[(assoc_size as usize)..(payload_len + (assoc_size as usize))],
+        payload[(assoc_size as usize)..payload_len + (assoc_size as usize)]
+    );
 }
 
 // Verify `ControlMessage::Ipv4PacketInfo` for `sendmsg`.
@@ -806,56 +1036,50 @@ pub fn test_af_alg_aead() {
 // This would be a more interesting test if we could assume that the test host
 // has more than one IP address (since we could select a different address to
 // test from).
-#[cfg(any(target_os = "linux",
-        target_os = "macos",
-        target_os = "netbsd"))]
+#[cfg(any(target_os = "linux", target_os = "macos", target_os = "netbsd"))]
 #[test]
 pub fn test_sendmsg_ipv4packetinfo() {
     use cfg_if::cfg_if;
-    use nix::sys::uio::IoVec;
-    use nix::sys::socket::{socket, sendmsg, bind,
-                           AddressFamily, SockType, SockFlag, SockAddr,
-                           ControlMessage, MsgFlags};
-
-    let sock = socket(AddressFamily::Inet,
-                      SockType::Datagram,
-                      SockFlag::empty(),
-                      None)
-        .expect("socket failed");
+    use nix::sys::socket::{
+        bind, sendmsg, socket, AddressFamily, ControlMessage, MsgFlags,
+        SockFlag, SockType, SockaddrIn,
+    };
+    use std::io::IoSlice;
+
+    let sock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
 
-    let std_sa = SocketAddr::from_str("127.0.0.1:4000").unwrap();
-    let inet_addr = InetAddr::from_std(&std_sa);
-    let sock_addr = SockAddr::new_inet(inet_addr);
+    let sock_addr = SockaddrIn::new(127, 0, 0, 1, 4000);
 
     bind(sock, &sock_addr).expect("bind failed");
 
     let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-    let iov = [IoVec::from_slice(&slice)];
-
-    if let InetAddr::V4(sin) = inet_addr {
-        cfg_if! {
-            if #[cfg(target_os = "netbsd")] {
-                let _dontcare = sin;
-                let pi = libc::in_pktinfo {
-                    ipi_ifindex: 0, /* Unspecified interface */
-                    ipi_addr: libc::in_addr { s_addr: 0 },
-                };
-            } else {
-                let pi = libc::in_pktinfo {
-                    ipi_ifindex: 0, /* Unspecified interface */
-                    ipi_addr: libc::in_addr { s_addr: 0 },
-                    ipi_spec_dst: sin.sin_addr,
-                };
-            }
+    let iov = [IoSlice::new(&slice)];
+
+    cfg_if! {
+        if #[cfg(target_os = "netbsd")] {
+            let pi = libc::in_pktinfo {
+                ipi_ifindex: 0, /* Unspecified interface */
+                ipi_addr: libc::in_addr { s_addr: 0 },
+            };
+        } else {
+            let pi = libc::in_pktinfo {
+                ipi_ifindex: 0, /* Unspecified interface */
+                ipi_addr: libc::in_addr { s_addr: 0 },
+                ipi_spec_dst: sock_addr.as_ref().sin_addr,
+            };
         }
+    }
 
-        let cmsg = [ControlMessage::Ipv4PacketInfo(&pi)];
+    let cmsg = [ControlMessage::Ipv4PacketInfo(&pi)];
 
-        sendmsg(sock, &iov, &cmsg, MsgFlags::empty(), Some(&sock_addr))
-            .expect("sendmsg");
-    } else {
-        panic!("No IPv4 addresses available for testing?");
-    }
+    sendmsg(sock, &iov, &cmsg, MsgFlags::empty(), Some(&sock_addr))
+        .expect("sendmsg");
 }
 
 // Verify `ControlMessage::Ipv6PacketInfo` for `sendmsg`.
@@ -866,27 +1090,31 @@ pub fn test_sendmsg_ipv4packetinfo() {
 // This would be a more interesting test if we could assume that the test host
 // has more than one IP address (since we could select a different address to
 // test from).
-#[cfg(any(target_os = "linux",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "freebsd"
+))]
 #[test]
 pub fn test_sendmsg_ipv6packetinfo() {
     use nix::errno::Errno;
-    use nix::sys::uio::IoVec;
-    use nix::sys::socket::{socket, sendmsg, bind,
-                           AddressFamily, SockType, SockFlag, SockAddr,
-                           ControlMessage, MsgFlags};
-
-    let sock = socket(AddressFamily::Inet6,
-                      SockType::Datagram,
-                      SockFlag::empty(),
-                      None)
-        .expect("socket failed");
+    use nix::sys::socket::{
+        bind, sendmsg, socket, AddressFamily, ControlMessage, MsgFlags,
+        SockFlag, SockType, SockaddrIn6,
+    };
+    use std::io::IoSlice;
+
+    let sock = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
 
-    let std_sa = SocketAddr::from_str("[::1]:6000").unwrap();
-    let inet_addr = InetAddr::from_std(&std_sa);
-    let sock_addr = SockAddr::new_inet(inet_addr);
+    let std_sa = SocketAddrV6::from_str("[::1]:6000").unwrap();
+    let sock_addr: SockaddrIn6 = SockaddrIn6::from(std_sa);
 
     if let Err(Errno::EADDRNOTAVAIL) = bind(sock, &sock_addr) {
         println!("IPv6 not available, skipping test.");
@@ -894,21 +1122,75 @@ pub fn test_sendmsg_ipv6packetinfo() {
     }
 
     let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-    let iov = [IoVec::from_slice(&slice)];
+    let iov = [IoSlice::new(&slice)];
 
-    if let InetAddr::V6(sin) = inet_addr {
-        let pi = libc::in6_pktinfo {
-            ipi6_ifindex: 0, /* Unspecified interface */
-            ipi6_addr: sin.sin6_addr,
-        };
+    let pi = libc::in6_pktinfo {
+        ipi6_ifindex: 0, /* Unspecified interface */
+        ipi6_addr: sock_addr.as_ref().sin6_addr,
+    };
 
-        let cmsg = [ControlMessage::Ipv6PacketInfo(&pi)];
+    let cmsg = [ControlMessage::Ipv6PacketInfo(&pi)];
 
-        sendmsg(sock, &iov, &cmsg, MsgFlags::empty(), Some(&sock_addr))
-            .expect("sendmsg");
-    } else {
-        println!("No IPv6 addresses available for testing: skipping testing Ipv6PacketInfo");
-    }
+    sendmsg::<SockaddrIn6>(
+        sock,
+        &iov,
+        &cmsg,
+        MsgFlags::empty(),
+        Some(&sock_addr),
+    )
+    .expect("sendmsg");
+}
+
+// Verify that ControlMessage::Ipv4SendSrcAddr works for sendmsg. This
+// creates a UDP socket bound to all local interfaces (0.0.0.0). It then
+// sends message to itself at 127.0.0.1 while explicitly specifying
+// 127.0.0.1 as the source address through an Ipv4SendSrcAddr
+// (IP_SENDSRCADDR) control message.
+//
+// Note that binding to 0.0.0.0 is *required* on FreeBSD; sendmsg
+// returns EINVAL otherwise. (See FreeBSD's ip(4) man page.)
+#[cfg(any(
+    target_os = "netbsd",
+    target_os = "freebsd",
+    target_os = "openbsd",
+    target_os = "dragonfly",
+))]
+#[test]
+pub fn test_sendmsg_ipv4sendsrcaddr() {
+    use nix::sys::socket::{
+        bind, sendmsg, socket, AddressFamily, ControlMessage, MsgFlags,
+        SockFlag, SockType, SockaddrIn,
+    };
+    use std::io::IoSlice;
+
+    let sock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
+
+    let unspec_sock_addr = SockaddrIn::new(0, 0, 0, 0, 0);
+    bind(sock, &unspec_sock_addr).expect("bind failed");
+    let bound_sock_addr: SockaddrIn = getsockname(sock).unwrap();
+    let localhost_sock_addr: SockaddrIn =
+        SockaddrIn::new(127, 0, 0, 1, bound_sock_addr.port());
+
+    let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
+    let iov = [IoSlice::new(&slice)];
+    let cmsg = [ControlMessage::Ipv4SendSrcAddr(
+        &localhost_sock_addr.as_ref().sin_addr,
+    )];
+
+    sendmsg(
+        sock,
+        &iov,
+        &cmsg,
+        MsgFlags::empty(),
+        Some(&localhost_sock_addr),
+    )
+    .expect("sendmsg");
 }
 
 /// Tests that passing multiple fds using a single `ControlMessage` works.
@@ -917,46 +1199,55 @@ pub fn test_sendmsg_ipv6packetinfo() {
 #[cfg_attr(qemu, ignore)]
 #[test]
 fn test_scm_rights_single_cmsg_multiple_fds() {
+    use nix::sys::socket::{
+        recvmsg, sendmsg, ControlMessage, ControlMessageOwned, MsgFlags,
+    };
+    use std::io::{IoSlice, IoSliceMut};
+    use std::os::unix::io::{AsRawFd, RawFd};
     use std::os::unix::net::UnixDatagram;
-    use std::os::unix::io::{RawFd, AsRawFd};
     use std::thread;
-    use nix::sys::socket::{ControlMessage, ControlMessageOwned, MsgFlags,
-        sendmsg, recvmsg};
-    use nix::sys::uio::IoVec;
 
     let (send, receive) = UnixDatagram::pair().unwrap();
     let thread = thread::spawn(move || {
         let mut buf = [0u8; 8];
-        let iovec = [IoVec::from_mut_slice(&mut buf)];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
+
         let mut space = cmsg_space!([RawFd; 2]);
-        let msg = recvmsg(
+        let msg = recvmsg::<()>(
             receive.as_raw_fd(),
-            &iovec,
+            &mut iovec,
             Some(&mut space),
-            MsgFlags::empty()
-        ).unwrap();
-        assert!(!msg.flags.intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+            MsgFlags::empty(),
+        )
+        .unwrap();
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
 
         let mut cmsgs = msg.cmsgs();
         match cmsgs.next() {
             Some(ControlMessageOwned::ScmRights(fds)) => {
-                assert_eq!(fds.len(), 2,
-                           "unexpected fd count (expected 2 fds, got {})",
-                           fds.len());
-            },
+                assert_eq!(
+                    fds.len(),
+                    2,
+                    "unexpected fd count (expected 2 fds, got {})",
+                    fds.len()
+                );
+            }
             _ => panic!(),
         }
         assert!(cmsgs.next().is_none(), "unexpected control msg");
 
         assert_eq!(msg.bytes, 8);
-        assert_eq!(iovec[0].as_slice(), [1u8, 2, 3, 4, 5, 6, 7, 8]);
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
     });
 
     let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-    let iov = [IoVec::from_slice(&slice)];
-    let fds = [libc::STDIN_FILENO, libc::STDOUT_FILENO];    // pass stdin and stdout
+    let iov = [IoSlice::new(&slice)];
+    let fds = [libc::STDIN_FILENO, libc::STDOUT_FILENO]; // pass stdin and stdout
     let cmsg = [ControlMessage::ScmRights(&fds)];
-    sendmsg(send.as_raw_fd(), &iov, &cmsg, MsgFlags::empty(), None).unwrap();
+    sendmsg::<()>(send.as_raw_fd(), &iov, &cmsg, MsgFlags::empty(), None)
+        .unwrap();
     thread.join().unwrap();
 }
 
@@ -966,30 +1257,49 @@ fn test_scm_rights_single_cmsg_multiple_fds() {
 // raw `sendmsg`.
 #[test]
 pub fn test_sendmsg_empty_cmsgs() {
-    use nix::sys::uio::IoVec;
+    use nix::sys::socket::{
+        recvmsg, sendmsg, socketpair, AddressFamily, MsgFlags, SockFlag,
+        SockType,
+    };
     use nix::unistd::close;
-    use nix::sys::socket::{socketpair, sendmsg, recvmsg,
-                           AddressFamily, SockType, SockFlag, MsgFlags};
+    use std::io::{IoSlice, IoSliceMut};
 
-    let (fd1, fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty())
-                     .unwrap();
+    let (fd1, fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
 
     {
-        let iov = [IoVec::from_slice(b"hello")];
-        assert_eq!(sendmsg(fd1, &iov, &[], MsgFlags::empty(), None).unwrap(), 5);
+        let iov = [IoSlice::new(b"hello")];
+        assert_eq!(
+            sendmsg::<()>(fd1, &iov, &[], MsgFlags::empty(), None).unwrap(),
+            5
+        );
         close(fd1).unwrap();
     }
 
     {
         let mut buf = [0u8; 5];
-        let iov = [IoVec::from_mut_slice(&mut buf[..])];
+        let mut iov = [IoSliceMut::new(&mut buf[..])];
+
         let mut cmsgspace = cmsg_space!([RawFd; 1]);
-        let msg = recvmsg(fd2, &iov, Some(&mut cmsgspace), MsgFlags::empty()).unwrap();
+        let msg = recvmsg::<()>(
+            fd2,
+            &mut iov,
+            Some(&mut cmsgspace),
+            MsgFlags::empty(),
+        )
+        .unwrap();
 
         for _ in msg.cmsgs() {
             panic!("unexpected cmsg");
         }
-        assert!(!msg.flags.intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
         assert_eq!(msg.bytes, 5);
         close(fd2).unwrap();
     }
@@ -1003,37 +1313,53 @@ pub fn test_sendmsg_empty_cmsgs() {
 ))]
 #[test]
 fn test_scm_credentials() {
-    use nix::sys::uio::IoVec;
-    use nix::unistd::{close, getpid, getuid, getgid};
-    use nix::sys::socket::{socketpair, sendmsg, recvmsg,
-                           AddressFamily, SockType, SockFlag,
-                           ControlMessage, ControlMessageOwned, MsgFlags,
-                           UnixCredentials};
+    use nix::sys::socket::{
+        recvmsg, sendmsg, socketpair, AddressFamily, ControlMessage,
+        ControlMessageOwned, MsgFlags, SockFlag, SockType, UnixCredentials,
+    };
     #[cfg(any(target_os = "android", target_os = "linux"))]
     use nix::sys::socket::{setsockopt, sockopt::PassCred};
+    use nix::unistd::{close, getgid, getpid, getuid};
+    use std::io::{IoSlice, IoSliceMut};
 
-    let (send, recv) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty())
-        .unwrap();
+    let (send, recv) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     #[cfg(any(target_os = "android", target_os = "linux"))]
     setsockopt(recv, PassCred, &true).unwrap();
 
     {
-        let iov = [IoVec::from_slice(b"hello")];
+        let iov = [IoSlice::new(b"hello")];
         #[cfg(any(target_os = "android", target_os = "linux"))]
         let cred = UnixCredentials::new();
         #[cfg(any(target_os = "android", target_os = "linux"))]
         let cmsg = ControlMessage::ScmCredentials(&cred);
         #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
         let cmsg = ControlMessage::ScmCreds;
-        assert_eq!(sendmsg(send, &iov, &[cmsg], MsgFlags::empty(), None).unwrap(), 5);
+        assert_eq!(
+            sendmsg::<()>(send, &iov, &[cmsg], MsgFlags::empty(), None)
+                .unwrap(),
+            5
+        );
         close(send).unwrap();
     }
 
     {
         let mut buf = [0u8; 5];
-        let iov = [IoVec::from_mut_slice(&mut buf[..])];
+        let mut iov = [IoSliceMut::new(&mut buf[..])];
+
         let mut cmsgspace = cmsg_space!(UnixCredentials);
-        let msg = recvmsg(recv, &iov, Some(&mut cmsgspace), MsgFlags::empty()).unwrap();
+        let msg = recvmsg::<()>(
+            recv,
+            &mut iov,
+            Some(&mut cmsgspace),
+            MsgFlags::empty(),
+        )
+        .unwrap();
         let mut received_cred = None;
 
         for cmsg in msg.cmsgs() {
@@ -1052,7 +1378,9 @@ fn test_scm_credentials() {
         }
         received_cred.expect("no creds received");
         assert_eq!(msg.bytes, 5);
-        assert!(!msg.flags.intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
         close(recv).unwrap();
     }
 }
@@ -1084,41 +1412,53 @@ fn test_too_large_cmsgspace() {
 #[cfg(any(target_os = "android", target_os = "linux"))]
 fn test_impl_scm_credentials_and_rights(mut space: Vec<u8>) {
     use libc::ucred;
-    use nix::sys::uio::IoVec;
-    use nix::unistd::{pipe, write, close, getpid, getuid, getgid};
-    use nix::sys::socket::{socketpair, sendmsg, recvmsg, setsockopt,
-                           SockType, SockFlag,
-                           ControlMessage, ControlMessageOwned, MsgFlags};
     use nix::sys::socket::sockopt::PassCred;
+    use nix::sys::socket::{
+        recvmsg, sendmsg, setsockopt, socketpair, ControlMessage,
+        ControlMessageOwned, MsgFlags, SockFlag, SockType,
+    };
+    use nix::unistd::{close, getgid, getpid, getuid, pipe, write};
+    use std::io::{IoSlice, IoSliceMut};
 
-    let (send, recv) = socketpair(AddressFamily::Unix, SockType::Stream, None, SockFlag::empty())
-        .unwrap();
+    let (send, recv) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     setsockopt(recv, PassCred, &true).unwrap();
 
     let (r, w) = pipe().unwrap();
     let mut received_r: Option<RawFd> = None;
 
     {
-        let iov = [IoVec::from_slice(b"hello")];
+        let iov = [IoSlice::new(b"hello")];
         let cred = ucred {
             pid: getpid().as_raw(),
             uid: getuid().as_raw(),
             gid: getgid().as_raw(),
-        }.into();
+        }
+        .into();
         let fds = [r];
         let cmsgs = [
             ControlMessage::ScmCredentials(&cred),
             ControlMessage::ScmRights(&fds),
         ];
-        assert_eq!(sendmsg(send, &iov, &cmsgs, MsgFlags::empty(), None).unwrap(), 5);
+        assert_eq!(
+            sendmsg::<()>(send, &iov, &cmsgs, MsgFlags::empty(), None).unwrap(),
+            5
+        );
         close(r).unwrap();
         close(send).unwrap();
     }
 
     {
         let mut buf = [0u8; 5];
-        let iov = [IoVec::from_mut_slice(&mut buf[..])];
-        let msg = recvmsg(recv, &iov, Some(&mut space), MsgFlags::empty()).unwrap();
+        let mut iov = [IoSliceMut::new(&mut buf[..])];
+        let msg =
+            recvmsg::<()>(recv, &mut iov, Some(&mut space), MsgFlags::empty())
+                .unwrap();
         let mut received_cred = None;
 
         assert_eq!(msg.cmsgs().count(), 2, "expected 2 cmsgs");
@@ -1142,7 +1482,9 @@ fn test_impl_scm_credentials_and_rights(mut space: Vec<u8>) {
         }
         received_cred.expect("no creds received");
         assert_eq!(msg.bytes, 5);
-        assert!(!msg.flags.intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
         close(recv).unwrap();
     }
 
@@ -1158,23 +1500,33 @@ fn test_impl_scm_credentials_and_rights(mut space: Vec<u8>) {
 
 // Test creating and using named unix domain sockets
 #[test]
-pub fn test_unixdomain() {
-    use nix::sys::socket::{SockType, SockFlag};
-    use nix::sys::socket::{bind, socket, connect, listen, accept, SockAddr};
-    use nix::unistd::{read, write, close};
+pub fn test_named_unixdomain() {
+    use nix::sys::socket::{accept, bind, connect, listen, socket, UnixAddr};
+    use nix::sys::socket::{SockFlag, SockType};
+    use nix::unistd::{close, read, write};
     use std::thread;
 
     let tempdir = tempfile::tempdir().unwrap();
     let sockname = tempdir.path().join("sock");
-    let s1 = socket(AddressFamily::Unix, SockType::Stream,
-                    SockFlag::empty(), None).expect("socket failed");
-    let sockaddr = SockAddr::new_unix(&sockname).unwrap();
+    let s1 = socket(
+        AddressFamily::Unix,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
+    let sockaddr = UnixAddr::new(&sockname).unwrap();
     bind(s1, &sockaddr).expect("bind failed");
     listen(s1, 10).expect("listen failed");
 
     let thr = thread::spawn(move || {
-        let s2 = socket(AddressFamily::Unix, SockType::Stream, SockFlag::empty(), None)
-                 .expect("socket failed");
+        let s2 = socket(
+            AddressFamily::Unix,
+            SockType::Stream,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("socket failed");
         connect(s2, &sockaddr).expect("connect failed");
         write(s2, b"hello").expect("write failed");
         close(s2).unwrap();
@@ -1182,7 +1534,7 @@ pub fn test_unixdomain() {
 
     let s3 = accept(s1).expect("accept failed");
 
-    let mut buf = [0;5];
+    let mut buf = [0; 5];
     read(s3, &mut buf).unwrap();
     close(s3).unwrap();
     close(s1).unwrap();
@@ -1191,18 +1543,81 @@ pub fn test_unixdomain() {
     assert_eq!(&buf[..], b"hello");
 }
 
+// Test using unnamed unix domain addresses
+#[cfg(any(target_os = "android", target_os = "linux"))]
+#[test]
+pub fn test_unnamed_unixdomain() {
+    use nix::sys::socket::{getsockname, socketpair};
+    use nix::sys::socket::{SockFlag, SockType};
+    use nix::unistd::close;
+
+    let (fd_1, fd_2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .expect("socketpair failed");
+
+    let addr_1: UnixAddr = getsockname(fd_1).expect("getsockname failed");
+    assert!(addr_1.is_unnamed());
+
+    close(fd_1).unwrap();
+    close(fd_2).unwrap();
+}
+
+// Test creating and using unnamed unix domain addresses for autobinding sockets
+#[cfg(any(target_os = "android", target_os = "linux"))]
+#[test]
+pub fn test_unnamed_unixdomain_autobind() {
+    use nix::sys::socket::{bind, getsockname, socket};
+    use nix::sys::socket::{SockFlag, SockType};
+    use nix::unistd::close;
+
+    let fd = socket(
+        AddressFamily::Unix,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
+
+    // unix(7): "If a bind(2) call specifies addrlen as `sizeof(sa_family_t)`, or [...], then the
+    // socket is autobound to an abstract address"
+    bind(fd, &UnixAddr::new_unnamed()).expect("bind failed");
+
+    let addr: UnixAddr = getsockname(fd).expect("getsockname failed");
+    let addr = addr.as_abstract().unwrap();
+
+    // changed from 8 to 5 bytes in Linux 2.3.15, and rust's minimum supported Linux version is 3.2
+    // (as of 2022-11)
+    assert_eq!(addr.len(), 5);
+
+    close(fd).unwrap();
+}
+
 // Test creating and using named system control sockets
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[test]
 pub fn test_syscontrol() {
     use nix::errno::Errno;
-    use nix::sys::socket::{socket, SockAddr, SockType, SockFlag, SockProtocol};
+    use nix::sys::socket::{
+        socket, SockFlag, SockProtocol, SockType, SysControlAddr,
+    };
 
-    let fd = socket(AddressFamily::System, SockType::Datagram,
-                    SockFlag::empty(), SockProtocol::KextControl)
-             .expect("socket failed");
-    let _sockaddr = SockAddr::new_sys_control(fd, "com.apple.net.utun_control", 0).expect("resolving sys_control name failed");
-    assert_eq!(SockAddr::new_sys_control(fd, "foo.bar.lol", 0).err(), Some(Errno::ENOENT));
+    let fd = socket(
+        AddressFamily::System,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::KextControl,
+    )
+    .expect("socket failed");
+    SysControlAddr::from_name(fd, "com.apple.net.utun_control", 0)
+        .expect("resolving sys_control name failed");
+    assert_eq!(
+        SysControlAddr::from_name(fd, "foo.bar.lol", 0).err(),
+        Some(Errno::ENOENT)
+    );
 
     // requires root privileges
     // connect(fd, &sockaddr).expect("connect failed");
@@ -1217,42 +1632,30 @@ pub fn test_syscontrol() {
     target_os = "netbsd",
     target_os = "openbsd",
 ))]
-fn loopback_address(family: AddressFamily) -> Option<nix::ifaddrs::InterfaceAddress> {
-    use std::io;
-    use std::io::Write;
+fn loopback_address(
+    family: AddressFamily,
+) -> Option<nix::ifaddrs::InterfaceAddress> {
     use nix::ifaddrs::getifaddrs;
     use nix::net::if_::*;
+    use nix::sys::socket::SockaddrLike;
+    use std::io;
+    use std::io::Write;
 
-    let addrs = match getifaddrs() {
+    let mut addrs = match getifaddrs() {
         Ok(iter) => iter,
         Err(e) => {
             let stdioerr = io::stderr();
             let mut handle = stdioerr.lock();
             writeln!(handle, "getifaddrs: {:?}", e).unwrap();
             return None;
-        },
+        }
     };
     // return first address matching family
-    for ifaddr in addrs {
-        if ifaddr.flags.contains(InterfaceFlags::IFF_LOOPBACK) {
-            match ifaddr.address {
-                Some(SockAddr::Inet(InetAddr::V4(..))) => {
-                    match family {
-                        AddressFamily::Inet => return Some(ifaddr),
-                        _ => continue
-                    }
-                },
-                Some(SockAddr::Inet(InetAddr::V6(..))) => {
-                    match family {
-                        AddressFamily::Inet6 => return Some(ifaddr),
-                        _ => continue
-                    }
-                },
-                _ => continue,
-            }
-        }
-    }
-    None
+    addrs.find(|ifaddr| {
+        ifaddr.flags.contains(InterfaceFlags::IFF_LOOPBACK)
+            && ifaddr.address.as_ref().and_then(SockaddrLike::family)
+                == Some(family)
+    })
 }
 
 #[cfg(any(
@@ -1263,84 +1666,89 @@ fn loopback_address(family: AddressFamily) -> Option<nix::ifaddrs::InterfaceAddr
     target_os = "netbsd",
 ))]
 // qemu doesn't seem to be emulating this correctly in these architectures
-#[cfg_attr(all(
-    qemu,
-    any(
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "powerpc64",
-    )
-), ignore)]
+#[cfg_attr(
+    all(
+        qemu,
+        any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc64",
+        )
+    ),
+    ignore
+)]
 #[test]
 pub fn test_recv_ipv4pktinfo() {
+    use nix::net::if_::*;
     use nix::sys::socket::sockopt::Ipv4PacketInfo;
-    use nix::sys::socket::{bind, SockFlag, SockType};
+    use nix::sys::socket::{bind, SockFlag, SockType, SockaddrIn};
     use nix::sys::socket::{getsockname, setsockopt, socket};
     use nix::sys::socket::{recvmsg, sendmsg, ControlMessageOwned, MsgFlags};
-    use nix::sys::uio::IoVec;
-    use nix::net::if_::*;
+    use std::io::{IoSlice, IoSliceMut};
 
     let lo_ifaddr = loopback_address(AddressFamily::Inet);
     let (lo_name, lo) = match lo_ifaddr {
-        Some(ifaddr) => (ifaddr.interface_name,
-                         ifaddr.address.expect("Expect IPv4 address on interface")),
+        Some(ifaddr) => (
+            ifaddr.interface_name,
+            ifaddr.address.expect("Expect IPv4 address on interface"),
+        ),
         None => return,
     };
     let receive = socket(
-            AddressFamily::Inet,
-            SockType::Datagram,
-            SockFlag::empty(),
-            None,
-        ).expect("receive socket failed");
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("receive socket failed");
     bind(receive, &lo).expect("bind failed");
-    let sa = getsockname(receive).expect("getsockname failed");
+    let sa: SockaddrIn = getsockname(receive).expect("getsockname failed");
     setsockopt(receive, Ipv4PacketInfo, &true).expect("setsockopt failed");
 
     {
         let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-        let iov = [IoVec::from_slice(&slice)];
+        let iov = [IoSlice::new(&slice)];
 
         let send = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
-        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa)).expect("sendmsg failed");
+        )
+        .expect("send socket failed");
+        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa))
+            .expect("sendmsg failed");
     }
 
     {
         let mut buf = [0u8; 8];
-        let iovec = [IoVec::from_mut_slice(&mut buf)];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
+
         let mut space = cmsg_space!(libc::in_pktinfo);
-        let msg = recvmsg(
+        let msg = recvmsg::<()>(
             receive,
-            &iovec,
+            &mut iovec,
             Some(&mut space),
             MsgFlags::empty(),
-        ).expect("recvmsg failed");
-        assert!(
-            !msg.flags
-                .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC)
-        );
+        )
+        .expect("recvmsg failed");
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
 
         let mut cmsgs = msg.cmsgs();
-        if let Some(ControlMessageOwned::Ipv4PacketInfo(pktinfo)) = cmsgs.next() {
+        if let Some(ControlMessageOwned::Ipv4PacketInfo(pktinfo)) = cmsgs.next()
+        {
             let i = if_nametoindex(lo_name.as_bytes()).expect("if_nametoindex");
             assert_eq!(
-                pktinfo.ipi_ifindex as libc::c_uint,
-                i,
+                pktinfo.ipi_ifindex as libc::c_uint, i,
                 "unexpected ifindex (expected {}, got {})",
-                i,
-                pktinfo.ipi_ifindex
+                i, pktinfo.ipi_ifindex
             );
         }
         assert!(cmsgs.next().is_none(), "unexpected additional control msg");
         assert_eq!(msg.bytes, 8);
-        assert_eq!(
-            iovec[0].as_slice(),
-            [1u8, 2, 3, 4, 5, 6, 7, 8]
-        );
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
     }
 }
 
@@ -1352,27 +1760,32 @@ pub fn test_recv_ipv4pktinfo() {
     target_os = "openbsd",
 ))]
 // qemu doesn't seem to be emulating this correctly in these architectures
-#[cfg_attr(all(
-    qemu,
-    any(
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "powerpc64",
-    )
-), ignore)]
+#[cfg_attr(
+    all(
+        qemu,
+        any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc64",
+        )
+    ),
+    ignore
+)]
 #[test]
 pub fn test_recvif() {
     use nix::net::if_::*;
-    use nix::sys::socket::sockopt::{Ipv4RecvIf, Ipv4RecvDstAddr};
-    use nix::sys::socket::{bind, SockFlag, SockType};
-    use nix::sys::socket::{getsockname, setsockopt, socket, SockAddr};
+    use nix::sys::socket::sockopt::{Ipv4RecvDstAddr, Ipv4RecvIf};
+    use nix::sys::socket::{bind, SockFlag, SockType, SockaddrIn};
+    use nix::sys::socket::{getsockname, setsockopt, socket};
     use nix::sys::socket::{recvmsg, sendmsg, ControlMessageOwned, MsgFlags};
-    use nix::sys::uio::IoVec;
+    use std::io::{IoSlice, IoSliceMut};
 
     let lo_ifaddr = loopback_address(AddressFamily::Inet);
     let (lo_name, lo) = match lo_ifaddr {
-        Some(ifaddr) => (ifaddr.interface_name,
-                         ifaddr.address.expect("Expect IPv4 address on interface")),
+        Some(ifaddr) => (
+            ifaddr.interface_name,
+            ifaddr.address.expect("Expect IPv4 address on interface"),
+        ),
         None => return,
     };
     let receive = socket(
@@ -1380,39 +1793,44 @@ pub fn test_recvif() {
         SockType::Datagram,
         SockFlag::empty(),
         None,
-    ).expect("receive socket failed");
+    )
+    .expect("receive socket failed");
     bind(receive, &lo).expect("bind failed");
-    let sa = getsockname(receive).expect("getsockname failed");
-    setsockopt(receive, Ipv4RecvIf, &true).expect("setsockopt IP_RECVIF failed");
-    setsockopt(receive, Ipv4RecvDstAddr, &true).expect("setsockopt IP_RECVDSTADDR failed");
+    let sa: SockaddrIn = getsockname(receive).expect("getsockname failed");
+    setsockopt(receive, Ipv4RecvIf, &true)
+        .expect("setsockopt IP_RECVIF failed");
+    setsockopt(receive, Ipv4RecvDstAddr, &true)
+        .expect("setsockopt IP_RECVDSTADDR failed");
 
     {
         let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-        let iov = [IoVec::from_slice(&slice)];
+        let iov = [IoSlice::new(&slice)];
 
         let send = socket(
             AddressFamily::Inet,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
-        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa)).expect("sendmsg failed");
+        )
+        .expect("send socket failed");
+        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa))
+            .expect("sendmsg failed");
     }
 
     {
         let mut buf = [0u8; 8];
-        let iovec = [IoVec::from_mut_slice(&mut buf)];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
         let mut space = cmsg_space!(libc::sockaddr_dl, libc::in_addr);
-        let msg = recvmsg(
+        let msg = recvmsg::<()>(
             receive,
-            &iovec,
+            &mut iovec,
             Some(&mut space),
             MsgFlags::empty(),
-        ).expect("recvmsg failed");
-        assert!(
-            !msg.flags
-                .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC)
-        );
+        )
+        .expect("recvmsg failed");
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
         assert_eq!(msg.cmsgs().count(), 2, "expected 2 cmsgs");
 
         let mut rx_recvif = false;
@@ -1421,37 +1839,203 @@ pub fn test_recvif() {
             match cmsg {
                 ControlMessageOwned::Ipv4RecvIf(dl) => {
                     rx_recvif = true;
-                    let i = if_nametoindex(lo_name.as_bytes()).expect("if_nametoindex");
+                    let i = if_nametoindex(lo_name.as_bytes())
+                        .expect("if_nametoindex");
                     assert_eq!(
-                        dl.sdl_index as libc::c_uint,
-                        i,
+                        dl.sdl_index as libc::c_uint, i,
                         "unexpected ifindex (expected {}, got {})",
-                        i,
-                        dl.sdl_index
+                        i, dl.sdl_index
                     );
-                },
+                }
                 ControlMessageOwned::Ipv4RecvDstAddr(addr) => {
                     rx_recvdstaddr = true;
-                    if let SockAddr::Inet(InetAddr::V4(a)) = lo {
-                        assert_eq!(a.sin_addr.s_addr,
+                    if let Some(sin) = lo.as_sockaddr_in() {
+                        assert_eq!(sin.as_ref().sin_addr.s_addr,
                                    addr.s_addr,
                                    "unexpected destination address (expected {}, got {})",
-                                   a.sin_addr.s_addr,
+                                   sin.as_ref().sin_addr.s_addr,
                                    addr.s_addr);
                     } else {
                         panic!("unexpected Sockaddr");
                     }
-                },
+                }
                 _ => panic!("unexpected additional control msg"),
             }
         }
         assert!(rx_recvif);
         assert!(rx_recvdstaddr);
         assert_eq!(msg.bytes, 8);
-        assert_eq!(
-            iovec[0].as_slice(),
-            [1u8, 2, 3, 4, 5, 6, 7, 8]
-        );
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
+    }
+}
+
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg_attr(qemu, ignore)]
+#[test]
+pub fn test_recvif_ipv4() {
+    use nix::sys::socket::sockopt::Ipv4OrigDstAddr;
+    use nix::sys::socket::{bind, SockFlag, SockType, SockaddrIn};
+    use nix::sys::socket::{getsockname, setsockopt, socket};
+    use nix::sys::socket::{recvmsg, sendmsg, ControlMessageOwned, MsgFlags};
+    use std::io::{IoSlice, IoSliceMut};
+
+    let lo_ifaddr = loopback_address(AddressFamily::Inet);
+    let (_lo_name, lo) = match lo_ifaddr {
+        Some(ifaddr) => (
+            ifaddr.interface_name,
+            ifaddr.address.expect("Expect IPv4 address on interface"),
+        ),
+        None => return,
+    };
+    let receive = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("receive socket failed");
+    bind(receive, &lo).expect("bind failed");
+    let sa: SockaddrIn = getsockname(receive).expect("getsockname failed");
+    setsockopt(receive, Ipv4OrigDstAddr, &true)
+        .expect("setsockopt IP_ORIGDSTADDR failed");
+
+    {
+        let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let iov = [IoSlice::new(&slice)];
+
+        let send = socket(
+            AddressFamily::Inet,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("send socket failed");
+        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa))
+            .expect("sendmsg failed");
+    }
+
+    {
+        let mut buf = [0u8; 8];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
+        let mut space = cmsg_space!(libc::sockaddr_in);
+        let msg = recvmsg::<()>(
+            receive,
+            &mut iovec,
+            Some(&mut space),
+            MsgFlags::empty(),
+        )
+        .expect("recvmsg failed");
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert_eq!(msg.cmsgs().count(), 1, "expected 1 cmsgs");
+
+        let mut rx_recvorigdstaddr = false;
+        for cmsg in msg.cmsgs() {
+            match cmsg {
+                ControlMessageOwned::Ipv4OrigDstAddr(addr) => {
+                    rx_recvorigdstaddr = true;
+                    if let Some(sin) = lo.as_sockaddr_in() {
+                        assert_eq!(sin.as_ref().sin_addr.s_addr,
+                                   addr.sin_addr.s_addr,
+                                   "unexpected destination address (expected {}, got {})",
+                                   sin.as_ref().sin_addr.s_addr,
+                                   addr.sin_addr.s_addr);
+                    } else {
+                        panic!("unexpected Sockaddr");
+                    }
+                }
+                _ => panic!("unexpected additional control msg"),
+            }
+        }
+        assert!(rx_recvorigdstaddr);
+        assert_eq!(msg.bytes, 8);
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
+    }
+}
+
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
+#[cfg_attr(qemu, ignore)]
+#[test]
+pub fn test_recvif_ipv6() {
+    use nix::sys::socket::sockopt::Ipv6OrigDstAddr;
+    use nix::sys::socket::{bind, SockFlag, SockType, SockaddrIn6};
+    use nix::sys::socket::{getsockname, setsockopt, socket};
+    use nix::sys::socket::{recvmsg, sendmsg, ControlMessageOwned, MsgFlags};
+    use std::io::{IoSlice, IoSliceMut};
+
+    let lo_ifaddr = loopback_address(AddressFamily::Inet6);
+    let (_lo_name, lo) = match lo_ifaddr {
+        Some(ifaddr) => (
+            ifaddr.interface_name,
+            ifaddr.address.expect("Expect IPv6 address on interface"),
+        ),
+        None => return,
+    };
+    let receive = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("receive socket failed");
+    bind(receive, &lo).expect("bind failed");
+    let sa: SockaddrIn6 = getsockname(receive).expect("getsockname failed");
+    setsockopt(receive, Ipv6OrigDstAddr, &true)
+        .expect("setsockopt IP_ORIGDSTADDR failed");
+
+    {
+        let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        let iov = [IoSlice::new(&slice)];
+
+        let send = socket(
+            AddressFamily::Inet6,
+            SockType::Datagram,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("send socket failed");
+        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa))
+            .expect("sendmsg failed");
+    }
+
+    {
+        let mut buf = [0u8; 8];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
+        let mut space = cmsg_space!(libc::sockaddr_in6);
+        let msg = recvmsg::<()>(
+            receive,
+            &mut iovec,
+            Some(&mut space),
+            MsgFlags::empty(),
+        )
+        .expect("recvmsg failed");
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
+        assert_eq!(msg.cmsgs().count(), 1, "expected 1 cmsgs");
+
+        let mut rx_recvorigdstaddr = false;
+        for cmsg in msg.cmsgs() {
+            match cmsg {
+                ControlMessageOwned::Ipv6OrigDstAddr(addr) => {
+                    rx_recvorigdstaddr = true;
+                    if let Some(sin) = lo.as_sockaddr_in6() {
+                        assert_eq!(sin.as_ref().sin6_addr.s6_addr,
+                                   addr.sin6_addr.s6_addr,
+                                   "unexpected destination address (expected {:?}, got {:?})",
+                                   sin.as_ref().sin6_addr.s6_addr,
+                                   addr.sin6_addr.s6_addr);
+                    } else {
+                        panic!("unexpected Sockaddr");
+                    }
+                }
+                _ => panic!("unexpected additional control msg"),
+            }
+        }
+        assert!(rx_recvorigdstaddr);
+        assert_eq!(msg.bytes, 8);
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
     }
 }
 
@@ -1465,27 +2049,32 @@ pub fn test_recvif() {
     target_os = "openbsd",
 ))]
 // qemu doesn't seem to be emulating this correctly in these architectures
-#[cfg_attr(all(
-    qemu,
-    any(
-        target_arch = "mips",
-        target_arch = "mips64",
-        target_arch = "powerpc64",
-    )
-), ignore)]
+#[cfg_attr(
+    all(
+        qemu,
+        any(
+            target_arch = "mips",
+            target_arch = "mips64",
+            target_arch = "powerpc64",
+        )
+    ),
+    ignore
+)]
 #[test]
 pub fn test_recv_ipv6pktinfo() {
     use nix::net::if_::*;
     use nix::sys::socket::sockopt::Ipv6RecvPacketInfo;
-    use nix::sys::socket::{bind, SockFlag, SockType};
+    use nix::sys::socket::{bind, SockFlag, SockType, SockaddrIn6};
     use nix::sys::socket::{getsockname, setsockopt, socket};
     use nix::sys::socket::{recvmsg, sendmsg, ControlMessageOwned, MsgFlags};
-    use nix::sys::uio::IoVec;
+    use std::io::{IoSlice, IoSliceMut};
 
     let lo_ifaddr = loopback_address(AddressFamily::Inet6);
     let (lo_name, lo) = match lo_ifaddr {
-        Some(ifaddr) => (ifaddr.interface_name,
-                         ifaddr.address.expect("Expect IPv4 address on interface")),
+        Some(ifaddr) => (
+            ifaddr.interface_name,
+            ifaddr.address.expect("Expect IPv6 address on interface"),
+        ),
         None => return,
     };
     let receive = socket(
@@ -1493,57 +2082,56 @@ pub fn test_recv_ipv6pktinfo() {
         SockType::Datagram,
         SockFlag::empty(),
         None,
-    ).expect("receive socket failed");
+    )
+    .expect("receive socket failed");
     bind(receive, &lo).expect("bind failed");
-    let sa = getsockname(receive).expect("getsockname failed");
+    let sa: SockaddrIn6 = getsockname(receive).expect("getsockname failed");
     setsockopt(receive, Ipv6RecvPacketInfo, &true).expect("setsockopt failed");
 
     {
         let slice = [1u8, 2, 3, 4, 5, 6, 7, 8];
-        let iov = [IoVec::from_slice(&slice)];
+        let iov = [IoSlice::new(&slice)];
 
         let send = socket(
             AddressFamily::Inet6,
             SockType::Datagram,
             SockFlag::empty(),
             None,
-        ).expect("send socket failed");
-        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa)).expect("sendmsg failed");
+        )
+        .expect("send socket failed");
+        sendmsg(send, &iov, &[], MsgFlags::empty(), Some(&sa))
+            .expect("sendmsg failed");
     }
 
     {
         let mut buf = [0u8; 8];
-        let iovec = [IoVec::from_mut_slice(&mut buf)];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
+
         let mut space = cmsg_space!(libc::in6_pktinfo);
-        let msg = recvmsg(
+        let msg = recvmsg::<()>(
             receive,
-            &iovec,
+            &mut iovec,
             Some(&mut space),
             MsgFlags::empty(),
-        ).expect("recvmsg failed");
-        assert!(
-            !msg.flags
-                .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC)
-        );
+        )
+        .expect("recvmsg failed");
+        assert!(!msg
+            .flags
+            .intersects(MsgFlags::MSG_TRUNC | MsgFlags::MSG_CTRUNC));
 
         let mut cmsgs = msg.cmsgs();
         if let Some(ControlMessageOwned::Ipv6PacketInfo(pktinfo)) = cmsgs.next()
         {
             let i = if_nametoindex(lo_name.as_bytes()).expect("if_nametoindex");
             assert_eq!(
-                pktinfo.ipi6_ifindex as libc::c_uint,
-                i,
+                pktinfo.ipi6_ifindex as libc::c_uint, i,
                 "unexpected ifindex (expected {}, got {})",
-                i,
-                pktinfo.ipi6_ifindex
+                i, pktinfo.ipi6_ifindex
             );
         }
         assert!(cmsgs.next().is_none(), "unexpected additional control msg");
         assert_eq!(msg.bytes, 8);
-        assert_eq!(
-            iovec[0].as_slice(),
-            [1u8, 2, 3, 4, 5, 6, 7, 8]
-        );
+        assert_eq!(*iovec[0], [1u8, 2, 3, 4, 5, 6, 7, 8]);
     }
 }
 
@@ -1552,38 +2140,47 @@ pub fn test_recv_ipv6pktinfo() {
 #[test]
 pub fn test_vsock() {
     use nix::errno::Errno;
-    use nix::sys::socket::{AddressFamily, socket, bind, connect, listen,
-                           SockAddr, SockType, SockFlag};
-    use nix::unistd::{close};
+    use nix::sys::socket::{
+        bind, connect, listen, socket, AddressFamily, SockFlag, SockType,
+        VsockAddr,
+    };
+    use nix::unistd::close;
     use std::thread;
 
     let port: u32 = 3000;
 
-    let s1 = socket(AddressFamily::Vsock,  SockType::Stream,
-                    SockFlag::empty(), None)
-             .expect("socket failed");
+    let s1 = socket(
+        AddressFamily::Vsock,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("socket failed");
 
     // VMADDR_CID_HYPERVISOR is reserved, so we expect an EADDRNOTAVAIL error.
-    let sockaddr = SockAddr::new_vsock(libc::VMADDR_CID_HYPERVISOR, port);
-    assert_eq!(bind(s1, &sockaddr).err(),
-               Some(Errno::EADDRNOTAVAIL));
+    let sockaddr_hv = VsockAddr::new(libc::VMADDR_CID_HYPERVISOR, port);
+    assert_eq!(bind(s1, &sockaddr_hv).err(), Some(Errno::EADDRNOTAVAIL));
 
-    let sockaddr = SockAddr::new_vsock(libc::VMADDR_CID_ANY, port);
-    assert_eq!(bind(s1, &sockaddr), Ok(()));
+    let sockaddr_any = VsockAddr::new(libc::VMADDR_CID_ANY, port);
+    assert_eq!(bind(s1, &sockaddr_any), Ok(()));
     listen(s1, 10).expect("listen failed");
 
     let thr = thread::spawn(move || {
         let cid: u32 = libc::VMADDR_CID_HOST;
 
-        let s2 = socket(AddressFamily::Vsock, SockType::Stream,
-                        SockFlag::empty(), None)
-                 .expect("socket failed");
+        let s2 = socket(
+            AddressFamily::Vsock,
+            SockType::Stream,
+            SockFlag::empty(),
+            None,
+        )
+        .expect("socket failed");
 
-        let sockaddr = SockAddr::new_vsock(cid, port);
+        let sockaddr_host = VsockAddr::new(cid, port);
 
         // The current implementation does not support loopback devices, so,
         // for now, we expect a failure on the connect.
-        assert_ne!(connect(s2, &sockaddr), Ok(()));
+        assert_ne!(connect(s2, &sockaddr_host), Ok(()));
 
         close(s2).unwrap();
     });
@@ -1599,8 +2196,8 @@ pub fn test_vsock() {
 #[test]
 fn test_recvmsg_timestampns() {
     use nix::sys::socket::*;
-    use nix::sys::uio::IoVec;
     use nix::sys::time::*;
+    use std::io::{IoSlice, IoSliceMut};
     use std::time::*;
 
     // Set up
@@ -1609,34 +2206,38 @@ fn test_recvmsg_timestampns() {
         AddressFamily::Inet,
         SockType::Datagram,
         SockFlag::empty(),
-        None).unwrap();
+        None,
+    )
+    .unwrap();
     setsockopt(in_socket, sockopt::ReceiveTimestampns, &true).unwrap();
-    let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
-    bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
-    let address = getsockname(in_socket).unwrap();
+    let localhost = SockaddrIn::new(127, 0, 0, 1, 0);
+    bind(in_socket, &localhost).unwrap();
+    let address: SockaddrIn = getsockname(in_socket).unwrap();
     // Get initial time
     let time0 = SystemTime::now();
     // Send the message
-    let iov = [IoVec::from_slice(message)];
+    let iov = [IoSlice::new(message)];
     let flags = MsgFlags::empty();
     let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();
     assert_eq!(message.len(), l);
     // Receive the message
     let mut buffer = vec![0u8; message.len()];
     let mut cmsgspace = nix::cmsg_space!(TimeSpec);
-    let iov = [IoVec::from_mut_slice(&mut buffer)];
-    let r = recvmsg(in_socket, &iov, Some(&mut cmsgspace), flags).unwrap();
+
+    let mut iov = [IoSliceMut::new(&mut buffer)];
+    let r = recvmsg::<()>(in_socket, &mut iov, Some(&mut cmsgspace), flags)
+        .unwrap();
     let rtime = match r.cmsgs().next() {
         Some(ControlMessageOwned::ScmTimestampns(rtime)) => rtime,
         Some(_) => panic!("Unexpected control message"),
-        None => panic!("No control message")
+        None => panic!("No control message"),
     };
     // Check the final time
     let time1 = SystemTime::now();
     // the packet's received timestamp should lie in-between the two system
     // times, unless the system clock was adjusted in the meantime.
-    let rduration = Duration::new(rtime.tv_sec() as u64,
-    rtime.tv_nsec() as u32);
+    let rduration =
+        Duration::new(rtime.tv_sec() as u64, rtime.tv_nsec() as u32);
     assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);
     assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());
     // Close socket
@@ -1650,8 +2251,8 @@ fn test_recvmsg_timestampns() {
 #[test]
 fn test_recvmmsg_timestampns() {
     use nix::sys::socket::*;
-    use nix::sys::uio::IoVec;
     use nix::sys::time::*;
+    use std::io::{IoSlice, IoSliceMut};
     use std::time::*;
 
     // Set up
@@ -1660,40 +2261,40 @@ fn test_recvmmsg_timestampns() {
         AddressFamily::Inet,
         SockType::Datagram,
         SockFlag::empty(),
-        None).unwrap();
+        None,
+    )
+    .unwrap();
     setsockopt(in_socket, sockopt::ReceiveTimestampns, &true).unwrap();
-    let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
-    bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
-    let address = getsockname(in_socket).unwrap();
+    let localhost = SockaddrIn::from_str("127.0.0.1:0").unwrap();
+    bind(in_socket, &localhost).unwrap();
+    let address: SockaddrIn = getsockname(in_socket).unwrap();
     // Get initial time
     let time0 = SystemTime::now();
     // Send the message
-    let iov = [IoVec::from_slice(message)];
+    let iov = [IoSlice::new(message)];
     let flags = MsgFlags::empty();
     let l = sendmsg(in_socket, &iov, &[], flags, Some(&address)).unwrap();
     assert_eq!(message.len(), l);
     // Receive the message
     let mut buffer = vec![0u8; message.len()];
-    let mut cmsgspace = nix::cmsg_space!(TimeSpec);
-    let iov = [IoVec::from_mut_slice(&mut buffer)];
-    let mut data = vec![
-        RecvMmsgData {
-            iov,
-            cmsg_buffer: Some(&mut cmsgspace),
-        },
-    ];
-    let r = recvmmsg(in_socket, &mut data, flags, None).unwrap();
+    let cmsgspace = nix::cmsg_space!(TimeSpec);
+    let iov = vec![[IoSliceMut::new(&mut buffer)]];
+    let mut data = MultiHeaders::preallocate(1, Some(cmsgspace));
+    let r: Vec<RecvMsg<()>> =
+        recvmmsg(in_socket, &mut data, iov.iter(), flags, None)
+            .unwrap()
+            .collect();
     let rtime = match r[0].cmsgs().next() {
         Some(ControlMessageOwned::ScmTimestampns(rtime)) => rtime,
         Some(_) => panic!("Unexpected control message"),
-        None => panic!("No control message")
+        None => panic!("No control message"),
     };
     // Check the final time
     let time1 = SystemTime::now();
     // the packet's received timestamp should lie in-between the two system
     // times, unless the system clock was adjusted in the meantime.
-    let rduration = Duration::new(rtime.tv_sec() as u64,
-    rtime.tv_nsec() as u32);
+    let rduration =
+        Duration::new(rtime.tv_sec() as u64, rtime.tv_nsec() as u32);
     assert!(time0.duration_since(UNIX_EPOCH).unwrap() <= rduration);
     assert!(rduration <= time1.duration_since(UNIX_EPOCH).unwrap());
     // Close socket
@@ -1706,10 +2307,10 @@ fn test_recvmmsg_timestampns() {
 #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
 #[test]
 fn test_recvmsg_rxq_ovfl() {
-    use nix::Error;
+    use nix::sys::socket::sockopt::{RcvBuf, RxqOvfl};
     use nix::sys::socket::*;
-    use nix::sys::uio::IoVec;
-    use nix::sys::socket::sockopt::{RxqOvfl, RcvBuf};
+    use nix::Error;
+    use std::io::{IoSlice, IoSliceMut};
 
     let message = [0u8; 2048];
     let bufsize = message.len() * 2;
@@ -1718,17 +2319,21 @@ fn test_recvmsg_rxq_ovfl() {
         AddressFamily::Inet,
         SockType::Datagram,
         SockFlag::empty(),
-        None).unwrap();
+        None,
+    )
+    .unwrap();
     let out_socket = socket(
         AddressFamily::Inet,
         SockType::Datagram,
         SockFlag::empty(),
-        None).unwrap();
+        None,
+    )
+    .unwrap();
 
-    let localhost = InetAddr::new(IpAddr::new_v4(127, 0, 0, 1), 0);
-    bind(in_socket, &SockAddr::new_inet(localhost)).unwrap();
+    let localhost = SockaddrIn::from_str("127.0.0.1:0").unwrap();
+    bind(in_socket, &localhost).unwrap();
 
-    let address = getsockname(in_socket).unwrap();
+    let address: SockaddrIn = getsockname(in_socket).unwrap();
     connect(out_socket, &address).unwrap();
 
     // Set SO_RXQ_OVFL flag.
@@ -1740,13 +2345,14 @@ fn test_recvmsg_rxq_ovfl() {
     let mut drop_counter = 0;
 
     for _ in 0..2 {
-        let iov = [IoVec::from_slice(&message)];
+        let iov = [IoSlice::new(&message)];
         let flags = MsgFlags::empty();
 
         // Send the 3 messages (the receiver buffer can only hold 2 messages)
         // to create an overflow.
         for _ in 0..3 {
-            let l = sendmsg(out_socket, &iov, &[], flags, Some(&address)).unwrap();
+            let l =
+                sendmsg(out_socket, &iov, &[], flags, Some(&address)).unwrap();
             assert_eq!(message.len(), l);
         }
 
@@ -1755,22 +2361,29 @@ fn test_recvmsg_rxq_ovfl() {
             let mut buffer = vec![0u8; message.len()];
             let mut cmsgspace = nix::cmsg_space!(u32);
 
-            let iov = [IoVec::from_mut_slice(&mut buffer)];
+            let mut iov = [IoSliceMut::new(&mut buffer)];
 
-            match recvmsg(
+            match recvmsg::<()>(
                 in_socket,
-                &iov,
+                &mut iov,
                 Some(&mut cmsgspace),
-                MsgFlags::MSG_DONTWAIT) {
+                MsgFlags::MSG_DONTWAIT,
+            ) {
                 Ok(r) => {
                     drop_counter = match r.cmsgs().next() {
-                        Some(ControlMessageOwned::RxqOvfl(drop_counter)) => drop_counter,
+                        Some(ControlMessageOwned::RxqOvfl(drop_counter)) => {
+                            drop_counter
+                        }
                         Some(_) => panic!("Unexpected control message"),
                         None => 0,
                     };
-                },
-                Err(Error::EAGAIN) => { break; },
-                _ => { panic!("unknown recvmsg() error"); },
+                }
+                Err(Error::EAGAIN) => {
+                    break;
+                }
+                _ => {
+                    panic!("unknown recvmsg() error");
+                }
             }
         }
     }
@@ -1783,13 +2396,10 @@ fn test_recvmsg_rxq_ovfl() {
     nix::unistd::close(out_socket).unwrap();
 }
 
-#[cfg(any(
-    target_os = "linux",
-    target_os = "android",
-))]
+#[cfg(any(target_os = "linux", target_os = "android",))]
 mod linux_errqueue {
+    use super::FromStr;
     use nix::sys::socket::*;
-    use super::{FromStr, SocketAddr};
 
     // Send a UDP datagram to a bogus destination address and observe an ICMP error (v4).
     //
@@ -1817,11 +2427,16 @@ mod linux_errqueue {
             // Closure handles protocol-specific testing and returns generic sock_extended_err for
             // protocol-independent test impl.
             |cmsg| {
-                if let ControlMessageOwned::Ipv4RecvErr(ext_err, err_addr) = cmsg {
+                if let ControlMessageOwned::Ipv4RecvErr(ext_err, err_addr) =
+                    cmsg
+                {
                     if let Some(origin) = err_addr {
                         // Validate that our network error originated from 127.0.0.1:0.
                         assert_eq!(origin.sin_family, AddressFamily::Inet as _);
-                        assert_eq!(Ipv4Addr(origin.sin_addr), Ipv4Addr::new(127, 0, 0, 1));
+                        assert_eq!(
+                            origin.sin_addr.s_addr,
+                            u32::from_be(0x7f000001)
+                        );
                         assert_eq!(origin.sin_port, 0);
                     } else {
                         panic!("Expected some error origin");
@@ -1860,13 +2475,18 @@ mod linux_errqueue {
             // Closure handles protocol-specific testing and returns generic sock_extended_err for
             // protocol-independent test impl.
             |cmsg| {
-                if let ControlMessageOwned::Ipv6RecvErr(ext_err, err_addr) = cmsg {
+                if let ControlMessageOwned::Ipv6RecvErr(ext_err, err_addr) =
+                    cmsg
+                {
                     if let Some(origin) = err_addr {
                         // Validate that our network error originated from localhost:0.
-                        assert_eq!(origin.sin6_family, AddressFamily::Inet6 as _);
                         assert_eq!(
-                            Ipv6Addr(origin.sin6_addr),
-                            Ipv6Addr::from_std(&"::1".parse().unwrap()),
+                            origin.sin6_family,
+                            AddressFamily::Inet6 as _
+                        );
+                        assert_eq!(
+                            origin.sin6_addr.s6_addr,
+                            std::net::Ipv6Addr::LOCALHOST.octets()
                         );
                         assert_eq!(origin.sin6_port, 0);
                     } else {
@@ -1880,43 +2500,51 @@ mod linux_errqueue {
         )
     }
 
-    fn test_recverr_impl<SA, OPT, TESTF>(sa: &str,
-                                         af: AddressFamily,
-                                         opt: OPT,
-                                         ee_origin: u8,
-                                         ee_type: u8,
-                                         ee_code: u8,
-                                         testf: TESTF)
-        where
-            OPT: SetSockOpt<Val = bool>,
-            TESTF: FnOnce(&ControlMessageOwned) -> libc::sock_extended_err,
+    fn test_recverr_impl<SA, OPT, TESTF>(
+        sa: &str,
+        af: AddressFamily,
+        opt: OPT,
+        ee_origin: u8,
+        ee_type: u8,
+        ee_code: u8,
+        testf: TESTF,
+    ) where
+        OPT: SetSockOpt<Val = bool>,
+        TESTF: FnOnce(&ControlMessageOwned) -> libc::sock_extended_err,
     {
         use nix::errno::Errno;
-        use nix::sys::uio::IoVec;
+        use std::io::IoSliceMut;
 
         const MESSAGE_CONTENTS: &str = "ABCDEF";
-
-        let sock_addr = {
-            let std_sa = SocketAddr::from_str(sa).unwrap();
-            let inet_addr = InetAddr::from_std(&std_sa);
-            SockAddr::new_inet(inet_addr)
-        };
-        let sock = socket(af, SockType::Datagram, SockFlag::SOCK_CLOEXEC, None).unwrap();
+        let std_sa = std::net::SocketAddr::from_str(sa).unwrap();
+        let sock_addr = SockaddrStorage::from(std_sa);
+        let sock = socket(af, SockType::Datagram, SockFlag::SOCK_CLOEXEC, None)
+            .unwrap();
         setsockopt(sock, opt, &true).unwrap();
-        if let Err(e) = sendto(sock, MESSAGE_CONTENTS.as_bytes(), &sock_addr, MsgFlags::empty()) {
+        if let Err(e) = sendto(
+            sock,
+            MESSAGE_CONTENTS.as_bytes(),
+            &sock_addr,
+            MsgFlags::empty(),
+        ) {
             assert_eq!(e, Errno::EADDRNOTAVAIL);
             println!("{:?} not available, skipping test.", af);
             return;
         }
 
         let mut buf = [0u8; 8];
-        let iovec = [IoVec::from_mut_slice(&mut buf)];
+        let mut iovec = [IoSliceMut::new(&mut buf)];
         let mut cspace = cmsg_space!(libc::sock_extended_err, SA);
 
-        let msg = recvmsg(sock, &iovec, Some(&mut cspace), MsgFlags::MSG_ERRQUEUE).unwrap();
+        let msg = recvmsg(
+            sock,
+            &mut iovec,
+            Some(&mut cspace),
+            MsgFlags::MSG_ERRQUEUE,
+        )
+        .unwrap();
         // The sent message / destination associated with the error is returned:
         assert_eq!(msg.bytes, MESSAGE_CONTENTS.as_bytes().len());
-        assert_eq!(&buf[..msg.bytes], MESSAGE_CONTENTS.as_bytes());
         // recvmsg(2): "The original destination address of the datagram that caused the error is
         // supplied via msg_name;" however, this is not literally true.  E.g., an earlier version
         // of this test used 0.0.0.0 (::0) as the destination address, which was mutated into
@@ -1937,5 +2565,64 @@ mod linux_errqueue {
         assert_eq!(ext_err.ee_code, ee_code);
         // ip(7): ee_info contains the discovered MTU for EMSGSIZE errors.
         assert_eq!(ext_err.ee_info, 0);
+
+        let bytes = msg.bytes;
+        assert_eq!(&buf[..bytes], MESSAGE_CONTENTS.as_bytes());
     }
 }
+
+// Disable the test on emulated platforms because it fails in Cirrus-CI.  Lack
+// of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+#[cfg(target_os = "linux")]
+#[test]
+pub fn test_txtime() {
+    use nix::sys::socket::{
+        bind, recvmsg, sendmsg, setsockopt, socket, sockopt, ControlMessage,
+        MsgFlags, SockFlag, SockType, SockaddrIn,
+    };
+    use nix::sys::time::TimeValLike;
+    use nix::time::{clock_gettime, ClockId};
+
+    require_kernel_version!(test_txtime, ">= 5.8");
+
+    let sock_addr = SockaddrIn::from_str("127.0.0.1:6802").unwrap();
+
+    let ssock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .expect("send socket failed");
+
+    let txtime_cfg = libc::sock_txtime {
+        clockid: libc::CLOCK_MONOTONIC,
+        flags: 0,
+    };
+    setsockopt(ssock, sockopt::TxTime, &txtime_cfg).unwrap();
+
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    bind(rsock, &sock_addr).unwrap();
+
+    let sbuf = [0u8; 2048];
+    let iov1 = [std::io::IoSlice::new(&sbuf)];
+
+    let now = clock_gettime(ClockId::CLOCK_MONOTONIC).unwrap();
+    let delay = std::time::Duration::from_secs(1).into();
+    let txtime = (now + delay).num_nanoseconds() as u64;
+
+    let cmsg = ControlMessage::TxTime(&txtime);
+    sendmsg(ssock, &iov1, &[cmsg], MsgFlags::empty(), Some(&sock_addr))
+        .unwrap();
+
+    let mut rbuf = [0u8; 2048];
+    let mut iov2 = [std::io::IoSliceMut::new(&mut rbuf)];
+    recvmsg::<()>(rsock, &mut iov2, None, MsgFlags::empty()).unwrap();
+}
diff --git a/test/sys/test_sockopt.rs b/test/sys/test_sockopt.rs
index 01920fd..34bef94 100644
--- a/test/sys/test_sockopt.rs
+++ b/test/sys/test_sockopt.rs
@@ -1,22 +1,27 @@
-use rand::{thread_rng, Rng};
-use nix::sys::socket::{socket, sockopt, getsockopt, setsockopt, AddressFamily, SockType, SockFlag, SockProtocol};
 #[cfg(any(target_os = "android", target_os = "linux"))]
 use crate::*;
+use nix::sys::socket::{
+    getsockopt, setsockopt, socket, sockopt, AddressFamily, SockFlag,
+    SockProtocol, SockType,
+};
+use rand::{thread_rng, Rng};
 
 // NB: FreeBSD supports LOCAL_PEERCRED for SOCK_SEQPACKET, but OSX does not.
-#[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-))]
+#[cfg(any(target_os = "dragonfly", target_os = "freebsd",))]
 #[test]
 pub fn test_local_peercred_seqpacket() {
     use nix::{
+        sys::socket::socketpair,
         unistd::{Gid, Uid},
-        sys::socket::socketpair
     };
 
-    let (fd1, _fd2) = socketpair(AddressFamily::Unix, SockType::SeqPacket, None,
-                                SockFlag::empty()).unwrap();
+    let (fd1, _fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::SeqPacket,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     let xucred = getsockopt(fd1, sockopt::LocalPeerCred).unwrap();
     assert_eq!(xucred.version(), 0);
     assert_eq!(Uid::from_raw(xucred.uid()), Uid::current());
@@ -24,20 +29,25 @@ pub fn test_local_peercred_seqpacket() {
 }
 
 #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "macos",
-        target_os = "ios"
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "ios"
 ))]
 #[test]
 pub fn test_local_peercred_stream() {
     use nix::{
+        sys::socket::socketpair,
         unistd::{Gid, Uid},
-        sys::socket::socketpair
     };
 
-    let (fd1, _fd2) = socketpair(AddressFamily::Unix, SockType::Stream, None,
-                                SockFlag::empty()).unwrap();
+    let (fd1, _fd2) = socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .unwrap();
     let xucred = getsockopt(fd1, sockopt::LocalPeerCred).unwrap();
     assert_eq!(xucred.version(), 0);
     assert_eq!(Uid::from_raw(xucred.uid()), Uid::current());
@@ -51,7 +61,13 @@ fn is_so_mark_functional() {
 
     require_capability!("is_so_mark_functional", CAP_NET_ADMIN);
 
-    let s = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), None).unwrap();
+    let s = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
     setsockopt(s, sockopt::Mark, &1337).unwrap();
     let mark = getsockopt(s, sockopt::Mark).unwrap();
     assert_eq!(mark, 1337);
@@ -59,8 +75,13 @@ fn is_so_mark_functional() {
 
 #[test]
 fn test_so_buf() {
-    let fd = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(), SockProtocol::Udp)
-             .unwrap();
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::Udp,
+    )
+    .unwrap();
     let bufsize: usize = thread_rng().gen_range(4096..131_072);
     setsockopt(fd, sockopt::SndBuf, &bufsize).unwrap();
     let actual = getsockopt(fd, sockopt::SndBuf).unwrap();
@@ -72,17 +93,21 @@ fn test_so_buf() {
 
 #[test]
 fn test_so_tcp_maxseg() {
-    use std::net::SocketAddr;
-    use std::str::FromStr;
-    use nix::sys::socket::{accept, bind, connect, listen, InetAddr, SockAddr};
+    use nix::sys::socket::{accept, bind, connect, listen, SockaddrIn};
     use nix::unistd::{close, write};
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
 
-    let std_sa = SocketAddr::from_str("127.0.0.1:4001").unwrap();
-    let inet_addr = InetAddr::from_std(&std_sa);
-    let sock_addr = SockAddr::new_inet(inet_addr);
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:4001").unwrap();
+    let sock_addr = SockaddrIn::from(std_sa);
 
-    let rsock = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), SockProtocol::Tcp)
-                .unwrap();
+    let rsock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
     bind(rsock, &sock_addr).unwrap();
     listen(rsock, 10).unwrap();
     let initial = getsockopt(rsock, sockopt::TcpMaxSeg).unwrap();
@@ -100,8 +125,13 @@ fn test_so_tcp_maxseg() {
     }
 
     // Connect and check the MSS that was advertised
-    let ssock = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), SockProtocol::Tcp)
-                .unwrap();
+    let ssock = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
     connect(ssock, &sock_addr).unwrap();
     let rsess = accept(rsock).unwrap();
     write(rsess, b"hello").unwrap();
@@ -121,8 +151,35 @@ fn test_so_tcp_maxseg() {
     close(ssock).unwrap();
 }
 
+#[test]
+fn test_so_type() {
+    let sockfd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+
+    assert_eq!(Ok(SockType::Stream), getsockopt(sockfd, sockopt::SockType));
+}
+
+/// getsockopt(_, sockopt::SockType) should gracefully handle unknown socket
+/// types.  Regression test for https://github.com/nix-rust/nix/issues/1819
+#[cfg(any(target_os = "android", target_os = "linux",))]
+#[test]
+fn test_so_type_unknown() {
+    use nix::errno::Errno;
+
+    require_capability!("test_so_type", CAP_NET_RAW);
+    let sockfd = unsafe { libc::socket(libc::AF_PACKET, libc::SOCK_PACKET, 0) };
+    assert!(sockfd >= 0, "Error opening socket: {}", nix::Error::last());
+
+    assert_eq!(Err(Errno::EINVAL), getsockopt(sockfd, sockopt::SockType));
+}
+
 // The CI doesn't supported getsockopt and setsockopt on emulated processors.
-// It's beleived that a QEMU issue, the tests run ok on a fully emulated system.
+// It's believed that a QEMU issue, the tests run ok on a fully emulated system.
 // Current CI just run the binary with QEMU but the Kernel remains the same as the host.
 // So the syscall doesn't work properly unless the kernel is also emulated.
 #[test]
@@ -133,17 +190,25 @@ fn test_so_tcp_maxseg() {
 fn test_tcp_congestion() {
     use std::ffi::OsString;
 
-    let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), None).unwrap();
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
 
     let val = getsockopt(fd, sockopt::TcpCongestion).unwrap();
     setsockopt(fd, sockopt::TcpCongestion, &val).unwrap();
 
-    setsockopt(fd, sockopt::TcpCongestion, &OsString::from("tcp_congestion_does_not_exist")).unwrap_err();
+    setsockopt(
+        fd,
+        sockopt::TcpCongestion,
+        &OsString::from("tcp_congestion_does_not_exist"),
+    )
+    .unwrap_err();
 
-    assert_eq!(
-        getsockopt(fd, sockopt::TcpCongestion).unwrap(),
-        val
-    );
+    assert_eq!(getsockopt(fd, sockopt::TcpCongestion).unwrap(), val);
 }
 
 #[test]
@@ -151,28 +216,39 @@ fn test_tcp_congestion() {
 fn test_bindtodevice() {
     skip_if_not_root!("test_bindtodevice");
 
-    let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), None).unwrap();
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
 
     let val = getsockopt(fd, sockopt::BindToDevice).unwrap();
     setsockopt(fd, sockopt::BindToDevice, &val).unwrap();
 
-    assert_eq!(
-        getsockopt(fd, sockopt::BindToDevice).unwrap(),
-        val
-    );
+    assert_eq!(getsockopt(fd, sockopt::BindToDevice).unwrap(), val);
 }
 
 #[test]
 fn test_so_tcp_keepalive() {
-    let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), SockProtocol::Tcp).unwrap();
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
     setsockopt(fd, sockopt::KeepAlive, &true).unwrap();
     assert!(getsockopt(fd, sockopt::KeepAlive).unwrap());
 
-    #[cfg(any(target_os = "android",
-              target_os = "dragonfly",
-              target_os = "freebsd",
-              target_os = "linux",
-              target_os = "nacl"))] {
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux"
+    ))]
+    {
         let x = getsockopt(fd, sockopt::TcpKeepIdle).unwrap();
         setsockopt(fd, sockopt::TcpKeepIdle, &(x + 1)).unwrap();
         assert_eq!(getsockopt(fd, sockopt::TcpKeepIdle).unwrap(), x + 1);
@@ -188,12 +264,168 @@ fn test_so_tcp_keepalive() {
 }
 
 #[test]
+#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg_attr(qemu, ignore)]
+fn test_get_mtu() {
+    use nix::sys::socket::{bind, connect, SockaddrIn};
+    use std::net::SocketAddrV4;
+    use std::str::FromStr;
+
+    let std_sa = SocketAddrV4::from_str("127.0.0.1:4001").unwrap();
+    let std_sb = SocketAddrV4::from_str("127.0.0.1:4002").unwrap();
+
+    let usock = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        SockProtocol::Udp,
+    )
+    .unwrap();
+
+    // Bind and initiate connection
+    bind(usock, &SockaddrIn::from(std_sa)).unwrap();
+    connect(usock, &SockaddrIn::from(std_sb)).unwrap();
+
+    // Loopback connections have 2^16 - the maximum - MTU
+    assert_eq!(getsockopt(usock, sockopt::IpMtu), Ok(u16::MAX as i32))
+}
+
+#[test]
 #[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
 fn test_ttl_opts() {
-    let fd4 = socket(AddressFamily::Inet, SockType::Datagram, SockFlag::empty(), None).unwrap();
+    let fd4 = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
     setsockopt(fd4, sockopt::Ipv4Ttl, &1)
         .expect("setting ipv4ttl on an inet socket should succeed");
-    let fd6 = socket(AddressFamily::Inet6, SockType::Datagram, SockFlag::empty(), None).unwrap();
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
     setsockopt(fd6, sockopt::Ipv6Ttl, &1)
         .expect("setting ipv6ttl on an inet6 socket should succeed");
 }
+
+#[test]
+#[cfg(any(target_os = "ios", target_os = "macos"))]
+fn test_dontfrag_opts() {
+    let fd4 = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(fd4, sockopt::IpDontFrag, &true)
+        .expect("setting IP_DONTFRAG on an inet stream socket should succeed");
+    setsockopt(fd4, sockopt::IpDontFrag, &false).expect(
+        "unsetting IP_DONTFRAG on an inet stream socket should succeed",
+    );
+    let fd4d = socket(
+        AddressFamily::Inet,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(fd4d, sockopt::IpDontFrag, &true).expect(
+        "setting IP_DONTFRAG on an inet datagram socket should succeed",
+    );
+    setsockopt(fd4d, sockopt::IpDontFrag, &false).expect(
+        "unsetting IP_DONTFRAG on an inet datagram socket should succeed",
+    );
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos",
+))]
+// Disable the test under emulation because it fails in Cirrus-CI.  Lack
+// of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+fn test_v6dontfrag_opts() {
+    let fd6 = socket(
+        AddressFamily::Inet6,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    setsockopt(fd6, sockopt::Ipv6DontFrag, &true).expect(
+        "setting IPV6_DONTFRAG on an inet6 stream socket should succeed",
+    );
+    setsockopt(fd6, sockopt::Ipv6DontFrag, &false).expect(
+        "unsetting IPV6_DONTFRAG on an inet6 stream socket should succeed",
+    );
+    let fd6d = socket(
+        AddressFamily::Inet6,
+        SockType::Datagram,
+        SockFlag::empty(),
+        None,
+    )
+    .unwrap();
+    setsockopt(fd6d, sockopt::Ipv6DontFrag, &true).expect(
+        "setting IPV6_DONTFRAG on an inet6 datagram socket should succeed",
+    );
+    setsockopt(fd6d, sockopt::Ipv6DontFrag, &false).expect(
+        "unsetting IPV6_DONTFRAG on an inet6 datagram socket should succeed",
+    );
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_so_priority() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let priority = 3;
+    setsockopt(fd, sockopt::Priority, &priority).unwrap();
+    assert_eq!(getsockopt(fd, sockopt::Priority).unwrap(), priority);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+fn test_ip_tos() {
+    let fd = socket(
+        AddressFamily::Inet,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let tos = 0x80; // CS4
+    setsockopt(fd, sockopt::IpTos, &tos).unwrap();
+    assert_eq!(getsockopt(fd, sockopt::IpTos).unwrap(), tos);
+}
+
+#[test]
+#[cfg(target_os = "linux")]
+// Disable the test under emulation because it fails in Cirrus-CI.  Lack
+// of QEMU support is suspected.
+#[cfg_attr(qemu, ignore)]
+fn test_ipv6_tclass() {
+    let fd = socket(
+        AddressFamily::Inet6,
+        SockType::Stream,
+        SockFlag::empty(),
+        SockProtocol::Tcp,
+    )
+    .unwrap();
+    let class = 0x80; // CS4
+    setsockopt(fd, sockopt::Ipv6TClass, &class).unwrap();
+    assert_eq!(getsockopt(fd, sockopt::Ipv6TClass).unwrap(), class);
+}
diff --git a/test/sys/test_stat.rs b/test/sys/test_stat.rs
new file mode 100644
index 0000000..426b4b6
--- /dev/null
+++ b/test/sys/test_stat.rs
@@ -0,0 +1,29 @@
+// The conversion is not useless on all platforms.
+#[allow(clippy::useless_conversion)]
+#[cfg(target_os = "freebsd")]
+#[test]
+fn test_chflags() {
+    use nix::{
+        sys::stat::{fstat, FileFlag},
+        unistd::chflags,
+    };
+    use std::os::unix::io::AsRawFd;
+    use tempfile::NamedTempFile;
+
+    let f = NamedTempFile::new().unwrap();
+
+    let initial = FileFlag::from_bits_truncate(
+        fstat(f.as_raw_fd()).unwrap().st_flags.into(),
+    );
+    // UF_OFFLINE is preserved by all FreeBSD file systems, but not interpreted
+    // in any way, so it's handy for testing.
+    let commanded = initial ^ FileFlag::UF_OFFLINE;
+
+    chflags(f.path(), commanded).unwrap();
+
+    let changed = FileFlag::from_bits_truncate(
+        fstat(f.as_raw_fd()).unwrap().st_flags.into(),
+    );
+
+    assert_eq!(commanded, changed);
+}
diff --git a/test/sys/test_sysinfo.rs b/test/sys/test_sysinfo.rs
index 73e6586..2897366 100644
--- a/test/sys/test_sysinfo.rs
+++ b/test/sys/test_sysinfo.rs
@@ -9,10 +9,12 @@ fn sysinfo_works() {
     assert!(l5 >= 0.0);
     assert!(l15 >= 0.0);
 
-    info.uptime();  // just test Duration construction
+    info.uptime(); // just test Duration construction
 
-    assert!(info.swap_free() <= info.swap_total(),
-            "more swap available than installed (free: {}, total: {})",
-            info.swap_free(),
-            info.swap_total());
+    assert!(
+        info.swap_free() <= info.swap_total(),
+        "more swap available than installed (free: {}, total: {})",
+        info.swap_free(),
+        info.swap_total()
+    );
 }
diff --git a/test/sys/test_termios.rs b/test/sys/test_termios.rs
index 4a86154..aaf0008 100644
--- a/test/sys/test_termios.rs
+++ b/test/sys/test_termios.rs
@@ -1,11 +1,11 @@
 use std::os::unix::prelude::*;
 use tempfile::tempfile;
 
-use nix::fcntl;
 use nix::errno::Errno;
+use nix::fcntl;
 use nix::pty::openpty;
-use nix::sys::termios::{self, LocalFlags, OutputFlags, tcgetattr};
-use nix::unistd::{read, write, close};
+use nix::sys::termios::{self, tcgetattr, LocalFlags, OutputFlags};
+use nix::unistd::{close, read, write};
 
 /// Helper function analogous to `std::io::Write::write_all`, but for `RawFd`s
 fn write_all(f: RawFd, buf: &[u8]) {
@@ -22,7 +22,7 @@ fn test_tcgetattr_pty() {
     let _m = crate::PTSNAME_MTX.lock();
 
     let pty = openpty(None, None).expect("openpty failed");
-    assert!(termios::tcgetattr(pty.slave).is_ok());
+    termios::tcgetattr(pty.slave).unwrap();
     close(pty.master).expect("closing the master failed");
     close(pty.slave).expect("closing the slave failed");
 }
@@ -31,15 +31,16 @@ fn test_tcgetattr_pty() {
 #[test]
 fn test_tcgetattr_enotty() {
     let file = tempfile().unwrap();
-    assert_eq!(termios::tcgetattr(file.as_raw_fd()).err(),
-               Some(Errno::ENOTTY));
+    assert_eq!(
+        termios::tcgetattr(file.as_raw_fd()).err(),
+        Some(Errno::ENOTTY)
+    );
 }
 
 // Test tcgetattr on an invalid file descriptor
 #[test]
 fn test_tcgetattr_ebadf() {
-    assert_eq!(termios::tcgetattr(-1).err(),
-               Some(Errno::EBADF));
+    assert_eq!(termios::tcgetattr(-1).err(), Some(Errno::EBADF));
 }
 
 // Test modifying output flags
@@ -60,11 +61,15 @@ fn test_output_flags() {
     };
 
     // Make sure postprocessing '\r' isn't specified by default or this test is useless.
-    assert!(!termios.output_flags.contains(OutputFlags::OPOST | OutputFlags::OCRNL));
+    assert!(!termios
+        .output_flags
+        .contains(OutputFlags::OPOST | OutputFlags::OCRNL));
 
     // Specify that '\r' characters should be transformed to '\n'
     // OPOST is specified to enable post-processing
-    termios.output_flags.insert(OutputFlags::OPOST | OutputFlags::OCRNL);
+    termios
+        .output_flags
+        .insert(OutputFlags::OPOST | OutputFlags::OCRNL);
 
     // Open a pty
     let pty = openpty(None, &termios).unwrap();
@@ -114,7 +119,8 @@ fn test_local_flags() {
 
     // Set the master is in nonblocking mode or reading will never return.
     let flags = fcntl::fcntl(pty.master, fcntl::F_GETFL).unwrap();
-    let new_flags = fcntl::OFlag::from_bits_truncate(flags) | fcntl::OFlag::O_NONBLOCK;
+    let new_flags =
+        fcntl::OFlag::from_bits_truncate(flags) | fcntl::OFlag::O_NONBLOCK;
     fcntl::fcntl(pty.master, fcntl::F_SETFL(new_flags)).unwrap();
 
     // Write into the master
diff --git a/test/sys/test_timerfd.rs b/test/sys/test_timerfd.rs
index 24fb2ac..08e2921 100644
--- a/test/sys/test_timerfd.rs
+++ b/test/sys/test_timerfd.rs
@@ -1,10 +1,13 @@
 use nix::sys::time::{TimeSpec, TimeValLike};
-use nix::sys::timerfd::{ClockId, Expiration, TimerFd, TimerFlags, TimerSetTimeFlags};
+use nix::sys::timerfd::{
+    ClockId, Expiration, TimerFd, TimerFlags, TimerSetTimeFlags,
+};
 use std::time::Instant;
 
 #[test]
 pub fn test_timerfd_oneshot() {
-    let timer = TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
 
     let before = Instant::now();
 
@@ -23,12 +26,16 @@ pub fn test_timerfd_oneshot() {
 
 #[test]
 pub fn test_timerfd_interval() {
-    let timer = TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
 
     let before = Instant::now();
     timer
         .set(
-            Expiration::IntervalDelayed(TimeSpec::seconds(1), TimeSpec::seconds(2)),
+            Expiration::IntervalDelayed(
+                TimeSpec::seconds(1),
+                TimeSpec::seconds(2),
+            ),
             TimerSetTimeFlags::empty(),
         )
         .unwrap();
@@ -46,7 +53,8 @@ pub fn test_timerfd_interval() {
 
 #[test]
 pub fn test_timerfd_unset() {
-    let timer = TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
+    let timer =
+        TimerFd::new(ClockId::CLOCK_MONOTONIC, TimerFlags::empty()).unwrap();
 
     timer
         .set(
@@ -57,5 +65,5 @@ pub fn test_timerfd_unset() {
 
     timer.unset().unwrap();
 
-    assert!(timer.get().unwrap() == None);
+    assert!(timer.get().unwrap().is_none());
 }
diff --git a/test/sys/test_uio.rs b/test/sys/test_uio.rs
index c63b581..0f4b8a6 100644
--- a/test/sys/test_uio.rs
+++ b/test/sys/test_uio.rs
@@ -1,14 +1,18 @@
 use nix::sys::uio::*;
 use nix::unistd::*;
-use rand::{thread_rng, Rng};
 use rand::distributions::Alphanumeric;
-use std::{cmp, iter};
-use std::fs::{OpenOptions};
+use rand::{thread_rng, Rng};
+use std::fs::OpenOptions;
+use std::io::IoSlice;
 use std::os::unix::io::AsRawFd;
+use std::{cmp, iter};
 
 #[cfg(not(target_os = "redox"))]
-use tempfile::tempfile;
+use std::io::IoSliceMut;
+
 use tempfile::tempdir;
+#[cfg(not(target_os = "redox"))]
+use tempfile::tempfile;
 
 #[test]
 fn test_writev() {
@@ -27,41 +31,38 @@ fn test_writev() {
     let mut consumed = 0;
     while consumed < to_write.len() {
         let left = to_write.len() - consumed;
-        let slice_len = if left <= 64 { left } else { thread_rng().gen_range(64..cmp::min(256, left)) };
-        let b = &to_write[consumed..consumed+slice_len];
-        iovecs.push(IoVec::from_slice(b));
+        let slice_len = if left <= 64 {
+            left
+        } else {
+            thread_rng().gen_range(64..cmp::min(256, left))
+        };
+        let b = &to_write[consumed..consumed + slice_len];
+        iovecs.push(IoSlice::new(b));
         consumed += slice_len;
     }
     let pipe_res = pipe();
-    assert!(pipe_res.is_ok());
-    let (reader, writer) = pipe_res.ok().unwrap();
+    let (reader, writer) = pipe_res.expect("Couldn't create pipe");
     // FileDesc will close its filedesc (reader).
     let mut read_buf: Vec<u8> = iter::repeat(0u8).take(128 * 16).collect();
     // Blocking io, should write all data.
     let write_res = writev(writer, &iovecs);
-    // Successful write
-    assert!(write_res.is_ok());
-    let written = write_res.ok().unwrap();
+    let written = write_res.expect("couldn't write");
     // Check whether we written all data
     assert_eq!(to_write.len(), written);
     let read_res = read(reader, &mut read_buf[..]);
-    // Successful read
-    assert!(read_res.is_ok());
-    let read = read_res.ok().unwrap() as usize;
+    let read = read_res.expect("couldn't read");
     // Check we have read as much as we written
     assert_eq!(read, written);
     // Check equality of written and read data
     assert_eq!(&to_write, &read_buf);
-    let close_res = close(writer);
-    assert!(close_res.is_ok());
-    let close_res = close(reader);
-    assert!(close_res.is_ok());
+    close(writer).expect("closed writer");
+    close(reader).expect("closed reader");
 }
 
 #[test]
 #[cfg(not(target_os = "redox"))]
 fn test_readv() {
-    let s:String = thread_rng()
+    let s: String = thread_rng()
         .sample_iter(&Alphanumeric)
         .map(char::from)
         .take(128)
@@ -71,40 +72,36 @@ fn test_readv() {
     let mut allocated = 0;
     while allocated < to_write.len() {
         let left = to_write.len() - allocated;
-        let vec_len = if left <= 64 { left } else { thread_rng().gen_range(64..cmp::min(256, left)) };
+        let vec_len = if left <= 64 {
+            left
+        } else {
+            thread_rng().gen_range(64..cmp::min(256, left))
+        };
         let v: Vec<u8> = iter::repeat(0u8).take(vec_len).collect();
         storage.push(v);
         allocated += vec_len;
     }
     let mut iovecs = Vec::with_capacity(storage.len());
     for v in &mut storage {
-        iovecs.push(IoVec::from_mut_slice(&mut v[..]));
+        iovecs.push(IoSliceMut::new(&mut v[..]));
     }
-    let pipe_res = pipe();
-    assert!(pipe_res.is_ok());
-    let (reader, writer) = pipe_res.ok().unwrap();
+    let (reader, writer) = pipe().expect("couldn't create pipe");
     // Blocking io, should write all data.
-    let write_res = write(writer, &to_write);
-    // Successful write
-    assert!(write_res.is_ok());
-    let read_res = readv(reader, &mut iovecs[..]);
-    assert!(read_res.is_ok());
-    let read = read_res.ok().unwrap();
+    write(writer, &to_write).expect("write failed");
+    let read = readv(reader, &mut iovecs[..]).expect("read failed");
     // Check whether we've read all data
     assert_eq!(to_write.len(), read);
     // Cccumulate data from iovecs
     let mut read_buf = Vec::with_capacity(to_write.len());
     for iovec in &iovecs {
-        read_buf.extend(iovec.as_slice().iter().cloned());
+        read_buf.extend(iovec.iter().cloned());
     }
     // Check whether iovecs contain all written data
     assert_eq!(read_buf.len(), to_write.len());
     // Check equality of written and read data
     assert_eq!(&read_buf, &to_write);
-    let close_res = close(reader);
-    assert!(close_res.is_ok());
-    let close_res = close(writer);
-    assert!(close_res.is_ok());
+    close(reader).expect("couldn't close reader");
+    close(writer).expect("couldn't close writer");
 }
 
 #[test]
@@ -113,12 +110,12 @@ fn test_pwrite() {
     use std::io::Read;
 
     let mut file = tempfile().unwrap();
-    let buf = [1u8;8];
+    let buf = [1u8; 8];
     assert_eq!(Ok(8), pwrite(file.as_raw_fd(), &buf, 8));
     let mut file_content = Vec::new();
     file.read_to_end(&mut file_content).unwrap();
-    let mut expected = vec![0u8;8];
-    expected.extend(vec![1;8]);
+    let mut expected = vec![0u8; 8];
+    expected.extend(vec![1; 8]);
     assert_eq!(file_content, expected);
 }
 
@@ -129,37 +126,47 @@ fn test_pread() {
     let tempdir = tempdir().unwrap();
 
     let path = tempdir.path().join("pread_test_file");
-    let mut file = OpenOptions::new().write(true).read(true).create(true)
-                                    .truncate(true).open(path).unwrap();
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
     let file_content: Vec<u8> = (0..64).collect();
     file.write_all(&file_content).unwrap();
 
-    let mut buf = [0u8;16];
+    let mut buf = [0u8; 16];
     assert_eq!(Ok(16), pread(file.as_raw_fd(), &mut buf, 16));
     let expected: Vec<_> = (16..32).collect();
     assert_eq!(&buf[..], &expected[..]);
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_pwritev() {
     use std::io::Read;
 
     let to_write: Vec<u8> = (0..128).collect();
-    let expected: Vec<u8> = [vec![0;100], to_write.clone()].concat();
+    let expected: Vec<u8> = [vec![0; 100], to_write.clone()].concat();
 
     let iovecs = [
-        IoVec::from_slice(&to_write[0..17]),
-        IoVec::from_slice(&to_write[17..64]),
-        IoVec::from_slice(&to_write[64..128]),
+        IoSlice::new(&to_write[0..17]),
+        IoSlice::new(&to_write[17..64]),
+        IoSlice::new(&to_write[64..128]),
     ];
 
     let tempdir = tempdir().unwrap();
 
     // pwritev them into a temporary file
     let path = tempdir.path().join("pwritev_test_file");
-    let mut file = OpenOptions::new().write(true).read(true).create(true)
-                                    .truncate(true).open(path).unwrap();
+    let mut file = OpenOptions::new()
+        .write(true)
+        .read(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
 
     let written = pwritev(file.as_raw_fd(), &iovecs, 100).ok().unwrap();
     assert_eq!(written, to_write.len());
@@ -171,7 +178,7 @@ fn test_pwritev() {
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_preadv() {
     use std::io::Write;
 
@@ -182,21 +189,24 @@ fn test_preadv() {
 
     let path = tempdir.path().join("preadv_test_file");
 
-    let mut file = OpenOptions::new().read(true).write(true).create(true)
-                                    .truncate(true).open(path).unwrap();
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(path)
+        .unwrap();
     file.write_all(&to_write).unwrap();
 
-    let mut buffers: Vec<Vec<u8>> = vec![
-        vec![0; 24],
-        vec![0; 1],
-        vec![0; 75],
-    ];
+    let mut buffers: Vec<Vec<u8>> = vec![vec![0; 24], vec![0; 1], vec![0; 75]];
 
     {
         // Borrow the buffers into IoVecs and preadv into them
-        let iovecs: Vec<_> = buffers.iter_mut().map(
-            |buf| IoVec::from_mut_slice(&mut buf[..])).collect();
-        assert_eq!(Ok(100), preadv(file.as_raw_fd(), &iovecs, 100));
+        let mut iovecs: Vec<_> = buffers
+            .iter_mut()
+            .map(|buf| IoSliceMut::new(&mut buf[..]))
+            .collect();
+        assert_eq!(Ok(100), preadv(file.as_raw_fd(), &mut iovecs, 100));
     }
 
     let all = buffers.concat();
@@ -204,14 +214,15 @@ fn test_preadv() {
 }
 
 #[test]
-#[cfg(target_os = "linux")]
+#[cfg(all(target_os = "linux", not(target_env = "uclibc")))]
+// uclibc doesn't implement process_vm_readv
 // qemu-user doesn't implement process_vm_readv/writev on most arches
 #[cfg_attr(qemu, ignore)]
 fn test_process_vm_readv() {
-    use nix::unistd::ForkResult::*;
+    use crate::*;
     use nix::sys::signal::*;
     use nix::sys::wait::*;
-    use crate::*;
+    use nix::unistd::ForkResult::*;
 
     require_capability!("test_process_vm_readv", CAP_SYS_PTRACE);
     let _m = crate::FORK_MTX.lock();
@@ -221,7 +232,7 @@ fn test_process_vm_readv() {
     let mut vector = vec![1u8, 2, 3, 4, 5];
 
     let (r, w) = pipe().unwrap();
-    match unsafe{fork()}.expect("Error: Fork Failed") {
+    match unsafe { fork() }.expect("Error: Fork Failed") {
         Parent { child } => {
             close(w).unwrap();
             // wait for child
@@ -232,16 +243,18 @@ fn test_process_vm_readv() {
             let remote_iov = RemoteIoVec { base: ptr, len: 5 };
             let mut buf = vec![0u8; 5];
 
-            let ret = process_vm_readv(child,
-                                       &[IoVec::from_mut_slice(&mut buf)],
-                                       &[remote_iov]);
+            let ret = process_vm_readv(
+                child,
+                &mut [IoSliceMut::new(&mut buf)],
+                &[remote_iov],
+            );
 
             kill(child, SIGTERM).unwrap();
             waitpid(child, None).unwrap();
 
             assert_eq!(Ok(5), ret);
             assert_eq!(20u8, buf.iter().sum());
-        },
+        }
         Child => {
             let _ = close(r);
             for i in &mut vector {
@@ -249,7 +262,9 @@ fn test_process_vm_readv() {
             }
             let _ = write(w, b"\0");
             let _ = close(w);
-            loop { let _ = pause(); }
-        },
+            loop {
+                pause();
+            }
+        }
     }
 }
diff --git a/test/sys/test_wait.rs b/test/sys/test_wait.rs
index afe4f42..d472f1e 100644
--- a/test/sys/test_wait.rs
+++ b/test/sys/test_wait.rs
@@ -1,25 +1,55 @@
+use libc::_exit;
 use nix::errno::Errno;
-use nix::unistd::*;
-use nix::unistd::ForkResult::*;
 use nix::sys::signal::*;
 use nix::sys::wait::*;
-use libc::_exit;
+use nix::unistd::ForkResult::*;
+use nix::unistd::*;
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_wait_signal() {
     let _m = crate::FORK_MTX.lock();
 
     // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
-    match unsafe{fork()}.expect("Error: Fork Failed") {
-      Child => {
-          pause();
-          unsafe { _exit(123) }
-      },
-      Parent { child } => {
-          kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
-          assert_eq!(waitpid(child, None), Ok(WaitStatus::Signaled(child, SIGKILL, false)));
-      },
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitpid(child, None),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false))
+            );
+        }
+    }
+}
+
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    //target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
+fn test_waitid_signal() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => {
+            pause();
+            unsafe { _exit(123) }
+        }
+        Parent { child } => {
+            kill(child, Some(SIGKILL)).expect("Error: Kill Failed");
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Signaled(child, SIGKILL, false)),
+            );
+        }
     }
 }
 
@@ -28,19 +58,53 @@ fn test_wait_exit() {
     let _m = crate::FORK_MTX.lock();
 
     // Safe: Child only calls `_exit`, which is async-signal-safe.
-    match unsafe{fork()}.expect("Error: Fork Failed") {
-      Child => unsafe { _exit(12); },
-      Parent { child } => {
-          assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 12)));
-      },
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 12)));
+        }
+    }
+}
+
+#[cfg(not(target_os = "haiku"))]
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+#[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
+fn test_waitid_exit() {
+    let _m = crate::FORK_MTX.lock();
+
+    // Safe: Child only calls `_exit`, which is async-signal-safe.
+    match unsafe { fork() }.expect("Error: Fork Failed") {
+        Child => unsafe {
+            _exit(12);
+        },
+        Parent { child } => {
+            assert_eq!(
+                waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+                Ok(WaitStatus::Exited(child, 12)),
+            );
+        }
     }
 }
 
 #[test]
 fn test_waitstatus_from_raw() {
     let pid = Pid::from_raw(1);
-    assert_eq!(WaitStatus::from_raw(pid, 0x0002), Ok(WaitStatus::Signaled(pid, Signal::SIGINT, false)));
-    assert_eq!(WaitStatus::from_raw(pid, 0x0200), Ok(WaitStatus::Exited(pid, 2)));
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0002),
+        Ok(WaitStatus::Signaled(pid, Signal::SIGINT, false))
+    );
+    assert_eq!(
+        WaitStatus::from_raw(pid, 0x0200),
+        Ok(WaitStatus::Exited(pid, 2))
+    );
     assert_eq!(WaitStatus::from_raw(pid, 0x7f7f), Err(Errno::EINVAL));
 }
 
@@ -48,7 +112,7 @@ fn test_waitstatus_from_raw() {
 fn test_waitstatus_pid() {
     let _m = crate::FORK_MTX.lock();
 
-    match unsafe{fork()}.unwrap() {
+    match unsafe { fork() }.unwrap() {
         Child => unsafe { _exit(0) },
         Parent { child } => {
             let status = waitpid(child, None).unwrap();
@@ -57,17 +121,36 @@ fn test_waitstatus_pid() {
     }
 }
 
+#[test]
+#[cfg(any(
+    target_os = "android",
+    target_os = "freebsd",
+    target_os = "haiku",
+    all(target_os = "linux", not(target_env = "uclibc")),
+))]
+fn test_waitid_pid() {
+    let _m = crate::FORK_MTX.lock();
+
+    match unsafe { fork() }.unwrap() {
+        Child => unsafe { _exit(0) },
+        Parent { child } => {
+            let status = waitid(Id::Pid(child), WaitPidFlag::WEXITED).unwrap();
+            assert_eq!(status.pid(), Some(child));
+        }
+    }
+}
+
 #[cfg(any(target_os = "linux", target_os = "android"))]
 // FIXME: qemu-user doesn't implement ptrace on most arches
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 mod ptrace {
-    use nix::sys::ptrace::{self, Options, Event};
+    use crate::*;
+    use libc::_exit;
+    use nix::sys::ptrace::{self, Event, Options};
     use nix::sys::signal::*;
     use nix::sys::wait::*;
-    use nix::unistd::*;
     use nix::unistd::ForkResult::*;
-    use libc::_exit;
-    use crate::*;
+    use nix::unistd::*;
 
     fn ptrace_child() -> ! {
         ptrace::traceme().unwrap();
@@ -77,31 +160,98 @@ mod ptrace {
         unsafe { _exit(0) }
     }
 
-    fn ptrace_parent(child: Pid) {
+    fn ptrace_wait_parent(child: Pid) {
         // Wait for the raised SIGTRAP
-        assert_eq!(waitpid(child, None), Ok(WaitStatus::Stopped(child, SIGTRAP)));
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::Stopped(child, SIGTRAP))
+        );
         // We want to test a syscall stop and a PTRACE_EVENT stop
-        assert!(ptrace::setoptions(child, Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT).is_ok());
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setoptions failed");
 
         // First, stop on the next system call, which will be exit()
-        assert!(ptrace::syscall(child, None).is_ok());
+        ptrace::syscall(child, None).expect("syscall failed");
         assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceSyscall(child)));
         // Then get the ptrace event for the process exiting
-        assert!(ptrace::cont(child, None).is_ok());
-        assert_eq!(waitpid(child, None), Ok(WaitStatus::PtraceEvent(child, SIGTRAP, Event::PTRACE_EVENT_EXIT as i32)));
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitpid(child, None),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            ))
+        );
         // Finally get the normal wait() result, now that the process has exited
-        assert!(ptrace::cont(child, None).is_ok());
+        ptrace::cont(child, None).expect("cont failed");
         assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 0)));
     }
 
+    #[cfg(not(target_env = "uclibc"))]
+    fn ptrace_waitid_parent(child: Pid) {
+        // Wait for the raised SIGTRAP
+        //
+        // Unlike waitpid(), waitid() can distinguish trap events from regular
+        // stop events, so unlike ptrace_wait_parent(), we get a PtraceEvent here
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(child, SIGTRAP, 0)),
+        );
+        // We want to test a syscall stop and a PTRACE_EVENT stop
+        ptrace::setoptions(
+            child,
+            Options::PTRACE_O_TRACESYSGOOD | Options::PTRACE_O_TRACEEXIT,
+        )
+        .expect("setopts failed");
+
+        // First, stop on the next system call, which will be exit()
+        ptrace::syscall(child, None).expect("syscall failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceSyscall(child)),
+        );
+        // Then get the ptrace event for the process exiting
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::PtraceEvent(
+                child,
+                SIGTRAP,
+                Event::PTRACE_EVENT_EXIT as i32
+            )),
+        );
+        // Finally get the normal wait() result, now that the process has exited
+        ptrace::cont(child, None).expect("cont failed");
+        assert_eq!(
+            waitid(Id::Pid(child), WaitPidFlag::WEXITED),
+            Ok(WaitStatus::Exited(child, 0)),
+        );
+    }
+
     #[test]
     fn test_wait_ptrace() {
         require_capability!("test_wait_ptrace", CAP_SYS_PTRACE);
         let _m = crate::FORK_MTX.lock();
 
-        match unsafe{fork()}.expect("Error: Fork Failed") {
+        match unsafe { fork() }.expect("Error: Fork Failed") {
+            Child => ptrace_child(),
+            Parent { child } => ptrace_wait_parent(child),
+        }
+    }
+
+    #[test]
+    #[cfg(not(target_env = "uclibc"))]
+    fn test_waitid_ptrace() {
+        require_capability!("test_waitid_ptrace", CAP_SYS_PTRACE);
+        let _m = crate::FORK_MTX.lock();
+
+        match unsafe { fork() }.expect("Error: Fork Failed") {
             Child => ptrace_child(),
-            Parent { child } => ptrace_parent(child),
+            Parent { child } => ptrace_waitid_parent(child),
         }
     }
 }
diff --git a/test/test.rs b/test/test.rs
index aade937..6b42aad 100644
--- a/test/test.rs
+++ b/test/test.rs
@@ -1,6 +1,6 @@
 #[macro_use]
 extern crate cfg_if;
-#[cfg_attr(not(target_os = "redox"), macro_use)]
+#[cfg_attr(not(any(target_os = "redox", target_os = "haiku")), macro_use)]
 extern crate nix;
 #[macro_use]
 extern crate lazy_static;
@@ -10,45 +10,67 @@ mod sys;
 #[cfg(not(target_os = "redox"))]
 mod test_dir;
 mod test_fcntl;
-#[cfg(any(target_os = "android",
-          target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "linux"))]
 mod test_kmod;
-#[cfg(target_os = "freebsd")]
-mod test_nmount;
-#[cfg(any(target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "fushsia",
-          target_os = "linux",
-          target_os = "netbsd"))]
+#[cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "fushsia",
+    target_os = "linux",
+    target_os = "netbsd"
+))]
 mod test_mq;
 #[cfg(not(target_os = "redox"))]
 mod test_net;
 mod test_nix_path;
-mod test_resource;
+#[cfg(target_os = "freebsd")]
+mod test_nmount;
 mod test_poll;
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 mod test_pty;
-#[cfg(any(target_os = "android",
-          target_os = "linux"))]
+mod test_resource;
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    all(target_os = "freebsd", fbsd14),
+    target_os = "linux"
+))]
 mod test_sched;
-#[cfg(any(target_os = "android",
-          target_os = "freebsd",
-          target_os = "ios",
-          target_os = "linux",
-          target_os = "macos"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "linux",
+    target_os = "macos"
+))]
 mod test_sendfile;
 mod test_stat;
 mod test_time;
+#[cfg(all(
+    any(
+        target_os = "freebsd",
+        target_os = "illumos",
+        target_os = "linux",
+        target_os = "netbsd"
+    ),
+    feature = "time",
+    feature = "signal"
+))]
+mod test_timer;
 mod test_unistd;
 
+use nix::unistd::{chdir, getcwd, read};
+use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
 use std::os::unix::io::RawFd;
 use std::path::PathBuf;
-use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
-use nix::unistd::{chdir, getcwd, read};
-
 
 /// Helper function analogous to `std::io::Read::read_exact`, but for `RawFD`s
-fn read_exact(f: RawFd, buf: &mut  [u8]) {
+fn read_exact(f: RawFd, buf: &mut [u8]) {
     let mut len = 0;
     while len < buf.len() {
         // get_mut would be better than split_at_mut, but it requires nightly
@@ -79,13 +101,13 @@ lazy_static! {
 /// RAII object that restores a test's original directory on drop
 struct DirRestore<'a> {
     d: PathBuf,
-    _g: RwLockWriteGuard<'a, ()>
+    _g: RwLockWriteGuard<'a, ()>,
 }
 
 impl<'a> DirRestore<'a> {
     fn new() -> Self {
         let guard = crate::CWD_LOCK.write();
-        DirRestore{
+        DirRestore {
             _g: guard,
             d: getcwd().unwrap(),
         }
diff --git a/test/test_dir.rs b/test/test_dir.rs
index 2940b6e..2af4aa5 100644
--- a/test/test_dir.rs
+++ b/test/test_dir.rs
@@ -4,7 +4,6 @@ use nix::sys::stat::Mode;
 use std::fs::File;
 use tempfile::tempdir;
 
-
 #[cfg(test)]
 fn flags() -> OFlag {
     #[cfg(target_os = "illumos")]
@@ -17,11 +16,11 @@ fn flags() -> OFlag {
 }
 
 #[test]
-#[allow(clippy::unnecessary_sort_by)]   // False positive
+#[allow(clippy::unnecessary_sort_by)] // False positive
 fn read() {
     let tmp = tempdir().unwrap();
-    File::create(&tmp.path().join("foo")).unwrap();
-    ::std::os::unix::fs::symlink("foo", tmp.path().join("bar")).unwrap();
+    File::create(tmp.path().join("foo")).unwrap();
+    std::os::unix::fs::symlink("foo", tmp.path().join("bar")).unwrap();
     let mut dir = Dir::open(tmp.path(), flags(), Mode::empty()).unwrap();
     let mut entries: Vec<_> = dir.iter().map(|e| e.unwrap()).collect();
     entries.sort_by(|a, b| a.file_name().cmp(b.file_name()));
@@ -43,13 +42,23 @@ fn read() {
 fn rewind() {
     let tmp = tempdir().unwrap();
     let mut dir = Dir::open(tmp.path(), flags(), Mode::empty()).unwrap();
-    let entries1: Vec<_> = dir.iter().map(|e| e.unwrap().file_name().to_owned()).collect();
-    let entries2: Vec<_> = dir.iter().map(|e| e.unwrap().file_name().to_owned()).collect();
-    let entries3: Vec<_> = dir.into_iter().map(|e| e.unwrap().file_name().to_owned()).collect();
+    let entries1: Vec<_> = dir
+        .iter()
+        .map(|e| e.unwrap().file_name().to_owned())
+        .collect();
+    let entries2: Vec<_> = dir
+        .iter()
+        .map(|e| e.unwrap().file_name().to_owned())
+        .collect();
+    let entries3: Vec<_> = dir
+        .into_iter()
+        .map(|e| e.unwrap().file_name().to_owned())
+        .collect();
     assert_eq!(entries1, entries2);
     assert_eq!(entries2, entries3);
 }
 
+#[cfg(not(target_os = "haiku"))]
 #[test]
 fn ebadf() {
     assert_eq!(Dir::from_fd(-1).unwrap_err(), nix::Error::EBADF);
diff --git a/test/test_fcntl.rs b/test/test_fcntl.rs
index db2acfb..e51044a 100644
--- a/test/test_fcntl.rs
+++ b/test/test_fcntl.rs
@@ -1,7 +1,7 @@
 #[cfg(not(target_os = "redox"))]
 use nix::errno::*;
 #[cfg(not(target_os = "redox"))]
-use nix::fcntl::{open, OFlag, readlink};
+use nix::fcntl::{open, readlink, OFlag};
 #[cfg(not(target_os = "redox"))]
 use nix::fcntl::{openat, readlinkat, renameat};
 #[cfg(all(
@@ -14,34 +14,40 @@ use nix::fcntl::{openat, readlinkat, renameat};
         target_arch = "s390x"
     )
 ))]
-use nix::fcntl::{RenameFlags, renameat2};
+use nix::fcntl::{renameat2, RenameFlags};
 #[cfg(not(target_os = "redox"))]
 use nix::sys::stat::Mode;
 #[cfg(not(target_os = "redox"))]
 use nix::unistd::{close, read};
 #[cfg(not(target_os = "redox"))]
-use tempfile::{self, NamedTempFile};
-#[cfg(not(target_os = "redox"))]
 use std::fs::File;
 #[cfg(not(target_os = "redox"))]
 use std::io::prelude::*;
 #[cfg(not(target_os = "redox"))]
 use std::os::unix::fs;
+#[cfg(not(target_os = "redox"))]
+use tempfile::{self, NamedTempFile};
 
 #[test]
 #[cfg(not(target_os = "redox"))]
+// QEMU does not handle openat well enough to satisfy this test
+// https://gitlab.com/qemu-project/qemu/-/issues/829
+#[cfg_attr(qemu, ignore)]
 fn test_openat() {
     const CONTENTS: &[u8] = b"abcd";
     let mut tmp = NamedTempFile::new().unwrap();
     tmp.write_all(CONTENTS).unwrap();
 
-    let dirfd = open(tmp.path().parent().unwrap(),
-                     OFlag::empty(),
-                     Mode::empty()).unwrap();
-    let fd = openat(dirfd,
-                    tmp.path().file_name().unwrap(),
-                    OFlag::O_RDONLY,
-                    Mode::empty()).unwrap();
+    let dirfd =
+        open(tmp.path().parent().unwrap(), OFlag::empty(), Mode::empty())
+            .unwrap();
+    let fd = openat(
+        dirfd,
+        tmp.path().file_name().unwrap(),
+        OFlag::O_RDONLY,
+        Mode::empty(),
+    )
+    .unwrap();
 
     let mut buf = [0u8; 1024];
     assert_eq!(4, read(fd, &mut buf).unwrap());
@@ -55,14 +61,18 @@ fn test_openat() {
 #[cfg(not(target_os = "redox"))]
 fn test_renameat() {
     let old_dir = tempfile::tempdir().unwrap();
-    let old_dirfd = open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let old_dirfd =
+        open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let old_path = old_dir.path().join("old");
-    File::create(&old_path).unwrap();
+    File::create(old_path).unwrap();
     let new_dir = tempfile::tempdir().unwrap();
-    let new_dirfd = open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let new_dirfd =
+        open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap();
-    assert_eq!(renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap_err(),
-               Errno::ENOENT);
+    assert_eq!(
+        renameat(Some(old_dirfd), "old", Some(new_dirfd), "new").unwrap_err(),
+        Errno::ENOENT
+    );
     close(old_dirfd).unwrap();
     close(new_dirfd).unwrap();
     assert!(new_dir.path().join("new").exists());
@@ -81,11 +91,13 @@ fn test_renameat() {
 ))]
 fn test_renameat2_behaves_like_renameat_with_no_flags() {
     let old_dir = tempfile::tempdir().unwrap();
-    let old_dirfd = open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let old_dirfd =
+        open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let old_path = old_dir.path().join("old");
-    File::create(&old_path).unwrap();
+    File::create(old_path).unwrap();
     let new_dir = tempfile::tempdir().unwrap();
-    let new_dirfd = open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let new_dirfd =
+        open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     renameat2(
         Some(old_dirfd),
         "old",
@@ -123,14 +135,16 @@ fn test_renameat2_behaves_like_renameat_with_no_flags() {
 ))]
 fn test_renameat2_exchange() {
     let old_dir = tempfile::tempdir().unwrap();
-    let old_dirfd = open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let old_dirfd =
+        open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let old_path = old_dir.path().join("old");
     {
         let mut old_f = File::create(&old_path).unwrap();
         old_f.write_all(b"old").unwrap();
     }
     let new_dir = tempfile::tempdir().unwrap();
-    let new_dirfd = open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let new_dirfd =
+        open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let new_path = new_dir.path().join("new");
     {
         let mut new_f = File::create(&new_path).unwrap();
@@ -169,13 +183,15 @@ fn test_renameat2_exchange() {
 ))]
 fn test_renameat2_noreplace() {
     let old_dir = tempfile::tempdir().unwrap();
-    let old_dirfd = open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let old_dirfd =
+        open(old_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let old_path = old_dir.path().join("old");
-    File::create(&old_path).unwrap();
+    File::create(old_path).unwrap();
     let new_dir = tempfile::tempdir().unwrap();
-    let new_dirfd = open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let new_dirfd =
+        open(new_dir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let new_path = new_dir.path().join("new");
-    File::create(&new_path).unwrap();
+    File::create(new_path).unwrap();
     assert_eq!(
         renameat2(
             Some(old_dirfd),
@@ -193,7 +209,6 @@ fn test_renameat2_noreplace() {
     assert!(old_dir.path().join("old").exists());
 }
 
-
 #[test]
 #[cfg(not(target_os = "redox"))]
 fn test_readlink() {
@@ -201,26 +216,25 @@ fn test_readlink() {
     let src = tempdir.path().join("a");
     let dst = tempdir.path().join("b");
     println!("a: {:?}, b: {:?}", &src, &dst);
-    fs::symlink(&src.as_path(), &dst.as_path()).unwrap();
-    let dirfd = open(tempdir.path(),
-                     OFlag::empty(),
-                     Mode::empty()).unwrap();
+    fs::symlink(src.as_path(), dst.as_path()).unwrap();
+    let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
     let expected_dir = src.to_str().unwrap();
 
     assert_eq!(readlink(&dst).unwrap().to_str().unwrap(), expected_dir);
-    assert_eq!(readlinkat(dirfd, "b").unwrap().to_str().unwrap(), expected_dir);
-
+    assert_eq!(
+        readlinkat(dirfd, "b").unwrap().to_str().unwrap(),
+        expected_dir
+    );
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux_android {
+    use libc::loff_t;
     use std::io::prelude::*;
-    use std::io::SeekFrom;
+    use std::io::IoSlice;
     use std::os::unix::prelude::*;
-    use libc::loff_t;
 
     use nix::fcntl::*;
-    use nix::sys::uio::IoVec;
     use nix::unistd::{close, pipe, read, write};
 
     use tempfile::tempfile;
@@ -258,7 +272,7 @@ mod linux_android {
         .unwrap();
 
         let mut res: String = String::new();
-        tmp2.seek(SeekFrom::Start(0)).unwrap();
+        tmp2.rewind().unwrap();
         tmp2.read_to_string(&mut res).unwrap();
 
         assert_eq!(res, String::from("bar"));
@@ -273,8 +287,15 @@ mod linux_android {
 
         let (rd, wr) = pipe().unwrap();
         let mut offset: loff_t = 5;
-        let res = splice(tmp.as_raw_fd(), Some(&mut offset),
-            wr, None, 2, SpliceFFlags::empty()).unwrap();
+        let res = splice(
+            tmp.as_raw_fd(),
+            Some(&mut offset),
+            wr,
+            None,
+            2,
+            SpliceFFlags::empty(),
+        )
+        .unwrap();
 
         assert_eq!(2, res);
 
@@ -319,10 +340,7 @@ mod linux_android {
 
         let buf1 = b"abcdef";
         let buf2 = b"defghi";
-        let iovecs = vec![
-            IoVec::from_slice(&buf1[0..3]),
-            IoVec::from_slice(&buf2[0..3])
-        ];
+        let iovecs = vec![IoSlice::new(&buf1[0..3]), IoSlice::new(&buf2[0..3])];
 
         let res = vmsplice(wr, &iovecs[..], SpliceFFlags::empty()).unwrap();
 
@@ -357,6 +375,7 @@ mod linux_android {
 
     #[test]
     #[cfg(all(target_os = "linux", not(target_env = "musl")))]
+    #[cfg_attr(target_env = "uclibc", ignore)] // uclibc doesn't support OFD locks, but the test should still compile
     fn test_ofd_write_lock() {
         use nix::sys::stat::fstat;
         use std::mem;
@@ -374,7 +393,7 @@ mod linux_android {
         let inode = fstat(fd).expect("fstat failed").st_ino as usize;
 
         let mut flock: libc::flock = unsafe {
-            mem::zeroed()  // required for Linux/mips
+            mem::zeroed() // required for Linux/mips
         };
         flock.l_type = libc::F_WRLCK as libc::c_short;
         flock.l_whence = libc::SEEK_SET as libc::c_short;
@@ -394,6 +413,7 @@ mod linux_android {
 
     #[test]
     #[cfg(all(target_os = "linux", not(target_env = "musl")))]
+    #[cfg_attr(target_env = "uclibc", ignore)] // uclibc doesn't support OFD locks, but the test should still compile
     fn test_ofd_read_lock() {
         use nix::sys::stat::fstat;
         use std::mem;
@@ -411,7 +431,7 @@ mod linux_android {
         let inode = fstat(fd).expect("fstat failed").st_ino as usize;
 
         let mut flock: libc::flock = unsafe {
-            mem::zeroed()  // required for Linux/mips
+            mem::zeroed() // required for Linux/mips
         };
         flock.l_type = libc::F_RDLCK as libc::c_short;
         flock.l_whence = libc::SEEK_SET as libc::c_short;
@@ -431,10 +451,7 @@ mod linux_android {
 
     #[cfg(all(target_os = "linux", not(target_env = "musl")))]
     fn lock_info(inode: usize) -> Option<(String, String)> {
-        use std::{
-            fs::File,
-            io::BufReader
-        };
+        use std::{fs::File, io::BufReader};
 
         let file = File::open("/proc/locks").expect("open /proc/locks failed");
         let buf = BufReader::new(file);
@@ -454,51 +471,63 @@ mod linux_android {
     }
 }
 
-#[cfg(any(target_os = "linux",
-          target_os = "android",
-          target_os = "emscripten",
-          target_os = "fuchsia",
-          any(target_os = "wasi", target_env = "wasi"),
-          target_env = "uclibc",
-          target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    target_os = "wasi",
+    target_env = "uclibc",
+    target_os = "freebsd"
+))]
 mod test_posix_fadvise {
 
-    use tempfile::NamedTempFile;
-    use std::os::unix::io::{RawFd, AsRawFd};
     use nix::errno::Errno;
     use nix::fcntl::*;
     use nix::unistd::pipe;
+    use std::os::unix::io::{AsRawFd, RawFd};
+    use tempfile::NamedTempFile;
 
     #[test]
     fn test_success() {
         let tmp = NamedTempFile::new().unwrap();
         let fd = tmp.as_raw_fd();
-        let res = posix_fadvise(fd, 0, 100, PosixFadviseAdvice::POSIX_FADV_WILLNEED);
-
-        assert!(res.is_ok());
+        posix_fadvise(fd, 0, 100, PosixFadviseAdvice::POSIX_FADV_WILLNEED)
+            .expect("posix_fadvise failed");
     }
 
     #[test]
     fn test_errno() {
         let (rd, _wr) = pipe().unwrap();
-        let res = posix_fadvise(rd as RawFd, 0, 100, PosixFadviseAdvice::POSIX_FADV_WILLNEED);
+        let res = posix_fadvise(
+            rd as RawFd,
+            0,
+            100,
+            PosixFadviseAdvice::POSIX_FADV_WILLNEED,
+        );
         assert_eq!(res, Err(Errno::ESPIPE));
     }
 }
 
-#[cfg(any(target_os = "linux",
-          target_os = "android",
-          target_os = "emscripten",
-          target_os = "fuchsia",
-          any(target_os = "wasi", target_env = "wasi"),
-          target_os = "freebsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "fuchsia",
+    target_os = "wasi",
+    target_os = "freebsd"
+))]
 mod test_posix_fallocate {
 
-    use tempfile::NamedTempFile;
-    use std::{io::Read, os::unix::io::{RawFd, AsRawFd}};
     use nix::errno::Errno;
     use nix::fcntl::*;
     use nix::unistd::pipe;
+    use std::{
+        io::Read,
+        os::unix::io::{AsRawFd, RawFd},
+    };
+    use tempfile::NamedTempFile;
 
     #[test]
     fn success() {
@@ -530,11 +559,7 @@ mod test_posix_fallocate {
         let err = posix_fallocate(rd as RawFd, 0, 100).unwrap_err();
         match err {
             Errno::EINVAL | Errno::ENODEV | Errno::ESPIPE | Errno::EBADF => (),
-            errno =>
-                panic!(
-                    "unexpected errno {}",
-                    errno,
-                ),
+            errno => panic!("unexpected errno {}", errno,),
         }
     }
 }
diff --git a/test/test_kmod/mod.rs b/test/test_kmod/mod.rs
index 8eef538..6f9aaa8 100644
--- a/test/test_kmod/mod.rs
+++ b/test/test_kmod/mod.rs
@@ -1,22 +1,25 @@
+use crate::*;
 use std::fs::copy;
 use std::path::PathBuf;
 use std::process::Command;
 use tempfile::{tempdir, TempDir};
-use crate::*;
 
 fn compile_kernel_module() -> (PathBuf, String, TempDir) {
     let _m = crate::FORK_MTX.lock();
 
-    let tmp_dir = tempdir().expect("unable to create temporary build directory");
+    let tmp_dir =
+        tempdir().expect("unable to create temporary build directory");
 
     copy(
         "test/test_kmod/hello_mod/hello.c",
-        &tmp_dir.path().join("hello.c"),
-    ).expect("unable to copy hello.c to temporary build directory");
+        tmp_dir.path().join("hello.c"),
+    )
+    .expect("unable to copy hello.c to temporary build directory");
     copy(
         "test/test_kmod/hello_mod/Makefile",
-        &tmp_dir.path().join("Makefile"),
-    ).expect("unable to copy Makefile to temporary build directory");
+        tmp_dir.path().join("Makefile"),
+    )
+    .expect("unable to copy Makefile to temporary build directory");
 
     let status = Command::new("make")
         .current_dir(tmp_dir.path())
@@ -51,12 +54,16 @@ fn test_finit_and_delete_module() {
     delete_module(
         &CString::new(kmod_name).unwrap(),
         DeleteModuleFlags::empty(),
-    ).expect("unable to unload kernel module");
+    )
+    .expect("unable to unload kernel module");
 }
 
 #[test]
 fn test_finit_and_delete_module_with_params() {
-    require_capability!("test_finit_and_delete_module_with_params", CAP_SYS_MODULE);
+    require_capability!(
+        "test_finit_and_delete_module_with_params",
+        CAP_SYS_MODULE
+    );
     let _m0 = crate::KMOD_MTX.lock();
     let _m1 = crate::CWD_LOCK.read();
 
@@ -67,12 +74,14 @@ fn test_finit_and_delete_module_with_params() {
         &f,
         &CString::new("who=Rust number=2018").unwrap(),
         ModuleInitFlags::empty(),
-    ).expect("unable to load kernel module");
+    )
+    .expect("unable to load kernel module");
 
     delete_module(
         &CString::new(kmod_name).unwrap(),
         DeleteModuleFlags::empty(),
-    ).expect("unable to unload kernel module");
+    )
+    .expect("unable to unload kernel module");
 }
 
 #[test]
@@ -87,17 +96,22 @@ fn test_init_and_delete_module() {
     let mut contents: Vec<u8> = Vec::new();
     f.read_to_end(&mut contents)
         .expect("unable to read kernel module content to buffer");
-    init_module(&contents, &CString::new("").unwrap()).expect("unable to load kernel module");
+    init_module(&contents, &CString::new("").unwrap())
+        .expect("unable to load kernel module");
 
     delete_module(
         &CString::new(kmod_name).unwrap(),
         DeleteModuleFlags::empty(),
-    ).expect("unable to unload kernel module");
+    )
+    .expect("unable to unload kernel module");
 }
 
 #[test]
 fn test_init_and_delete_module_with_params() {
-    require_capability!("test_init_and_delete_module_with_params", CAP_SYS_MODULE);
+    require_capability!(
+        "test_init_and_delete_module_with_params",
+        CAP_SYS_MODULE
+    );
     let _m0 = crate::KMOD_MTX.lock();
     let _m1 = crate::CWD_LOCK.read();
 
@@ -113,7 +127,8 @@ fn test_init_and_delete_module_with_params() {
     delete_module(
         &CString::new(kmod_name).unwrap(),
         DeleteModuleFlags::empty(),
-    ).expect("unable to unload kernel module");
+    )
+    .expect("unable to unload kernel module");
 }
 
 #[test]
@@ -125,14 +140,18 @@ fn test_finit_module_invalid() {
     let kmod_path = "/dev/zero";
 
     let f = File::open(kmod_path).expect("unable to open kernel module");
-    let result = finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty());
+    let result =
+        finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty());
 
     assert_eq!(result.unwrap_err(), Errno::EINVAL);
 }
 
 #[test]
 fn test_finit_module_twice_and_delete_module() {
-    require_capability!("test_finit_module_twice_and_delete_module", CAP_SYS_MODULE);
+    require_capability!(
+        "test_finit_module_twice_and_delete_module",
+        CAP_SYS_MODULE
+    );
     let _m0 = crate::KMOD_MTX.lock();
     let _m1 = crate::CWD_LOCK.read();
 
@@ -142,14 +161,16 @@ fn test_finit_module_twice_and_delete_module() {
     finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty())
         .expect("unable to load kernel module");
 
-    let result = finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty());
+    let result =
+        finit_module(&f, &CString::new("").unwrap(), ModuleInitFlags::empty());
 
     assert_eq!(result.unwrap_err(), Errno::EEXIST);
 
     delete_module(
         &CString::new(kmod_name).unwrap(),
         DeleteModuleFlags::empty(),
-    ).expect("unable to unload kernel module");
+    )
+    .expect("unable to unload kernel module");
 }
 
 #[test]
@@ -158,7 +179,10 @@ fn test_delete_module_not_loaded() {
     let _m0 = crate::KMOD_MTX.lock();
     let _m1 = crate::CWD_LOCK.read();
 
-    let result = delete_module(&CString::new("hello").unwrap(), DeleteModuleFlags::empty());
+    let result = delete_module(
+        &CString::new("hello").unwrap(),
+        DeleteModuleFlags::empty(),
+    );
 
     assert_eq!(result.unwrap_err(), Errno::ENOENT);
 }
diff --git a/test/test_mount.rs b/test/test_mount.rs
index 44287f9..2fd612e 100644
--- a/test/test_mount.rs
+++ b/test/test_mount.rs
@@ -1,6 +1,6 @@
 mod common;
 
-// Impelmentation note: to allow unprivileged users to run it, this test makes
+// Implementation note: to allow unprivileged users to run it, this test makes
 // use of user and mount namespaces. On systems that allow unprivileged user
 // namespaces (Linux >= 3.8 compiled with CONFIG_USER_NS), the test should run
 // without root.
@@ -27,16 +27,18 @@ exit 23";
     const EXPECTED_STATUS: i32 = 23;
 
     const NONE: Option<&'static [u8]> = None;
-    #[allow(clippy::bind_instead_of_map)]   // False positive
+    #[allow(clippy::bind_instead_of_map)] // False positive
     pub fn test_mount_tmpfs_without_flags_allows_rwx() {
         let tempdir = tempfile::tempdir().unwrap();
 
-        mount(NONE,
-              tempdir.path(),
-              Some(b"tmpfs".as_ref()),
-              MsFlags::empty(),
-              NONE)
-            .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        mount(
+            NONE,
+            tempdir.path(),
+            Some(b"tmpfs".as_ref()),
+            MsFlags::empty(),
+            NONE,
+        )
+        .unwrap_or_else(|e| panic!("mount failed: {}", e));
 
         let test_path = tempdir.path().join("test");
 
@@ -46,8 +48,10 @@ exit 23";
             .write(true)
             .mode((Mode::S_IRWXU | Mode::S_IRWXG | Mode::S_IRWXO).bits())
             .open(&test_path)
-            .or_else(|e|
-                if Errno::from_i32(e.raw_os_error().unwrap()) == Errno::EOVERFLOW {
+            .or_else(|e| {
+                if Errno::from_i32(e.raw_os_error().unwrap())
+                    == Errno::EOVERFLOW
+                {
                     // Skip tests on certain Linux kernels which have a bug
                     // regarding tmpfs in namespaces.
                     // Ubuntu 14.04 and 16.04 are known to be affected; 16.10 is
@@ -56,13 +60,16 @@ exit 23";
                     // https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1659087
                     let stderr = io::stderr();
                     let mut handle = stderr.lock();
-                    writeln!(handle, "Buggy Linux kernel detected.  Skipping test.")
+                    writeln!(
+                        handle,
+                        "Buggy Linux kernel detected.  Skipping test."
+                    )
                     .unwrap();
                     process::exit(0);
-               } else {
-                   panic!("open failed: {}", e);
-               }
-            )
+                } else {
+                    panic!("open failed: {}", e);
+                }
+            })
             .and_then(|mut f| f.write(SCRIPT_CONTENTS))
             .unwrap_or_else(|e| panic!("write failed: {}", e));
 
@@ -74,42 +81,55 @@ exit 23";
         assert_eq!(buf, SCRIPT_CONTENTS);
 
         // Verify execute.
-        assert_eq!(EXPECTED_STATUS,
-                   Command::new(&test_path)
-                       .status()
-                       .unwrap_or_else(|e| panic!("exec failed: {}", e))
-                       .code()
-                       .unwrap_or_else(|| panic!("child killed by signal")));
-
-        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {}", e));
+        assert_eq!(
+            EXPECTED_STATUS,
+            Command::new(&test_path)
+                .status()
+                .unwrap_or_else(|e| panic!("exec failed: {}", e))
+                .code()
+                .unwrap_or_else(|| panic!("child killed by signal"))
+        );
+
+        umount(tempdir.path())
+            .unwrap_or_else(|e| panic!("umount failed: {}", e));
     }
 
     pub fn test_mount_rdonly_disallows_write() {
         let tempdir = tempfile::tempdir().unwrap();
 
-        mount(NONE,
-              tempdir.path(),
-              Some(b"tmpfs".as_ref()),
-              MsFlags::MS_RDONLY,
-              NONE)
-            .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        mount(
+            NONE,
+            tempdir.path(),
+            Some(b"tmpfs".as_ref()),
+            MsFlags::MS_RDONLY,
+            NONE,
+        )
+        .unwrap_or_else(|e| panic!("mount failed: {}", e));
 
         // EROFS: Read-only file system
-        assert_eq!(EROFS as i32,
-                   File::create(tempdir.path().join("test")).unwrap_err().raw_os_error().unwrap());
-
-        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {}", e));
+        assert_eq!(
+            EROFS,
+            File::create(tempdir.path().join("test"))
+                .unwrap_err()
+                .raw_os_error()
+                .unwrap()
+        );
+
+        umount(tempdir.path())
+            .unwrap_or_else(|e| panic!("umount failed: {}", e));
     }
 
     pub fn test_mount_noexec_disallows_exec() {
         let tempdir = tempfile::tempdir().unwrap();
 
-        mount(NONE,
-              tempdir.path(),
-              Some(b"tmpfs".as_ref()),
-              MsFlags::MS_NOEXEC,
-              NONE)
-            .unwrap_or_else(|e| panic!("mount failed: {}", e));
+        mount(
+            NONE,
+            tempdir.path(),
+            Some(b"tmpfs".as_ref()),
+            MsFlags::MS_NOEXEC,
+            NONE,
+        )
+        .unwrap_or_else(|e| panic!("mount failed: {}", e));
 
         let test_path = tempdir.path().join("test");
 
@@ -122,21 +142,30 @@ exit 23";
             .unwrap_or_else(|e| panic!("write failed: {}", e));
 
         // Verify that we cannot execute despite a+x permissions being set.
-        let mode = stat::Mode::from_bits_truncate(fs::metadata(&test_path)
-                                                      .map(|md| md.permissions().mode())
-                                                      .unwrap_or_else(|e| {
-                                                          panic!("metadata failed: {}", e)
-                                                      }));
-
-        assert!(mode.contains(Mode::S_IXUSR | Mode::S_IXGRP | Mode::S_IXOTH),
-                "{:?} did not have execute permissions",
-                &test_path);
+        let mode = stat::Mode::from_bits_truncate(
+            fs::metadata(&test_path)
+                .map(|md| md.permissions().mode())
+                .unwrap_or_else(|e| panic!("metadata failed: {}", e)),
+        );
+
+        assert!(
+            mode.contains(Mode::S_IXUSR | Mode::S_IXGRP | Mode::S_IXOTH),
+            "{:?} did not have execute permissions",
+            &test_path
+        );
 
         // EACCES: Permission denied
-        assert_eq!(EACCES as i32,
-                   Command::new(&test_path).status().unwrap_err().raw_os_error().unwrap());
-
-        umount(tempdir.path()).unwrap_or_else(|e| panic!("umount failed: {}", e));
+        assert_eq!(
+            EACCES,
+            Command::new(&test_path)
+                .status()
+                .unwrap_err()
+                .raw_os_error()
+                .unwrap()
+        );
+
+        umount(tempdir.path())
+            .unwrap_or_else(|e| panic!("umount failed: {}", e));
     }
 
     pub fn test_mount_bind() {
@@ -146,12 +175,14 @@ exit 23";
         {
             let mount_point = tempfile::tempdir().unwrap();
 
-            mount(Some(tempdir.path()),
-                  mount_point.path(),
-                  NONE,
-                  MsFlags::MS_BIND,
-                  NONE)
-                .unwrap_or_else(|e| panic!("mount failed: {}", e));
+            mount(
+                Some(tempdir.path()),
+                mount_point.path(),
+                NONE,
+                MsFlags::MS_BIND,
+                NONE,
+            )
+            .unwrap_or_else(|e| panic!("mount failed: {}", e));
 
             fs::OpenOptions::new()
                 .create(true)
@@ -161,7 +192,8 @@ exit 23";
                 .and_then(|mut f| f.write(SCRIPT_CONTENTS))
                 .unwrap_or_else(|e| panic!("write failed: {}", e));
 
-            umount(mount_point.path()).unwrap_or_else(|e| panic!("umount failed: {}", e));
+            umount(mount_point.path())
+                .unwrap_or_else(|e| panic!("umount failed: {}", e));
         }
 
         // Verify the file written in the mount shows up in source directory, even
@@ -199,7 +231,6 @@ exit 23";
     }
 }
 
-
 // Test runner
 
 /// Mimic normal test output (hackishly).
@@ -220,16 +251,20 @@ macro_rules! run_tests {
 
 #[cfg(target_os = "linux")]
 fn main() {
-    use test_mount::{setup_namespaces, test_mount_tmpfs_without_flags_allows_rwx,
-                     test_mount_rdonly_disallows_write, test_mount_noexec_disallows_exec,
-                     test_mount_bind};
+    use test_mount::{
+        setup_namespaces, test_mount_bind, test_mount_noexec_disallows_exec,
+        test_mount_rdonly_disallows_write,
+        test_mount_tmpfs_without_flags_allows_rwx,
+    };
     skip_if_cirrus!("Fails for an unknown reason Cirrus CI.  Bug #1351");
     setup_namespaces();
 
-    run_tests!(test_mount_tmpfs_without_flags_allows_rwx,
-               test_mount_rdonly_disallows_write,
-               test_mount_noexec_disallows_exec,
-               test_mount_bind);
+    run_tests!(
+        test_mount_tmpfs_without_flags_allows_rwx,
+        test_mount_rdonly_disallows_write,
+        test_mount_noexec_disallows_exec,
+        test_mount_bind
+    );
 }
 
 #[cfg(not(target_os = "linux"))]
diff --git a/test/test_mq.rs b/test/test_mq.rs
index 430df5d..7b48e7a 100644
--- a/test/test_mq.rs
+++ b/test/test_mq.rs
@@ -1,16 +1,36 @@
+use cfg_if::cfg_if;
 use std::ffi::CString;
 use std::str;
 
 use nix::errno::Errno;
-use nix::mqueue::{mq_open, mq_close, mq_send, mq_receive, mq_attr_member_t};
-use nix::mqueue::{MqAttr, MQ_OFlag};
+use nix::mqueue::{mq_attr_member_t, mq_close, mq_open, mq_receive, mq_send};
+use nix::mqueue::{MQ_OFlag, MqAttr};
 use nix::sys::stat::Mode;
 
+// Defined as a macro such that the error source is reported as the caller's location.
+macro_rules! assert_attr_eq {
+    ($read_attr:ident, $initial_attr:ident) => {
+        cfg_if! {
+            if #[cfg(any(target_os = "dragonfly", target_os = "netbsd"))] {
+                // NetBSD (and others which inherit its implementation) include other flags
+                // in read_attr, such as those specified by oflag. Just make sure at least
+                // the correct bits are set.
+                assert_eq!($read_attr.flags() & $initial_attr.flags(), $initial_attr.flags());
+                assert_eq!($read_attr.maxmsg(), $initial_attr.maxmsg());
+                assert_eq!($read_attr.msgsize(), $initial_attr.msgsize());
+                assert_eq!($read_attr.curmsgs(), $initial_attr.curmsgs());
+            } else {
+                assert_eq!($read_attr, $initial_attr);
+            }
+        }
+    }
+}
+
 #[test]
 fn test_mq_send_and_receive() {
     const MSG_SIZE: mq_attr_member_t = 32;
-    let attr =  MqAttr::new(0, 10, MSG_SIZE, 0);
-    let mq_name= &CString::new(b"/a_nix_test_queue".as_ref()).unwrap();
+    let attr = MqAttr::new(0, 10, MSG_SIZE, 0);
+    let mq_name = &CString::new(b"/a_nix_test_queue".as_ref()).unwrap();
 
     let oflag0 = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
     let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
@@ -21,13 +41,13 @@ fn test_mq_send_and_receive() {
     };
     let mqd0 = r0.unwrap();
     let msg_to_send = "msg_1";
-    mq_send(mqd0, msg_to_send.as_bytes(), 1).unwrap();
+    mq_send(&mqd0, msg_to_send.as_bytes(), 1).unwrap();
 
     let oflag1 = MQ_OFlag::O_CREAT | MQ_OFlag::O_RDONLY;
     let mqd1 = mq_open(mq_name, oflag1, mode, Some(&attr)).unwrap();
     let mut buf = [0u8; 32];
     let mut prio = 0u32;
-    let len = mq_receive(mqd1, &mut buf, &mut prio).unwrap();
+    let len = mq_receive(&mqd1, &mut buf, &mut prio).unwrap();
     assert_eq!(prio, 1);
 
     mq_close(mqd1).unwrap();
@@ -35,13 +55,11 @@ fn test_mq_send_and_receive() {
     assert_eq!(msg_to_send, str::from_utf8(&buf[0..len]).unwrap());
 }
 
-
 #[test]
-#[cfg(not(any(target_os = "netbsd")))]
 fn test_mq_getattr() {
     use nix::mqueue::mq_getattr;
     const MSG_SIZE: mq_attr_member_t = 32;
-    let initial_attr =  MqAttr::new(0, 10, MSG_SIZE, 0);
+    let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
     let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
     let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
     let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
@@ -52,23 +70,21 @@ fn test_mq_getattr() {
     };
     let mqd = r.unwrap();
 
-    let read_attr = mq_getattr(mqd).unwrap();
-    assert_eq!(read_attr, initial_attr);
+    let read_attr = mq_getattr(&mqd).unwrap();
+    assert_attr_eq!(read_attr, initial_attr);
     mq_close(mqd).unwrap();
 }
 
 // FIXME: Fix failures for mips in QEMU
 #[test]
-#[cfg(not(any(target_os = "netbsd")))]
-#[cfg_attr(all(
-        qemu,
-        any(target_arch = "mips", target_arch = "mips64")
-    ), ignore
+#[cfg_attr(
+    all(qemu, any(target_arch = "mips", target_arch = "mips64")),
+    ignore
 )]
 fn test_mq_setattr() {
     use nix::mqueue::{mq_getattr, mq_setattr};
     const MSG_SIZE: mq_attr_member_t = 32;
-    let initial_attr =  MqAttr::new(0, 10, MSG_SIZE, 0);
+    let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
     let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
     let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
     let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
@@ -79,37 +95,46 @@ fn test_mq_setattr() {
     };
     let mqd = r.unwrap();
 
-    let new_attr =  MqAttr::new(0, 20, MSG_SIZE * 2, 100);
-    let old_attr = mq_setattr(mqd, &new_attr).unwrap();
-    assert_eq!(old_attr, initial_attr);
+    let new_attr = MqAttr::new(0, 20, MSG_SIZE * 2, 100);
+    let old_attr = mq_setattr(&mqd, &new_attr).unwrap();
+    assert_attr_eq!(old_attr, initial_attr);
 
-    let new_attr_get = mq_getattr(mqd).unwrap();
-    // The following tests make sense. No changes here because according to the Linux man page only
+    // No changes here because according to the Linux man page only
     // O_NONBLOCK can be set (see tests below)
-    assert_ne!(new_attr_get, new_attr);
-
-    let new_attr_non_blocking =  MqAttr::new(MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t, 10, MSG_SIZE, 0);
-    mq_setattr(mqd, &new_attr_non_blocking).unwrap();
-    let new_attr_get = mq_getattr(mqd).unwrap();
+    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd")))]
+    {
+        let new_attr_get = mq_getattr(&mqd).unwrap();
+        assert_ne!(new_attr_get, new_attr);
+    }
+
+    let new_attr_non_blocking = MqAttr::new(
+        MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t,
+        10,
+        MSG_SIZE,
+        0,
+    );
+    mq_setattr(&mqd, &new_attr_non_blocking).unwrap();
+    let new_attr_get = mq_getattr(&mqd).unwrap();
 
     // now the O_NONBLOCK flag has been set
-    assert_ne!(new_attr_get, initial_attr);
-    assert_eq!(new_attr_get, new_attr_non_blocking);
+    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd")))]
+    {
+        assert_ne!(new_attr_get, initial_attr);
+    }
+    assert_attr_eq!(new_attr_get, new_attr_non_blocking);
     mq_close(mqd).unwrap();
 }
 
 // FIXME: Fix failures for mips in QEMU
 #[test]
-#[cfg(not(any(target_os = "netbsd")))]
-#[cfg_attr(all(
-        qemu,
-        any(target_arch = "mips", target_arch = "mips64")
-    ), ignore
+#[cfg_attr(
+    all(qemu, any(target_arch = "mips", target_arch = "mips64")),
+    ignore
 )]
 fn test_mq_set_nonblocking() {
-    use nix::mqueue::{mq_getattr, mq_set_nonblock, mq_remove_nonblock};
+    use nix::mqueue::{mq_getattr, mq_remove_nonblock, mq_set_nonblock};
     const MSG_SIZE: mq_attr_member_t = 32;
-    let initial_attr =  MqAttr::new(0, 10, MSG_SIZE, 0);
+    let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
     let mq_name = &CString::new(b"/attr_test_get_attr".as_ref()).unwrap();
     let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
     let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
@@ -119,23 +144,25 @@ fn test_mq_set_nonblocking() {
         return;
     };
     let mqd = r.unwrap();
-    mq_set_nonblock(mqd).unwrap();
-    let new_attr = mq_getattr(mqd);
-    assert_eq!(new_attr.unwrap().flags(), MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t);
-    mq_remove_nonblock(mqd).unwrap();
-    let new_attr = mq_getattr(mqd);
-    assert_eq!(new_attr.unwrap().flags(), 0);
+    mq_set_nonblock(&mqd).unwrap();
+    let new_attr = mq_getattr(&mqd);
+    let o_nonblock_bits = MQ_OFlag::O_NONBLOCK.bits() as mq_attr_member_t;
+    assert_eq!(new_attr.unwrap().flags() & o_nonblock_bits, o_nonblock_bits);
+    mq_remove_nonblock(&mqd).unwrap();
+    let new_attr = mq_getattr(&mqd);
+    assert_eq!(new_attr.unwrap().flags() & o_nonblock_bits, 0);
     mq_close(mqd).unwrap();
 }
 
 #[test]
-#[cfg(not(any(target_os = "netbsd")))]
 fn test_mq_unlink() {
     use nix::mqueue::mq_unlink;
     const MSG_SIZE: mq_attr_member_t = 32;
-    let initial_attr =  MqAttr::new(0, 10, MSG_SIZE, 0);
+    let initial_attr = MqAttr::new(0, 10, MSG_SIZE, 0);
     let mq_name_opened = &CString::new(b"/mq_unlink_test".as_ref()).unwrap();
-    let mq_name_not_opened = &CString::new(b"/mq_unlink_test".as_ref()).unwrap();
+    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd")))]
+    let mq_name_not_opened =
+        &CString::new(b"/mq_unlink_test".as_ref()).unwrap();
     let oflag = MQ_OFlag::O_CREAT | MQ_OFlag::O_WRONLY;
     let mode = Mode::S_IWUSR | Mode::S_IRUSR | Mode::S_IRGRP | Mode::S_IROTH;
     let r = mq_open(mq_name_opened, oflag, mode, Some(&initial_attr));
@@ -146,12 +173,18 @@ fn test_mq_unlink() {
     let mqd = r.unwrap();
 
     let res_unlink = mq_unlink(mq_name_opened);
-    assert_eq!(res_unlink, Ok(()) );
+    assert_eq!(res_unlink, Ok(()));
 
-    let res_unlink_not_opened = mq_unlink(mq_name_not_opened);
-    assert_eq!(res_unlink_not_opened, Err(Errno::ENOENT) );
+    // NetBSD (and others which inherit its implementation) defer removing the message
+    // queue name until all references are closed, whereas Linux and others remove the
+    // message queue name immediately.
+    #[cfg(not(any(target_os = "dragonfly", target_os = "netbsd")))]
+    {
+        let res_unlink_not_opened = mq_unlink(mq_name_not_opened);
+        assert_eq!(res_unlink_not_opened, Err(Errno::ENOENT));
+    }
 
     mq_close(mqd).unwrap();
     let res_unlink_after_close = mq_unlink(mq_name_opened);
-    assert_eq!(res_unlink_after_close, Err(Errno::ENOENT) );
+    assert_eq!(res_unlink_after_close, Err(Errno::ENOENT));
 }
diff --git a/test/test_net.rs b/test/test_net.rs
index 40ecd6b..c44655a 100644
--- a/test/test_net.rs
+++ b/test/test_net.rs
@@ -3,10 +3,17 @@ use nix::net::if_::*;
 #[cfg(any(target_os = "android", target_os = "linux"))]
 const LOOPBACK: &[u8] = b"lo";
 
-#[cfg(not(any(target_os = "android", target_os = "linux")))]
+#[cfg(not(any(
+    target_os = "android",
+    target_os = "linux",
+    target_os = "haiku"
+)))]
 const LOOPBACK: &[u8] = b"lo0";
 
+#[cfg(target_os = "haiku")]
+const LOOPBACK: &[u8] = b"loop";
+
 #[test]
 fn test_if_nametoindex() {
-    assert!(if_nametoindex(LOOPBACK).is_ok());
+    if_nametoindex(LOOPBACK).expect("assertion failed");
 }
diff --git a/test/test_nix_path.rs b/test/test_nix_path.rs
index e69de29..8b13789 100644
--- a/test/test_nix_path.rs
+++ b/test/test_nix_path.rs
@@ -0,0 +1 @@
+
diff --git a/test/test_nmount.rs b/test/test_nmount.rs
index 4c74ecf..dec806a 100644
--- a/test/test_nmount.rs
+++ b/test/test_nmount.rs
@@ -1,13 +1,9 @@
 use crate::*;
 use nix::{
     errno::Errno,
-    mount::{MntFlags, Nmount, unmount}
-};
-use std::{
-    ffi::CString,
-    fs::File,
-    path::Path
+    mount::{unmount, MntFlags, Nmount},
 };
+use std::{ffi::CString, fs::File, path::Path};
 use tempfile::tempdir;
 
 #[test]
@@ -24,14 +20,15 @@ fn ok() {
         .str_opt(&fstype, &nullfs)
         .str_opt_owned("fspath", mountpoint.path().to_str().unwrap())
         .str_opt_owned("target", target.path().to_str().unwrap())
-        .nmount(MntFlags::empty()).unwrap();
-    
+        .nmount(MntFlags::empty())
+        .unwrap();
+
     // Now check that the sentry is visible through the mountpoint
     let exists = Path::exists(&mountpoint.path().join("sentry"));
 
     // Cleanup the mountpoint before asserting
     unmount(mountpoint.path(), MntFlags::empty()).unwrap();
-    
+
     assert!(exists);
 }
 
@@ -44,8 +41,9 @@ fn bad_fstype() {
     let e = Nmount::new()
         .str_opt_owned("fspath", mountpoint.path().to_str().unwrap())
         .str_opt_owned("target", target.path().to_str().unwrap())
-        .nmount(MntFlags::empty()).unwrap_err();
-    
+        .nmount(MntFlags::empty())
+        .unwrap_err();
+
     assert_eq!(e.error(), Errno::EINVAL);
     assert_eq!(e.errmsg(), Some("Invalid fstype"));
 }
diff --git a/test/test_poll.rs b/test/test_poll.rs
index e4b369f..53964e2 100644
--- a/test/test_poll.rs
+++ b/test/test_poll.rs
@@ -1,7 +1,7 @@
 use nix::{
     errno::Errno,
-    poll::{PollFlags, poll, PollFd},
-    unistd::{write, pipe}
+    poll::{poll, PollFd, PollFlags},
+    unistd::{pipe, write},
 };
 
 macro_rules! loop_while_eintr {
@@ -10,10 +10,10 @@ macro_rules! loop_while_eintr {
             match $poll_expr {
                 Ok(nfds) => break nfds,
                 Err(Errno::EINTR) => (),
-                Err(e) => panic!("{}", e)
+                Err(e) => panic!("{}", e),
             }
         }
-    }
+    };
 }
 
 #[test]
@@ -37,10 +37,12 @@ fn test_poll() {
 // ppoll(2) is the same as poll except for how it handles timeouts and signals.
 // Repeating the test for poll(2) should be sufficient to check that our
 // bindings are correct.
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "freebsd",
-          target_os = "linux"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux"
+))]
 #[test]
 fn test_ppoll() {
     use nix::poll::ppoll;
@@ -53,14 +55,14 @@ fn test_ppoll() {
 
     // Poll an idle pipe.  Should timeout
     let sigset = SigSet::empty();
-    let nfds = loop_while_eintr!(ppoll(&mut fds, Some(timeout), sigset));
+    let nfds = loop_while_eintr!(ppoll(&mut fds, Some(timeout), Some(sigset)));
     assert_eq!(nfds, 0);
     assert!(!fds[0].revents().unwrap().contains(PollFlags::POLLIN));
 
     write(w, b".").unwrap();
 
     // Poll a readable pipe.  Should return an event.
-    let nfds = ppoll(&mut fds, Some(timeout), SigSet::empty()).unwrap();
+    let nfds = ppoll(&mut fds, Some(timeout), None).unwrap();
     assert_eq!(nfds, 1);
     assert!(fds[0].revents().unwrap().contains(PollFlags::POLLIN));
 }
diff --git a/test/test_pty.rs b/test/test_pty.rs
index 71932f2..5c27e2d 100644
--- a/test/test_pty.rs
+++ b/test/test_pty.rs
@@ -1,15 +1,15 @@
 use std::fs::File;
 use std::io::{Read, Write};
-use std::path::Path;
 use std::os::unix::prelude::*;
+use std::path::Path;
 use tempfile::tempfile;
 
 use libc::{_exit, STDOUT_FILENO};
-use nix::fcntl::{OFlag, open};
+use nix::fcntl::{open, OFlag};
 use nix::pty::*;
 use nix::sys::stat;
 use nix::sys::termios::*;
-use nix::unistd::{write, close, pause};
+use nix::unistd::{close, pause, write};
 
 /// Regression test for Issue #659
 /// This is the correct way to explicitly close a `PtyMaster`
@@ -36,7 +36,7 @@ fn test_ptsname_equivalence() {
     assert!(master_fd.as_raw_fd() > 0);
 
     // Get the name of the slave
-    let slave_name = unsafe { ptsname(&master_fd) }.unwrap() ;
+    let slave_name = unsafe { ptsname(&master_fd) }.unwrap();
     let slave_name_r = ptsname_r(&master_fd).unwrap();
     assert_eq!(slave_name, slave_name_r);
 }
@@ -58,7 +58,7 @@ fn test_ptsname_copy() {
     assert_eq!(slave_name1, slave_name2);
     // Also make sure that the string was actually copied and they point to different parts of
     // memory.
-    assert!(slave_name1.as_ptr() != slave_name2.as_ptr());
+    assert_ne!(slave_name1.as_ptr(), slave_name2.as_ptr());
 }
 
 /// Test data copying of `ptsname_r`
@@ -73,7 +73,7 @@ fn test_ptsname_r_copy() {
     let slave_name1 = ptsname_r(&master_fd).unwrap();
     let slave_name2 = ptsname_r(&master_fd).unwrap();
     assert_eq!(slave_name1, slave_name2);
-    assert!(slave_name1.as_ptr() != slave_name2.as_ptr());
+    assert_ne!(slave_name1.as_ptr(), slave_name2.as_ptr());
 }
 
 /// Test that `ptsname` returns different names for different devices
@@ -93,7 +93,7 @@ fn test_ptsname_unique() {
     // Get the name of the slave
     let slave_name1 = unsafe { ptsname(&master1_fd) }.unwrap();
     let slave_name2 = unsafe { ptsname(&master2_fd) }.unwrap();
-    assert!(slave_name1 != slave_name2);
+    assert_ne!(slave_name1, slave_name2);
 }
 
 /// Common setup for testing PTTY pairs
@@ -111,7 +111,9 @@ fn open_ptty_pair() -> (PtyMaster, File) {
     let slave_name = unsafe { ptsname(&master) }.expect("ptsname failed");
 
     // Open the slave device
-    let slave_fd = open(Path::new(&slave_name), OFlag::O_RDWR, stat::Mode::empty()).unwrap();
+    let slave_fd =
+        open(Path::new(&slave_name), OFlag::O_RDWR, stat::Mode::empty())
+            .unwrap();
 
     #[cfg(target_os = "illumos")]
     // TODO: rewrite using ioctl!
@@ -170,6 +172,11 @@ fn test_read_ptty_pair() {
     slave.write_all(b"hello").unwrap();
     master.read_exact(&mut buf).unwrap();
     assert_eq!(&buf, b"hello");
+
+    let mut master = &master;
+    slave.write_all(b"hello").unwrap();
+    master.read_exact(&mut buf).unwrap();
+    assert_eq!(&buf, b"hello");
 }
 
 /// Test `io::Write` on the PTTY master
@@ -182,6 +189,11 @@ fn test_write_ptty_pair() {
     master.write_all(b"adios").unwrap();
     slave.read_exact(&mut buf).unwrap();
     assert_eq!(&buf, b"adios");
+
+    let mut master = &master;
+    master.write_all(b"adios").unwrap();
+    slave.read_exact(&mut buf).unwrap();
+    assert_eq!(&buf, b"adios");
 }
 
 #[test]
@@ -269,9 +281,9 @@ fn test_openpty_with_termios() {
 
 #[test]
 fn test_forkpty() {
-    use nix::unistd::ForkResult::*;
     use nix::sys::signal::*;
     use nix::sys::wait::wait;
+    use nix::unistd::ForkResult::*;
     // forkpty calls openpty which uses ptname(3) internally.
     let _m0 = crate::PTSNAME_MTX.lock();
     // forkpty spawns a child process
@@ -279,15 +291,15 @@ fn test_forkpty() {
 
     let string = "naninani\n";
     let echoed_string = "naninani\r\n";
-    let pty = unsafe {
-        forkpty(None, None).unwrap()
-    };
+    let pty = unsafe { forkpty(None, None).unwrap() };
     match pty.fork_result {
         Child => {
             write(STDOUT_FILENO, string.as_bytes()).unwrap();
-            pause();  // we need the child to stay alive until the parent calls read
-            unsafe { _exit(0); }
-        },
+            pause(); // we need the child to stay alive until the parent calls read
+            unsafe {
+                _exit(0);
+            }
+        }
         Parent { child } => {
             let mut buf = [0u8; 10];
             assert!(child.as_raw() > 0);
@@ -296,6 +308,6 @@ fn test_forkpty() {
             wait().unwrap(); // keep other tests using generic wait from getting our child
             assert_eq!(&buf, echoed_string.as_bytes());
             close(pty.master).unwrap();
-        },
+        }
     }
 }
diff --git a/test/test_ptymaster_drop.rs b/test/test_ptymaster_drop.rs
index a68f81e..ffbaa56 100644
--- a/test/test_ptymaster_drop.rs
+++ b/test/test_ptymaster_drop.rs
@@ -15,6 +15,6 @@ mod t {
     fn test_double_close() {
         let m = posix_openpt(OFlag::O_RDWR).unwrap();
         close(m.as_raw_fd()).unwrap();
-        drop(m);            // should panic here
+        drop(m); // should panic here
     }
 }
diff --git a/test/test_resource.rs b/test/test_resource.rs
index 5969750..2ab581b 100644
--- a/test/test_resource.rs
+++ b/test/test_resource.rs
@@ -1,4 +1,9 @@
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia", target_os = "illumos")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "haiku"
+)))]
 use nix::sys::resource::{getrlimit, setrlimit, Resource};
 
 /// Tests the RLIMIT_NOFILE functionality of getrlimit(), where the resource RLIMIT_NOFILE refers
@@ -10,11 +15,17 @@ use nix::sys::resource::{getrlimit, setrlimit, Resource};
 /// to put the new soft limit in effect, and then getrlimit() once more to ensure the limits have
 /// been updated.
 #[test]
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia", target_os = "illumos")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "illumos",
+    target_os = "haiku"
+)))]
 pub fn test_resource_limits_nofile() {
-    let (soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+    let (mut soft_limit, hard_limit) =
+        getrlimit(Resource::RLIMIT_NOFILE).unwrap();
 
-    let soft_limit = Some(soft_limit.map_or(1024, |v| v - 1));
+    soft_limit -= 1;
     assert_ne!(soft_limit, hard_limit);
     setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
 
diff --git a/test/test_sched.rs b/test/test_sched.rs
index 922196a..c52616b 100644
--- a/test/test_sched.rs
+++ b/test/test_sched.rs
@@ -1,4 +1,4 @@
-use nix::sched::{sched_getaffinity, sched_setaffinity, CpuSet};
+use nix::sched::{sched_getaffinity, sched_getcpu, sched_setaffinity, CpuSet};
 use nix::unistd::Pid;
 
 #[test]
@@ -24,9 +24,16 @@ fn test_sched_affinity() {
     let updated_affinity = sched_getaffinity(Pid::from_raw(0)).unwrap();
     for field in 0..CpuSet::count() {
         // Should be set only for the CPU we set previously
-        assert_eq!(updated_affinity.is_set(field).unwrap(), field==last_valid_cpu)
+        assert_eq!(
+            updated_affinity.is_set(field).unwrap(),
+            field == last_valid_cpu
+        )
     }
 
+    // Now check that we're also currently running on the CPU in question.
+    let cur_cpu = sched_getcpu().unwrap();
+    assert_eq!(cur_cpu, last_valid_cpu);
+
     // Finally, reset the initial CPU set
     sched_setaffinity(Pid::from_raw(0), &initial_affinity).unwrap();
 }
diff --git a/test/test_sendfile.rs b/test/test_sendfile.rs
index b6559d3..f73a3b5 100644
--- a/test/test_sendfile.rs
+++ b/test/test_sendfile.rs
@@ -8,7 +8,7 @@ use tempfile::tempfile;
 cfg_if! {
     if #[cfg(any(target_os = "android", target_os = "linux"))] {
         use nix::unistd::{close, pipe, read};
-    } else if #[cfg(any(target_os = "freebsd", target_os = "ios", target_os = "macos"))] {
+    } else if #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "ios", target_os = "macos"))] {
         use std::net::Shutdown;
         use std::os::unix::net::UnixStream;
     }
@@ -62,7 +62,8 @@ fn test_sendfile64_linux() {
 #[test]
 fn test_sendfile_freebsd() {
     // Declare the content
-    let header_strings = vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
+    let header_strings =
+        vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
     let body = "Xabcdef123456";
     let body_offset = 1;
     let trailer_strings = vec!["\n", "Served by Make Believe\n"];
@@ -72,8 +73,10 @@ fn test_sendfile_freebsd() {
     tmp.write_all(body.as_bytes()).unwrap();
 
     // Prepare headers and trailers for sendfile
-    let headers: Vec<&[u8]> = header_strings.iter().map(|s| s.as_bytes()).collect();
-    let trailers: Vec<&[u8]> = trailer_strings.iter().map(|s| s.as_bytes()).collect();
+    let headers: Vec<&[u8]> =
+        header_strings.iter().map(|s| s.as_bytes()).collect();
+    let trailers: Vec<&[u8]> =
+        trailer_strings.iter().map(|s| s.as_bytes()).collect();
 
     // Prepare socket pair
     let (mut rd, wr) = UnixStream::pair().unwrap();
@@ -93,8 +96,58 @@ fn test_sendfile_freebsd() {
     wr.shutdown(Shutdown::Both).unwrap();
 
     // Prepare the expected result
-    let expected_string =
-        header_strings.concat() + &body[body_offset..] + &trailer_strings.concat();
+    let expected_string = header_strings.concat()
+        + &body[body_offset..]
+        + &trailer_strings.concat();
+
+    // Verify the message that was sent
+    assert_eq!(bytes_written as usize, expected_string.as_bytes().len());
+
+    let mut read_string = String::new();
+    let bytes_read = rd.read_to_string(&mut read_string).unwrap();
+    assert_eq!(bytes_written as usize, bytes_read);
+    assert_eq!(expected_string, read_string);
+}
+
+#[cfg(target_os = "dragonfly")]
+#[test]
+fn test_sendfile_dragonfly() {
+    // Declare the content
+    let header_strings =
+        vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
+    let body = "Xabcdef123456";
+    let body_offset = 1;
+    let trailer_strings = vec!["\n", "Served by Make Believe\n"];
+
+    // Write the body to a file
+    let mut tmp = tempfile().unwrap();
+    tmp.write_all(body.as_bytes()).unwrap();
+
+    // Prepare headers and trailers for sendfile
+    let headers: Vec<&[u8]> =
+        header_strings.iter().map(|s| s.as_bytes()).collect();
+    let trailers: Vec<&[u8]> =
+        trailer_strings.iter().map(|s| s.as_bytes()).collect();
+
+    // Prepare socket pair
+    let (mut rd, wr) = UnixStream::pair().unwrap();
+
+    // Call the test method
+    let (res, bytes_written) = sendfile(
+        tmp.as_raw_fd(),
+        wr.as_raw_fd(),
+        body_offset as off_t,
+        None,
+        Some(headers.as_slice()),
+        Some(trailers.as_slice()),
+    );
+    assert!(res.is_ok());
+    wr.shutdown(Shutdown::Both).unwrap();
+
+    // Prepare the expected result
+    let expected_string = header_strings.concat()
+        + &body[body_offset..]
+        + &trailer_strings.concat();
 
     // Verify the message that was sent
     assert_eq!(bytes_written as usize, expected_string.as_bytes().len());
@@ -109,7 +162,8 @@ fn test_sendfile_freebsd() {
 #[test]
 fn test_sendfile_darwin() {
     // Declare the content
-    let header_strings = vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
+    let header_strings =
+        vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
     let body = "Xabcdef123456";
     let body_offset = 1;
     let trailer_strings = vec!["\n", "Served by Make Believe\n"];
@@ -119,8 +173,10 @@ fn test_sendfile_darwin() {
     tmp.write_all(body.as_bytes()).unwrap();
 
     // Prepare headers and trailers for sendfile
-    let headers: Vec<&[u8]> = header_strings.iter().map(|s| s.as_bytes()).collect();
-    let trailers: Vec<&[u8]> = trailer_strings.iter().map(|s| s.as_bytes()).collect();
+    let headers: Vec<&[u8]> =
+        header_strings.iter().map(|s| s.as_bytes()).collect();
+    let trailers: Vec<&[u8]> =
+        trailer_strings.iter().map(|s| s.as_bytes()).collect();
 
     // Prepare socket pair
     let (mut rd, wr) = UnixStream::pair().unwrap();
@@ -138,8 +194,9 @@ fn test_sendfile_darwin() {
     wr.shutdown(Shutdown::Both).unwrap();
 
     // Prepare the expected result
-    let expected_string =
-        header_strings.concat() + &body[body_offset..] + &trailer_strings.concat();
+    let expected_string = header_strings.concat()
+        + &body[body_offset..]
+        + &trailer_strings.concat();
 
     // Verify the message that was sent
     assert_eq!(bytes_written as usize, expected_string.as_bytes().len());
diff --git a/test/test_stat.rs b/test/test_stat.rs
index 33cf748..55f15c0 100644
--- a/test/test_stat.rs
+++ b/test/test_stat.rs
@@ -1,42 +1,51 @@
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 use std::fs;
 use std::fs::File;
 #[cfg(not(target_os = "redox"))]
-use std::os::unix::fs::{symlink, PermissionsExt};
+use std::os::unix::fs::symlink;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use std::os::unix::fs::PermissionsExt;
 use std::os::unix::prelude::AsRawFd;
 #[cfg(not(target_os = "redox"))]
-use std::time::{Duration, UNIX_EPOCH};
-#[cfg(not(target_os = "redox"))]
 use std::path::Path;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use std::time::{Duration, UNIX_EPOCH};
 
-#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
-use libc::{S_IFMT, S_IFLNK};
 use libc::mode_t;
+#[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
+use libc::{S_IFLNK, S_IFMT};
 
 #[cfg(not(target_os = "redox"))]
-use nix::fcntl;
-#[cfg(not(target_os = "redox"))]
 use nix::errno::Errno;
 #[cfg(not(target_os = "redox"))]
-use nix::sys::stat::{self, futimens, utimes};
-use nix::sys::stat::{fchmod, stat};
-#[cfg(not(target_os = "redox"))]
-use nix::sys::stat::{fchmodat, utimensat, mkdirat};
-#[cfg(any(target_os = "linux",
-          target_os = "haiku",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "netbsd"))]
+use nix::fcntl;
+#[cfg(any(
+    target_os = "linux",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "freebsd",
+    target_os = "netbsd"
+))]
 use nix::sys::stat::lutimes;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::utimensat;
 #[cfg(not(target_os = "redox"))]
-use nix::sys::stat::{FchmodatFlags, UtimensatFlags};
+use nix::sys::stat::FchmodatFlags;
 use nix::sys::stat::Mode;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::UtimensatFlags;
+#[cfg(not(target_os = "redox"))]
+use nix::sys::stat::{self};
+use nix::sys::stat::{fchmod, stat};
+#[cfg(not(target_os = "redox"))]
+use nix::sys::stat::{fchmodat, mkdirat};
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::sys::stat::{futimens, utimes};
 
 #[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
 use nix::sys::stat::FileStat;
 
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 use nix::sys::time::{TimeSpec, TimeVal, TimeValLike};
 #[cfg(not(target_os = "redox"))]
 use nix::unistd::chdir;
@@ -47,32 +56,35 @@ use nix::Result;
 #[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
 fn assert_stat_results(stat_result: Result<FileStat>) {
     let stats = stat_result.expect("stat call failed");
-    assert!(stats.st_dev > 0);      // must be positive integer, exact number machine dependent
-    assert!(stats.st_ino > 0);      // inode is positive integer, exact number machine dependent
-    assert!(stats.st_mode > 0);     // must be positive integer
-    assert_eq!(stats.st_nlink, 1);   // there links created, must be 1
-    assert_eq!(stats.st_size, 0);    // size is 0 because we did not write anything to the file
-    assert!(stats.st_blksize > 0);  // must be positive integer, exact number machine dependent
-    assert!(stats.st_blocks <= 16);  // Up to 16 blocks can be allocated for a blank file
+    assert!(stats.st_dev > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_ino > 0); // inode is positive integer, exact number machine dependent
+    assert!(stats.st_mode > 0); // must be positive integer
+    assert_eq!(stats.st_nlink, 1); // there links created, must be 1
+    assert_eq!(stats.st_size, 0); // size is 0 because we did not write anything to the file
+    assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_blocks <= 16); // Up to 16 blocks can be allocated for a blank file
 }
 
 #[cfg(not(any(target_os = "netbsd", target_os = "redox")))]
 // (Android's st_blocks is ulonglong which is always non-negative.)
 #[cfg_attr(target_os = "android", allow(unused_comparisons))]
-#[allow(clippy::absurd_extreme_comparisons)]    // Not absurd on all OSes
+#[allow(clippy::absurd_extreme_comparisons)] // Not absurd on all OSes
 fn assert_lstat_results(stat_result: Result<FileStat>) {
     let stats = stat_result.expect("stat call failed");
-    assert!(stats.st_dev > 0);      // must be positive integer, exact number machine dependent
-    assert!(stats.st_ino > 0);      // inode is positive integer, exact number machine dependent
-    assert!(stats.st_mode > 0);     // must be positive integer
+    assert!(stats.st_dev > 0); // must be positive integer, exact number machine dependent
+    assert!(stats.st_ino > 0); // inode is positive integer, exact number machine dependent
+    assert!(stats.st_mode > 0); // must be positive integer
 
     // st_mode is c_uint (u32 on Android) while S_IFMT is mode_t
     // (u16 on Android), and that will be a compile error.
     // On other platforms they are the same (either both are u16 or u32).
-    assert_eq!((stats.st_mode as usize) & (S_IFMT as usize), S_IFLNK as usize); // should be a link
-    assert_eq!(stats.st_nlink, 1);   // there links created, must be 1
-    assert!(stats.st_size > 0);    // size is > 0 because it points to another file
-    assert!(stats.st_blksize > 0);  // must be positive integer, exact number machine dependent
+    assert_eq!(
+        (stats.st_mode as usize) & (S_IFMT as usize),
+        S_IFLNK as usize
+    ); // should be a link
+    assert_eq!(stats.st_nlink, 1); // there links created, must be 1
+    assert!(stats.st_size > 0); // size is > 0 because it points to another file
+    assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent
 
     // st_blocks depends on whether the machine's file system uses fast
     // or slow symlinks, so just make sure it's not negative
@@ -101,13 +113,11 @@ fn test_fstatat() {
     let tempdir = tempfile::tempdir().unwrap();
     let filename = tempdir.path().join("foo.txt");
     File::create(&filename).unwrap();
-    let dirfd = fcntl::open(tempdir.path(),
-                            fcntl::OFlag::empty(),
-                            stat::Mode::empty());
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty());
 
-    let result = stat::fstatat(dirfd.unwrap(),
-                               &filename,
-                               fcntl::AtFlags::empty());
+    let result =
+        stat::fstatat(dirfd.unwrap(), &filename, fcntl::AtFlags::empty());
     assert_stat_results(result);
 }
 
@@ -167,12 +177,15 @@ fn test_fchmodat() {
     let fullpath = tempdir.path().join(filename);
     File::create(&fullpath).unwrap();
 
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     let mut mode1 = Mode::empty();
     mode1.insert(Mode::S_IRUSR);
     mode1.insert(Mode::S_IWUSR);
-    fchmodat(Some(dirfd), filename, mode1, FchmodatFlags::FollowSymlink).unwrap();
+    fchmodat(Some(dirfd), filename, mode1, FchmodatFlags::FollowSymlink)
+        .unwrap();
 
     let file_stat1 = stat(&fullpath).unwrap();
     assert_eq!(file_stat1.st_mode as mode_t & 0o7777, mode1.bits());
@@ -191,34 +204,42 @@ fn test_fchmodat() {
 ///
 /// The atime and mtime are expressed with a resolution of seconds because some file systems
 /// (like macOS's HFS+) do not have higher granularity.
-#[cfg(not(target_os = "redox"))]
-fn assert_times_eq(exp_atime_sec: u64, exp_mtime_sec: u64, attr: &fs::Metadata) {
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+fn assert_times_eq(
+    exp_atime_sec: u64,
+    exp_mtime_sec: u64,
+    attr: &fs::Metadata,
+) {
     assert_eq!(
         Duration::new(exp_atime_sec, 0),
-        attr.accessed().unwrap().duration_since(UNIX_EPOCH).unwrap());
+        attr.accessed().unwrap().duration_since(UNIX_EPOCH).unwrap()
+    );
     assert_eq!(
         Duration::new(exp_mtime_sec, 0),
-        attr.modified().unwrap().duration_since(UNIX_EPOCH).unwrap());
+        attr.modified().unwrap().duration_since(UNIX_EPOCH).unwrap()
+    );
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_utimes() {
     let tempdir = tempfile::tempdir().unwrap();
     let fullpath = tempdir.path().join("file");
     drop(File::create(&fullpath).unwrap());
 
-    utimes(&fullpath, &TimeVal::seconds(9990), &TimeVal::seconds(5550)).unwrap();
+    utimes(&fullpath, &TimeVal::seconds(9990), &TimeVal::seconds(5550))
+        .unwrap();
     assert_times_eq(9990, 5550, &fs::metadata(&fullpath).unwrap());
 }
 
 #[test]
-#[cfg(any(target_os = "linux",
-          target_os = "haiku",
-          target_os = "ios",
-          target_os = "macos",
-          target_os = "freebsd",
-          target_os = "netbsd"))]
+#[cfg(any(
+    target_os = "linux",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "freebsd",
+    target_os = "netbsd"
+))]
 fn test_lutimes() {
     let tempdir = tempfile::tempdir().unwrap();
     let target = tempdir.path().join("target");
@@ -227,31 +248,39 @@ fn test_lutimes() {
     symlink(&target, &fullpath).unwrap();
 
     let exp_target_metadata = fs::symlink_metadata(&target).unwrap();
-    lutimes(&fullpath, &TimeVal::seconds(4560), &TimeVal::seconds(1230)).unwrap();
+    lutimes(&fullpath, &TimeVal::seconds(4560), &TimeVal::seconds(1230))
+        .unwrap();
     assert_times_eq(4560, 1230, &fs::symlink_metadata(&fullpath).unwrap());
 
     let target_metadata = fs::symlink_metadata(&target).unwrap();
-    assert_eq!(exp_target_metadata.accessed().unwrap(), target_metadata.accessed().unwrap(),
-               "atime of symlink target was unexpectedly modified");
-    assert_eq!(exp_target_metadata.modified().unwrap(), target_metadata.modified().unwrap(),
-               "mtime of symlink target was unexpectedly modified");
+    assert_eq!(
+        exp_target_metadata.accessed().unwrap(),
+        target_metadata.accessed().unwrap(),
+        "atime of symlink target was unexpectedly modified"
+    );
+    assert_eq!(
+        exp_target_metadata.modified().unwrap(),
+        target_metadata.modified().unwrap(),
+        "mtime of symlink target was unexpectedly modified"
+    );
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_futimens() {
     let tempdir = tempfile::tempdir().unwrap();
     let fullpath = tempdir.path().join("file");
     drop(File::create(&fullpath).unwrap());
 
-    let fd = fcntl::open(&fullpath, fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let fd = fcntl::open(&fullpath, fcntl::OFlag::empty(), stat::Mode::empty())
+        .unwrap();
 
     futimens(fd, &TimeSpec::seconds(10), &TimeSpec::seconds(20)).unwrap();
     assert_times_eq(10, 20, &fs::metadata(&fullpath).unwrap());
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_utimensat() {
     let _dr = crate::DirRestore::new();
     let tempdir = tempfile::tempdir().unwrap();
@@ -259,16 +288,30 @@ fn test_utimensat() {
     let fullpath = tempdir.path().join(filename);
     drop(File::create(&fullpath).unwrap());
 
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
-    utimensat(Some(dirfd), filename, &TimeSpec::seconds(12345), &TimeSpec::seconds(678),
-              UtimensatFlags::FollowSymlink).unwrap();
+    utimensat(
+        Some(dirfd),
+        filename,
+        &TimeSpec::seconds(12345),
+        &TimeSpec::seconds(678),
+        UtimensatFlags::FollowSymlink,
+    )
+    .unwrap();
     assert_times_eq(12345, 678, &fs::metadata(&fullpath).unwrap());
 
     chdir(tempdir.path()).unwrap();
 
-    utimensat(None, filename, &TimeSpec::seconds(500), &TimeSpec::seconds(800),
-              UtimensatFlags::FollowSymlink).unwrap();
+    utimensat(
+        None,
+        filename,
+        &TimeSpec::seconds(500),
+        &TimeSpec::seconds(800),
+        UtimensatFlags::FollowSymlink,
+    )
+    .unwrap();
     assert_times_eq(500, 800, &fs::metadata(&fullpath).unwrap());
 }
 
@@ -277,20 +320,27 @@ fn test_utimensat() {
 fn test_mkdirat_success_path() {
     let tempdir = tempfile::tempdir().unwrap();
     let filename = "example_subdir";
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
-    assert!((mkdirat(dirfd, filename, Mode::S_IRWXU)).is_ok());
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+    mkdirat(dirfd, filename, Mode::S_IRWXU).expect("mkdirat failed");
     assert!(Path::exists(&tempdir.path().join(filename)));
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_mkdirat_success_mode() {
-    let expected_bits = stat::SFlag::S_IFDIR.bits() | stat::Mode::S_IRWXU.bits();
+    let expected_bits =
+        stat::SFlag::S_IFDIR.bits() | stat::Mode::S_IRWXU.bits();
     let tempdir = tempfile::tempdir().unwrap();
     let filename = "example_subdir";
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
-    assert!((mkdirat(dirfd, filename, Mode::S_IRWXU)).is_ok());
-    let permissions = fs::metadata(tempdir.path().join(filename)).unwrap().permissions();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
+    mkdirat(dirfd, filename, Mode::S_IRWXU).expect("mkdirat failed");
+    let permissions = fs::metadata(tempdir.path().join(filename))
+        .unwrap()
+        .permissions();
     let mode = permissions.mode();
     assert_eq!(mode as mode_t, expected_bits)
 }
@@ -299,19 +349,27 @@ fn test_mkdirat_success_mode() {
 #[cfg(not(target_os = "redox"))]
 fn test_mkdirat_fail() {
     let tempdir = tempfile::tempdir().unwrap();
-    let not_dir_filename= "example_not_dir";
+    let not_dir_filename = "example_not_dir";
     let filename = "example_subdir_dir";
-    let dirfd = fcntl::open(&tempdir.path().join(not_dir_filename), fcntl::OFlag::O_CREAT,
-                            stat::Mode::empty()).unwrap();
+    let dirfd = fcntl::open(
+        &tempdir.path().join(not_dir_filename),
+        fcntl::OFlag::O_CREAT,
+        stat::Mode::empty(),
+    )
+    .unwrap();
     let result = mkdirat(dirfd, filename, Mode::S_IRWXU).unwrap_err();
     assert_eq!(result, Errno::ENOTDIR);
 }
 
 #[test]
-#[cfg(not(any(target_os = "freebsd",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "redox")))]
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "haiku",
+    target_os = "redox"
+)))]
 fn test_mknod() {
     use stat::{lstat, mknod, SFlag};
 
@@ -320,16 +378,20 @@ fn test_mknod() {
     let target = tempdir.path().join(file_name);
     mknod(&target, SFlag::S_IFREG, Mode::S_IRWXU, 0).unwrap();
     let mode = lstat(&target).unwrap().st_mode as mode_t;
-    assert!(mode & libc::S_IFREG == libc::S_IFREG);
-    assert!(mode & libc::S_IRWXU == libc::S_IRWXU);
+    assert_eq!(mode & libc::S_IFREG, libc::S_IFREG);
+    assert_eq!(mode & libc::S_IRWXU, libc::S_IRWXU);
 }
 
 #[test]
-#[cfg(not(any(target_os = "freebsd",
-              target_os = "illumos",
-              target_os = "ios",
-              target_os = "macos",
-              target_os = "redox")))]
+#[cfg(not(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "illumos",
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "haiku",
+    target_os = "redox"
+)))]
 fn test_mknodat() {
     use fcntl::{AtFlags, OFlag};
     use nix::dir::Dir;
@@ -337,7 +399,8 @@ fn test_mknodat() {
 
     let file_name = "test_file";
     let tempdir = tempfile::tempdir().unwrap();
-    let target_dir = Dir::open(tempdir.path(), OFlag::O_DIRECTORY, Mode::S_IRWXU).unwrap();
+    let target_dir =
+        Dir::open(tempdir.path(), OFlag::O_DIRECTORY, Mode::S_IRWXU).unwrap();
     mknodat(
         target_dir.as_raw_fd(),
         file_name,
@@ -353,6 +416,6 @@ fn test_mknodat() {
     )
     .unwrap()
     .st_mode as mode_t;
-    assert!(mode & libc::S_IFREG == libc::S_IFREG);
-    assert!(mode & libc::S_IRWXU == libc::S_IRWXU);
+    assert_eq!(mode & libc::S_IFREG, libc::S_IFREG);
+    assert_eq!(mode & libc::S_IRWXU, libc::S_IRWXU);
 }
diff --git a/test/test_time.rs b/test/test_time.rs
index dc307e5..5f76e61 100644
--- a/test/test_time.rs
+++ b/test/test_time.rs
@@ -11,12 +11,12 @@ use nix::time::{clock_gettime, ClockId};
 #[cfg(not(target_os = "redox"))]
 #[test]
 pub fn test_clock_getres() {
-    assert!(nix::time::clock_getres(ClockId::CLOCK_REALTIME).is_ok());
+    nix::time::clock_getres(ClockId::CLOCK_REALTIME).expect("assertion failed");
 }
 
 #[test]
 pub fn test_clock_gettime() {
-    assert!(clock_gettime(ClockId::CLOCK_REALTIME).is_ok());
+    clock_gettime(ClockId::CLOCK_REALTIME).expect("assertion failed");
 }
 
 #[cfg(any(
@@ -29,18 +29,18 @@ pub fn test_clock_gettime() {
 #[test]
 pub fn test_clock_getcpuclockid() {
     let clock_id = clock_getcpuclockid(nix::unistd::Pid::this()).unwrap();
-    assert!(clock_gettime(clock_id).is_ok());
+    clock_gettime(clock_id).unwrap();
 }
 
 #[cfg(not(target_os = "redox"))]
 #[test]
 pub fn test_clock_id_res() {
-    assert!(ClockId::CLOCK_REALTIME.res().is_ok());
+    ClockId::CLOCK_REALTIME.res().unwrap();
 }
 
 #[test]
 pub fn test_clock_id_now() {
-    assert!(ClockId::CLOCK_REALTIME.now().is_ok());
+    ClockId::CLOCK_REALTIME.now().unwrap();
 }
 
 #[cfg(any(
@@ -52,7 +52,8 @@ pub fn test_clock_id_now() {
 ))]
 #[test]
 pub fn test_clock_id_pid_cpu_clock_id() {
-    assert!(ClockId::pid_cpu_clock_id(nix::unistd::Pid::this())
+    ClockId::pid_cpu_clock_id(nix::unistd::Pid::this())
         .map(ClockId::now)
-        .is_ok());
+        .unwrap()
+        .unwrap();
 }
diff --git a/test/test_timer.rs b/test/test_timer.rs
new file mode 100644
index 0000000..ffd1468
--- /dev/null
+++ b/test/test_timer.rs
@@ -0,0 +1,102 @@
+use nix::sys::signal::{
+    sigaction, SaFlags, SigAction, SigEvent, SigHandler, SigSet, SigevNotify,
+    Signal,
+};
+use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
+use nix::time::ClockId;
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::thread;
+use std::time::{Duration, Instant};
+
+const SIG: Signal = Signal::SIGALRM;
+static ALARM_CALLED: AtomicBool = AtomicBool::new(false);
+
+pub extern "C" fn handle_sigalarm(raw_signal: libc::c_int) {
+    let signal = Signal::try_from(raw_signal).unwrap();
+    if signal == SIG {
+        ALARM_CALLED.store(true, Ordering::Release);
+    }
+}
+
+#[test]
+fn alarm_fires() {
+    // Avoid interfering with other signal using tests by taking a mutex shared
+    // among other tests in this crate.
+    let _m = crate::SIGNAL_MTX.lock();
+    const TIMER_PERIOD: Duration = Duration::from_millis(100);
+
+    //
+    // Setup
+    //
+
+    // Create a handler for the test signal, `SIG`. The handler is responsible
+    // for flipping `ALARM_CALLED`.
+    let handler = SigHandler::Handler(handle_sigalarm);
+    let signal_action =
+        SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
+    let old_handler = unsafe {
+        sigaction(SIG, &signal_action)
+            .expect("unable to set signal handler for alarm")
+    };
+
+    // Create the timer. We use the monotonic clock here, though any would do
+    // really. The timer is set to fire every 250 milliseconds with no delay for
+    // the initial firing.
+    let clockid = ClockId::CLOCK_MONOTONIC;
+    let sigevent = SigEvent::new(SigevNotify::SigevSignal {
+        signal: SIG,
+        si_value: 0,
+    });
+    let mut timer =
+        Timer::new(clockid, sigevent).expect("failed to create timer");
+    let expiration = Expiration::Interval(TIMER_PERIOD.into());
+    let flags = TimerSetTimeFlags::empty();
+    timer.set(expiration, flags).expect("could not set timer");
+
+    //
+    // Test
+    //
+
+    // Determine that there's still an expiration tracked by the
+    // timer. Depending on when this runs either an `Expiration::Interval` or
+    // `Expiration::IntervalDelayed` will be present. That is, if the timer has
+    // not fired yet we'll get our original `expiration`, else the one that
+    // represents a delay to the next expiration. We're only interested in the
+    // timer still being extant.
+    match timer.get() {
+        Ok(Some(exp)) => assert!(matches!(
+            exp,
+            Expiration::Interval(..) | Expiration::IntervalDelayed(..)
+        )),
+        _ => panic!("timer lost its expiration"),
+    }
+
+    // Wait for 2 firings of the alarm before checking that it has fired and
+    // been handled at least the once. If we wait for 3 seconds and the handler
+    // is never called something has gone sideways and the test fails.
+    let starttime = Instant::now();
+    loop {
+        thread::sleep(2 * TIMER_PERIOD);
+        if ALARM_CALLED.load(Ordering::Acquire) {
+            break;
+        }
+        if starttime.elapsed() > Duration::from_secs(3) {
+            panic!("Timeout waiting for SIGALRM");
+        }
+    }
+
+    // Cleanup:
+    // 1) deregister the OS's timer.
+    // 2) Wait for a full timer period, since POSIX does not require that
+    //    disabling the timer will clear pending signals, and on NetBSD at least
+    //    it does not.
+    // 2) Replace the old signal handler now that we've completed the test. If
+    //    the test fails this process panics, so the fact we might not get here
+    //    is okay.
+    drop(timer);
+    thread::sleep(TIMER_PERIOD);
+    unsafe {
+        sigaction(SIG, &old_handler).expect("unable to reset signal handler");
+    }
+}
diff --git a/test/test_unistd.rs b/test/test_unistd.rs
index 61062ad..9e20f97 100644
--- a/test/test_unistd.rs
+++ b/test/test_unistd.rs
@@ -1,15 +1,24 @@
-#[cfg(not(target_os = "redox"))]
-use nix::fcntl::{self, open, readlink};
+use libc::{_exit, mode_t, off_t};
+use nix::errno::Errno;
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
+use nix::fcntl::readlink;
 use nix::fcntl::OFlag;
-use nix::unistd::*;
-use nix::unistd::ForkResult::*;
 #[cfg(not(target_os = "redox"))]
-use nix::sys::signal::{SaFlags, SigAction, SigHandler, SigSet, Signal, sigaction};
-use nix::sys::wait::*;
+use nix::fcntl::{self, open};
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
+use nix::pty::{grantpt, posix_openpt, ptsname, unlockpt};
+#[cfg(not(target_os = "redox"))]
+use nix::sys::signal::{
+    sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal,
+};
 use nix::sys::stat::{self, Mode, SFlag};
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-use nix::pty::{posix_openpt, grantpt, unlockpt, ptsname};
-use nix::errno::Errno;
+use nix::sys::wait::*;
+use nix::unistd::ForkResult::*;
+use nix::unistd::*;
 use std::env;
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox")))]
 use std::ffi::CString;
@@ -18,10 +27,13 @@ use std::fs::DirBuilder;
 use std::fs::{self, File};
 use std::io::Write;
 use std::os::unix::prelude::*;
-#[cfg(not(any(target_os = "fuchsia", target_os = "redox")))]
+#[cfg(not(any(
+    target_os = "fuchsia",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 use std::path::Path;
 use tempfile::{tempdir, tempfile};
-use libc::{_exit, mode_t, off_t};
 
 use crate::*;
 
@@ -31,7 +43,7 @@ fn test_fork_and_waitpid() {
     let _m = crate::FORK_MTX.lock();
 
     // Safe: Child only calls `_exit`, which is signal-safe
-    match unsafe{fork()}.expect("Error: Fork Failed") {
+    match unsafe { fork() }.expect("Error: Fork Failed") {
         Child => unsafe { _exit(0) },
         Parent { child } => {
             // assert that child was created and pid > 0
@@ -40,16 +52,17 @@ fn test_fork_and_waitpid() {
             let wait_status = waitpid(child, None);
             match wait_status {
                 // assert that waitpid returned correct status and the pid is the one of the child
-                Ok(WaitStatus::Exited(pid_t, _)) =>  assert_eq!(pid_t, child),
+                Ok(WaitStatus::Exited(pid_t, _)) => assert_eq!(pid_t, child),
 
                 // panic, must never happen
-                s @ Ok(_) => panic!("Child exited {:?}, should never happen", s),
+                s @ Ok(_) => {
+                    panic!("Child exited {:?}, should never happen", s)
+                }
 
                 // panic, waitpid should never fail
-                Err(s) => panic!("Error: waitpid returned Err({:?}", s)
+                Err(s) => panic!("Error: waitpid returned Err({:?}", s),
             }
-
-        },
+        }
     }
 }
 
@@ -59,14 +72,14 @@ fn test_wait() {
     let _m = crate::FORK_MTX.lock();
 
     // Safe: Child only calls `_exit`, which is signal-safe
-    match unsafe{fork()}.expect("Error: Fork Failed") {
+    match unsafe { fork() }.expect("Error: Fork Failed") {
         Child => unsafe { _exit(0) },
         Parent { child } => {
             let wait_status = wait();
 
             // just assert that (any) one child returns with WaitStatus::Exited
             assert_eq!(wait_status, Ok(WaitStatus::Exited(child, 0)));
-        },
+        }
     }
 }
 
@@ -80,15 +93,15 @@ fn test_mkstemp() {
         Ok((fd, path)) => {
             close(fd).unwrap();
             unlink(path.as_path()).unwrap();
-        },
-        Err(e) => panic!("mkstemp failed: {}", e)
+        }
+        Err(e) => panic!("mkstemp failed: {}", e),
     }
 }
 
 #[test]
 fn test_mkstemp_directory() {
     // mkstemp should fail if a directory is given
-    assert!(mkstemp(&env::temp_dir()).is_err());
+    mkstemp(&env::temp_dir()).expect_err("assertion failed");
 }
 
 #[test]
@@ -101,20 +114,24 @@ fn test_mkfifo() {
 
     let stats = stat::stat(&mkfifo_fifo).unwrap();
     let typ = stat::SFlag::from_bits_truncate(stats.st_mode as mode_t);
-    assert!(typ == SFlag::S_IFIFO);
+    assert_eq!(typ, SFlag::S_IFIFO);
 }
 
 #[test]
 #[cfg(not(target_os = "redox"))]
 fn test_mkfifo_directory() {
     // mkfifo should fail if a directory is given
-    assert!(mkfifo(&env::temp_dir(), Mode::S_IRUSR).is_err());
+    mkfifo(&env::temp_dir(), Mode::S_IRUSR).expect_err("assertion failed");
 }
 
 #[test]
 #[cfg(not(any(
-    target_os = "macos", target_os = "ios",
-    target_os = "android", target_os = "redox")))]
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 fn test_mkfifoat_none() {
     let _m = crate::CWD_LOCK.read();
 
@@ -130,8 +147,12 @@ fn test_mkfifoat_none() {
 
 #[test]
 #[cfg(not(any(
-    target_os = "macos", target_os = "ios",
-    target_os = "android", target_os = "redox")))]
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 fn test_mkfifoat() {
     use nix::fcntl;
 
@@ -141,26 +162,36 @@ fn test_mkfifoat() {
 
     mkfifoat(Some(dirfd), mkfifoat_name, Mode::S_IRUSR).unwrap();
 
-    let stats = stat::fstatat(dirfd, mkfifoat_name, fcntl::AtFlags::empty()).unwrap();
+    let stats =
+        stat::fstatat(dirfd, mkfifoat_name, fcntl::AtFlags::empty()).unwrap();
     let typ = stat::SFlag::from_bits_truncate(stats.st_mode);
     assert_eq!(typ, SFlag::S_IFIFO);
 }
 
 #[test]
 #[cfg(not(any(
-    target_os = "macos", target_os = "ios",
-    target_os = "android", target_os = "redox")))]
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 fn test_mkfifoat_directory_none() {
     let _m = crate::CWD_LOCK.read();
 
     // mkfifoat should fail if a directory is given
-    assert!(mkfifoat(None, &env::temp_dir(), Mode::S_IRUSR).is_err());
+    mkfifoat(None, &env::temp_dir(), Mode::S_IRUSR)
+        .expect_err("assertion failed");
 }
 
 #[test]
 #[cfg(not(any(
-    target_os = "macos", target_os = "ios",
-    target_os = "android", target_os = "redox")))]
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 fn test_mkfifoat_directory() {
     // mkfifoat should fail if a directory is given
     let tempdir = tempdir().unwrap();
@@ -168,7 +199,8 @@ fn test_mkfifoat_directory() {
     let mkfifoat_dir = "mkfifoat_dir";
     stat::mkdirat(dirfd, mkfifoat_dir, Mode::S_IRUSR).unwrap();
 
-    assert!(mkfifoat(Some(dirfd), mkfifoat_dir, Mode::S_IRUSR).is_err());
+    mkfifoat(Some(dirfd), mkfifoat_dir, Mode::S_IRUSR)
+        .expect_err("assertion failed");
 }
 
 #[test]
@@ -201,7 +233,13 @@ mod linux_android {
 
 #[test]
 // `getgroups()` and `setgroups()` do not behave as expected on Apple platforms
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 fn test_setgroups() {
     // Skip this test when not run as root as `setgroups()` requires root.
     skip_if_not_root!("test_setgroups");
@@ -224,11 +262,14 @@ fn test_setgroups() {
 
 #[test]
 // `getgroups()` and `setgroups()` do not behave as expected on Apple platforms
-#[cfg(not(any(target_os = "ios",
-              target_os = "macos",
-              target_os = "redox",
-              target_os = "fuchsia",
-              target_os = "illumos")))]
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku",
+    target_os = "illumos"
+)))]
 fn test_initgroups() {
     // Skip this test when not run as root as `initgroups()` and `setgroups()`
     // require root.
@@ -259,7 +300,7 @@ fn test_initgroups() {
 }
 
 #[cfg(not(any(target_os = "fuchsia", target_os = "redox")))]
-macro_rules! execve_test_factory(
+macro_rules! execve_test_factory (
     ($test_name:ident, $syscall:ident, $exe: expr $(, $pathname:expr, $flags:expr)*) => (
 
     #[cfg(test)]
@@ -359,36 +400,32 @@ macro_rules! execve_test_factory(
     )
 );
 
-cfg_if!{
+cfg_if! {
     if #[cfg(target_os = "android")] {
         execve_test_factory!(test_execve, execve, CString::new("/system/bin/sh").unwrap().as_c_str());
         execve_test_factory!(test_fexecve, fexecve, File::open("/system/bin/sh").unwrap().into_raw_fd());
-    } else if #[cfg(any(target_os = "freebsd",
+    } else if #[cfg(any(target_os = "dragonfly",
+                        target_os = "freebsd",
                         target_os = "linux"))] {
         // These tests frequently fail on musl, probably due to
         // https://github.com/nix-rust/nix/issues/555
         execve_test_factory!(test_execve, execve, CString::new("/bin/sh").unwrap().as_c_str());
         execve_test_factory!(test_fexecve, fexecve, File::open("/bin/sh").unwrap().into_raw_fd());
-    } else if #[cfg(any(target_os = "dragonfly",
-                        target_os = "illumos",
+    } else if #[cfg(any(target_os = "illumos",
                         target_os = "ios",
                         target_os = "macos",
                         target_os = "netbsd",
                         target_os = "openbsd",
                         target_os = "solaris"))] {
         execve_test_factory!(test_execve, execve, CString::new("/bin/sh").unwrap().as_c_str());
-        // No fexecve() on DragonFly, ios, macos, NetBSD, OpenBSD.
-        //
-        // Note for NetBSD and OpenBSD: although rust-lang/libc includes it
-        // (under unix/bsd/netbsdlike/) fexecve is not currently implemented on
-        // NetBSD nor on OpenBSD.
+        // No fexecve() on ios, macos, NetBSD, OpenBSD.
     }
 }
 
 #[cfg(any(target_os = "haiku", target_os = "linux", target_os = "openbsd"))]
 execve_test_factory!(test_execvpe, execvpe, &CString::new("sh").unwrap());
 
-cfg_if!{
+cfg_if! {
     if #[cfg(target_os = "android")] {
         use nix::fcntl::AtFlags;
         execve_test_factory!(test_execveat_empty, execveat,
@@ -421,10 +458,10 @@ fn test_fchdir() {
     let tmpdir_path = tmpdir.path().canonicalize().unwrap();
     let tmpdir_fd = File::open(&tmpdir_path).unwrap().into_raw_fd();
 
-    assert!(fchdir(tmpdir_fd).is_ok());
+    fchdir(tmpdir_fd).expect("assertion failed");
     assert_eq!(getcwd().unwrap(), tmpdir_path);
 
-    assert!(close(tmpdir_fd).is_ok());
+    close(tmpdir_fd).expect("assertion failed");
 }
 
 #[test]
@@ -434,7 +471,7 @@ fn test_getcwd() {
 
     let tmpdir = tempdir().unwrap();
     let tmpdir_path = tmpdir.path().canonicalize().unwrap();
-    assert!(chdir(&tmpdir_path).is_ok());
+    chdir(&tmpdir_path).expect("assertion failed");
     assert_eq!(getcwd().unwrap(), tmpdir_path);
 
     // make path 500 chars longer so that buffer doubling in getcwd
@@ -445,9 +482,10 @@ fn test_getcwd() {
     for _ in 0..5 {
         let newdir = "a".repeat(100);
         inner_tmp_dir.push(newdir);
-        assert!(mkdir(inner_tmp_dir.as_path(), Mode::S_IRWXU).is_ok());
+        mkdir(inner_tmp_dir.as_path(), Mode::S_IRWXU)
+            .expect("assertion failed");
     }
-    assert!(chdir(inner_tmp_dir.as_path()).is_ok());
+    chdir(inner_tmp_dir.as_path()).expect("assertion failed");
     assert_eq!(getcwd().unwrap(), inner_tmp_dir.as_path());
 }
 
@@ -502,7 +540,8 @@ fn test_fchownat() {
 
     let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
 
-    fchownat(Some(dirfd), "file", uid, gid, FchownatFlags::FollowSymlink).unwrap();
+    fchownat(Some(dirfd), "file", uid, gid, FchownatFlags::FollowSymlink)
+        .unwrap();
 
     chdir(tempdir.path()).unwrap();
     fchownat(None, "file", uid, gid, FchownatFlags::FollowSymlink).unwrap();
@@ -545,7 +584,7 @@ fn test_lseek64() {
     close(tmpfd).unwrap();
 }
 
-cfg_if!{
+cfg_if! {
     if #[cfg(any(target_os = "android", target_os = "linux"))] {
         macro_rules! require_acct{
             () => {
@@ -559,7 +598,7 @@ cfg_if!{
                 skip_if_jailed!("test_acct");
             }
         }
-    } else if #[cfg(not(any(target_os = "redox", target_os = "fuchsia")))] {
+    } else if #[cfg(not(any(target_os = "redox", target_os = "fuchsia", target_os = "haiku")))] {
         macro_rules! require_acct{
             () => {
                 skip_if_not_root!("test_acct");
@@ -569,11 +608,15 @@ cfg_if!{
 }
 
 #[test]
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 fn test_acct() {
-    use tempfile::NamedTempFile;
     use std::process::Command;
     use std::{thread, time};
+    use tempfile::NamedTempFile;
 
     let _m = crate::FORK_MTX.lock();
     require_acct!();
@@ -584,9 +627,11 @@ fn test_acct() {
     acct::enable(path).unwrap();
 
     loop {
-        Command::new("echo").arg("Hello world");
+        Command::new("echo").arg("Hello world").output().unwrap();
         let len = fs::metadata(path).unwrap().len();
-        if len > 0 { break; }
+        if len > 0 {
+            break;
+        }
         thread::sleep(time::Duration::from_millis(10));
     }
     acct::disable().unwrap();
@@ -597,21 +642,36 @@ fn test_fpathconf_limited() {
     let f = tempfile().unwrap();
     // AFAIK, PATH_MAX is limited on all platforms, so it makes a good test
     let path_max = fpathconf(f.as_raw_fd(), PathconfVar::PATH_MAX);
-    assert!(path_max.expect("fpathconf failed").expect("PATH_MAX is unlimited") > 0);
+    assert!(
+        path_max
+            .expect("fpathconf failed")
+            .expect("PATH_MAX is unlimited")
+            > 0
+    );
 }
 
 #[test]
 fn test_pathconf_limited() {
     // AFAIK, PATH_MAX is limited on all platforms, so it makes a good test
     let path_max = pathconf("/", PathconfVar::PATH_MAX);
-    assert!(path_max.expect("pathconf failed").expect("PATH_MAX is unlimited") > 0);
+    assert!(
+        path_max
+            .expect("pathconf failed")
+            .expect("PATH_MAX is unlimited")
+            > 0
+    );
 }
 
 #[test]
 fn test_sysconf_limited() {
     // AFAIK, OPEN_MAX is limited on all platforms, so it makes a good test
     let open_max = sysconf(SysconfVar::OPEN_MAX);
-    assert!(open_max.expect("sysconf failed").expect("OPEN_MAX is unlimited") > 0);
+    assert!(
+        open_max
+            .expect("sysconf failed")
+            .expect("OPEN_MAX is unlimited")
+            > 0
+    );
 }
 
 #[cfg(target_os = "freebsd")]
@@ -624,23 +684,34 @@ fn test_sysconf_unsupported() {
     assert!(open_max.expect("sysconf failed").is_none())
 }
 
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 #[test]
 fn test_getresuid() {
     let resuids = getresuid().unwrap();
-    assert!(resuids.real.as_raw() != libc::uid_t::max_value());
-    assert!(resuids.effective.as_raw() != libc::uid_t::max_value());
-    assert!(resuids.saved.as_raw() != libc::uid_t::max_value());
+    assert_ne!(resuids.real.as_raw(), libc::uid_t::MAX);
+    assert_ne!(resuids.effective.as_raw(), libc::uid_t::MAX);
+    assert_ne!(resuids.saved.as_raw(), libc::uid_t::MAX);
 }
 
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "openbsd"
+))]
 #[test]
 fn test_getresgid() {
     let resgids = getresgid().unwrap();
-    assert!(resgids.real.as_raw() != libc::gid_t::max_value());
-    assert!(resgids.effective.as_raw() != libc::gid_t::max_value());
-    assert!(resgids.saved.as_raw() != libc::gid_t::max_value());
+    assert_ne!(resgids.real.as_raw(), libc::gid_t::MAX);
+    assert_ne!(resgids.effective.as_raw(), libc::gid_t::MAX);
+    assert_ne!(resgids.saved.as_raw(), libc::gid_t::MAX);
 }
 
 // Test that we can create a pair of pipes.  No need to verify that they pass
@@ -648,25 +719,31 @@ fn test_getresgid() {
 #[test]
 fn test_pipe() {
     let (fd0, fd1) = pipe().unwrap();
-    let m0 = stat::SFlag::from_bits_truncate(stat::fstat(fd0).unwrap().st_mode as mode_t);
+    let m0 = stat::SFlag::from_bits_truncate(
+        stat::fstat(fd0).unwrap().st_mode as mode_t,
+    );
     // S_IFIFO means it's a pipe
     assert_eq!(m0, SFlag::S_IFIFO);
-    let m1 = stat::SFlag::from_bits_truncate(stat::fstat(fd1).unwrap().st_mode as mode_t);
+    let m1 = stat::SFlag::from_bits_truncate(
+        stat::fstat(fd1).unwrap().st_mode as mode_t,
+    );
     assert_eq!(m1, SFlag::S_IFIFO);
 }
 
 // pipe2(2) is the same as pipe(2), except it allows setting some flags.  Check
 // that we can set a flag.
-#[cfg(any(target_os = "android",
-          target_os = "dragonfly",
-          target_os = "emscripten",
-          target_os = "freebsd",
-          target_os = "illumos",
-          target_os = "linux",
-          target_os = "netbsd",
-          target_os = "openbsd",
-          target_os = "redox",
-          target_os = "solaris"))]
+#[cfg(any(
+    target_os = "android",
+    target_os = "dragonfly",
+    target_os = "emscripten",
+    target_os = "freebsd",
+    target_os = "illumos",
+    target_os = "linux",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "redox",
+    target_os = "solaris"
+))]
 #[test]
 fn test_pipe2() {
     use nix::fcntl::{fcntl, FcntlArg, FdFlag};
@@ -721,8 +798,13 @@ static mut ALARM_CALLED: bool = false;
 
 // Used in `test_alarm`.
 #[cfg(not(target_os = "redox"))]
-pub extern fn alarm_signal_handler(raw_signal: libc::c_int) {
-    assert_eq!(raw_signal, libc::SIGALRM, "unexpected signal: {}", raw_signal);
+pub extern "C" fn alarm_signal_handler(raw_signal: libc::c_int) {
+    assert_eq!(
+        raw_signal,
+        libc::SIGALRM,
+        "unexpected signal: {}",
+        raw_signal
+    );
     unsafe { ALARM_CALLED = true };
 }
 
@@ -730,15 +812,16 @@ pub extern fn alarm_signal_handler(raw_signal: libc::c_int) {
 #[cfg(not(target_os = "redox"))]
 fn test_alarm() {
     use std::{
-        time::{Duration, Instant,},
-        thread
+        thread,
+        time::{Duration, Instant},
     };
 
     // Maybe other tests that fork interfere with this one?
     let _m = crate::SIGNAL_MTX.lock();
 
     let handler = SigHandler::Handler(alarm_signal_handler);
-    let signal_action = SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
+    let signal_action =
+        SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
     let old_handler = unsafe {
         sigaction(Signal::SIGALRM, &signal_action)
             .expect("unable to set signal handler for alarm")
@@ -755,7 +838,7 @@ fn test_alarm() {
     let starttime = Instant::now();
     loop {
         thread::sleep(Duration::from_millis(100));
-        if unsafe { ALARM_CALLED} {
+        if unsafe { ALARM_CALLED } {
             break;
         }
         if starttime.elapsed() > Duration::from_secs(3) {
@@ -782,7 +865,7 @@ fn test_canceling_alarm() {
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_symlinkat() {
     let _m = crate::CWD_LOCK.read();
 
@@ -810,7 +893,7 @@ fn test_symlinkat() {
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_linkat_file() {
     let tempdir = tempdir().unwrap();
     let oldfilename = "foo.txt";
@@ -820,18 +903,27 @@ fn test_linkat_file() {
     let newfilepath = tempdir.path().join(newfilename);
 
     // Create file
-    File::create(&oldfilepath).unwrap();
+    File::create(oldfilepath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt hard link file at relative path
-    linkat(Some(dirfd), oldfilename, Some(dirfd), newfilename, LinkatFlags::SymlinkFollow).unwrap();
+    linkat(
+        Some(dirfd),
+        oldfilename,
+        Some(dirfd),
+        newfilename,
+        LinkatFlags::SymlinkFollow,
+    )
+    .unwrap();
     assert!(newfilepath.exists());
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_linkat_olddirfd_none() {
     let _dr = crate::DirRestore::new();
 
@@ -844,19 +936,31 @@ fn test_linkat_olddirfd_none() {
     let newfilepath = tempdir_newfile.path().join(newfilename);
 
     // Create file
-    File::create(&oldfilepath).unwrap();
+    File::create(oldfilepath).unwrap();
 
     // Get file descriptor for base directory of new file
-    let dirfd = fcntl::open(tempdir_newfile.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd = fcntl::open(
+        tempdir_newfile.path(),
+        fcntl::OFlag::empty(),
+        stat::Mode::empty(),
+    )
+    .unwrap();
 
     // Attempt hard link file using curent working directory as relative path for old file path
     chdir(tempdir_oldfile.path()).unwrap();
-    linkat(None, oldfilename, Some(dirfd), newfilename, LinkatFlags::SymlinkFollow).unwrap();
+    linkat(
+        None,
+        oldfilename,
+        Some(dirfd),
+        newfilename,
+        LinkatFlags::SymlinkFollow,
+    )
+    .unwrap();
     assert!(newfilepath.exists());
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_linkat_newdirfd_none() {
     let _dr = crate::DirRestore::new();
 
@@ -869,19 +973,36 @@ fn test_linkat_newdirfd_none() {
     let newfilepath = tempdir_newfile.path().join(newfilename);
 
     // Create file
-    File::create(&oldfilepath).unwrap();
+    File::create(oldfilepath).unwrap();
 
     // Get file descriptor for base directory of old file
-    let dirfd = fcntl::open(tempdir_oldfile.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd = fcntl::open(
+        tempdir_oldfile.path(),
+        fcntl::OFlag::empty(),
+        stat::Mode::empty(),
+    )
+    .unwrap();
 
     // Attempt hard link file using current working directory as relative path for new file path
     chdir(tempdir_newfile.path()).unwrap();
-    linkat(Some(dirfd), oldfilename, None, newfilename, LinkatFlags::SymlinkFollow).unwrap();
+    linkat(
+        Some(dirfd),
+        oldfilename,
+        None,
+        newfilename,
+        LinkatFlags::SymlinkFollow,
+    )
+    .unwrap();
     assert!(newfilepath.exists());
 }
 
 #[test]
-#[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
+#[cfg(not(any(
+    target_os = "ios",
+    target_os = "macos",
+    target_os = "redox",
+    target_os = "haiku"
+)))]
 fn test_linkat_no_follow_symlink() {
     let _m = crate::CWD_LOCK.read();
 
@@ -902,23 +1023,29 @@ fn test_linkat_no_follow_symlink() {
     symlinkat(&oldfilepath, None, &symoldfilepath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt link symlink of file at relative path
-    linkat(Some(dirfd), symoldfilename, Some(dirfd), newfilename, LinkatFlags::NoSymlinkFollow).unwrap();
+    linkat(
+        Some(dirfd),
+        symoldfilename,
+        Some(dirfd),
+        newfilename,
+        LinkatFlags::NoSymlinkFollow,
+    )
+    .unwrap();
 
     // Assert newfile is actually a symlink to oldfile.
     assert_eq!(
-        readlink(&newfilepath)
-            .unwrap()
-            .to_str()
-            .unwrap(),
+        readlink(&newfilepath).unwrap().to_str().unwrap(),
         oldfilepath.to_str().unwrap()
     );
 }
 
 #[test]
-#[cfg(not(target_os = "redox"))]
+#[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 fn test_linkat_follow_symlink() {
     let _m = crate::CWD_LOCK.read();
 
@@ -939,15 +1066,26 @@ fn test_linkat_follow_symlink() {
     symlinkat(&oldfilepath, None, &symoldfilepath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt link target of symlink of file at relative path
-    linkat(Some(dirfd), symoldfilename, Some(dirfd), newfilename, LinkatFlags::SymlinkFollow).unwrap();
+    linkat(
+        Some(dirfd),
+        symoldfilename,
+        Some(dirfd),
+        newfilename,
+        LinkatFlags::SymlinkFollow,
+    )
+    .unwrap();
 
     let newfilestat = stat::stat(&newfilepath).unwrap();
 
     // Check the file type of the new link
-    assert_eq!((stat::SFlag::from_bits_truncate(newfilestat.st_mode as mode_t) & SFlag::S_IFMT),
+    assert_eq!(
+        (stat::SFlag::from_bits_truncate(newfilestat.st_mode as mode_t)
+            & SFlag::S_IFMT),
         SFlag::S_IFREG
     );
 
@@ -963,15 +1101,18 @@ fn test_unlinkat_dir_noremovedir() {
     let dirpath = tempdir.path().join(dirname);
 
     // Create dir
-    DirBuilder::new().recursive(true).create(&dirpath).unwrap();
+    DirBuilder::new().recursive(true).create(dirpath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt unlink dir at relative path without proper flag
-    let err_result = unlinkat(Some(dirfd), dirname, UnlinkatFlags::NoRemoveDir).unwrap_err();
+    let err_result =
+        unlinkat(Some(dirfd), dirname, UnlinkatFlags::NoRemoveDir).unwrap_err();
     assert!(err_result == Errno::EISDIR || err_result == Errno::EPERM);
- }
+}
 
 #[test]
 #[cfg(not(target_os = "redox"))]
@@ -984,12 +1125,14 @@ fn test_unlinkat_dir_removedir() {
     DirBuilder::new().recursive(true).create(&dirpath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt unlink dir at relative path with proper flag
     unlinkat(Some(dirfd), dirname, UnlinkatFlags::RemoveDir).unwrap();
     assert!(!dirpath.exists());
- }
+}
 
 #[test]
 #[cfg(not(target_os = "redox"))]
@@ -1002,34 +1145,47 @@ fn test_unlinkat_file() {
     File::create(&filepath).unwrap();
 
     // Get file descriptor for base directory
-    let dirfd = fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty()).unwrap();
+    let dirfd =
+        fcntl::open(tempdir.path(), fcntl::OFlag::empty(), stat::Mode::empty())
+            .unwrap();
 
     // Attempt unlink file at relative path
     unlinkat(Some(dirfd), filename, UnlinkatFlags::NoRemoveDir).unwrap();
     assert!(!filepath.exists());
- }
+}
 
 #[test]
 fn test_access_not_existing() {
     let tempdir = tempdir().unwrap();
     let dir = tempdir.path().join("does_not_exist.txt");
-    assert_eq!(access(&dir, AccessFlags::F_OK).err().unwrap(),
-               Errno::ENOENT);
+    assert_eq!(
+        access(&dir, AccessFlags::F_OK).err().unwrap(),
+        Errno::ENOENT
+    );
 }
 
 #[test]
 fn test_access_file_exists() {
     let tempdir = tempdir().unwrap();
-    let path  = tempdir.path().join("does_exist.txt");
+    let path = tempdir.path().join("does_exist.txt");
     let _file = File::create(path.clone()).unwrap();
-    assert!(access(&path, AccessFlags::R_OK | AccessFlags::W_OK).is_ok());
+    access(&path, AccessFlags::R_OK | AccessFlags::W_OK)
+        .expect("assertion failed");
 }
 
+//Clippy false positive https://github.com/rust-lang/rust-clippy/issues/9111
+#[allow(clippy::needless_borrow)]
 #[cfg(not(target_os = "redox"))]
 #[test]
 fn test_user_into_passwd() {
     // get the UID of the "nobody" user
-    let nobody = User::from_name("nobody").unwrap().unwrap();
+    #[cfg(not(target_os = "haiku"))]
+    let test_username = "nobody";
+    // "nobody" unavailable on haiku
+    #[cfg(target_os = "haiku")]
+    let test_username = "user";
+
+    let nobody = User::from_name(test_username).unwrap().unwrap();
     let pwd: libc::passwd = nobody.into();
     let _: User = (&pwd).into();
 }
@@ -1048,8 +1204,7 @@ fn test_setfsuid() {
     // create a temporary file with permissions '-rw-r-----'
     let file = tempfile::NamedTempFile::new_in("/var/tmp").unwrap();
     let temp_path = file.into_temp_path();
-    dbg!(&temp_path);
-    let temp_path_2 = (&temp_path).to_path_buf();
+    let temp_path_2 = temp_path.to_path_buf();
     let mut permissions = fs::metadata(&temp_path).unwrap().permissions();
     permissions.set_mode(0o640);
 
@@ -1059,8 +1214,8 @@ fn test_setfsuid() {
         let fuid = setfsuid(nobody.uid);
         // trying to open the temporary file should fail with EACCES
         let res = fs::File::open(&temp_path);
-        assert!(res.is_err());
-        assert_eq!(res.err().unwrap().kind(), io::ErrorKind::PermissionDenied);
+        let err = res.expect_err("assertion failed");
+        assert_eq!(err.kind(), io::ErrorKind::PermissionDenied);
 
         // assert fuid actually changes
         let prev_fuid = setfsuid(Uid::from_raw(-1i32 as u32));
@@ -1074,7 +1229,11 @@ fn test_setfsuid() {
 }
 
 #[test]
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 fn test_ttyname() {
     let fd = posix_openpt(OFlag::O_RDWR).expect("posix_openpt failed");
     assert!(fd.as_raw_fd() > 0);
@@ -1085,11 +1244,8 @@ fn test_ttyname() {
     grantpt(&fd).expect("grantpt failed");
     unlockpt(&fd).expect("unlockpt failed");
     let sname = unsafe { ptsname(&fd) }.expect("ptsname failed");
-    let fds = open(
-        Path::new(&sname),
-        OFlag::O_RDWR,
-        stat::Mode::empty(),
-    ).expect("open failed");
+    let fds = open(Path::new(&sname), OFlag::O_RDWR, stat::Mode::empty())
+        .expect("open failed");
     assert!(fds > 0);
 
     let name = ttyname(fds).expect("ttyname failed");
@@ -1105,7 +1261,11 @@ fn test_ttyname_not_pty() {
 }
 
 #[test]
-#[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
+#[cfg(not(any(
+    target_os = "redox",
+    target_os = "fuchsia",
+    target_os = "haiku"
+)))]
 fn test_ttyname_invalid_fd() {
     assert_eq!(ttyname(-1), Err(Errno::EBADF));
 }
@@ -1146,5 +1306,102 @@ fn test_getpeereid() {
 ))]
 fn test_getpeereid_invalid_fd() {
     // getpeereid is not POSIX, so error codes are inconsistent between different Unices.
-    assert!(getpeereid(-1).is_err());
+    getpeereid(-1).expect_err("assertion failed");
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_faccessat_none_not_existing() {
+    use nix::fcntl::AtFlags;
+    let tempdir = tempfile::tempdir().unwrap();
+    let dir = tempdir.path().join("does_not_exist.txt");
+    assert_eq!(
+        faccessat(None, &dir, AccessFlags::F_OK, AtFlags::empty())
+            .err()
+            .unwrap(),
+        Errno::ENOENT
+    );
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_faccessat_not_existing() {
+    use nix::fcntl::AtFlags;
+    let tempdir = tempfile::tempdir().unwrap();
+    let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let not_exist_file = "does_not_exist.txt";
+    assert_eq!(
+        faccessat(
+            Some(dirfd),
+            not_exist_file,
+            AccessFlags::F_OK,
+            AtFlags::empty(),
+        )
+        .err()
+        .unwrap(),
+        Errno::ENOENT
+    );
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_faccessat_none_file_exists() {
+    use nix::fcntl::AtFlags;
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path().join("does_exist.txt");
+    let _file = File::create(path.clone()).unwrap();
+    assert!(faccessat(
+        None,
+        &path,
+        AccessFlags::R_OK | AccessFlags::W_OK,
+        AtFlags::empty(),
+    )
+    .is_ok());
+}
+
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_faccessat_file_exists() {
+    use nix::fcntl::AtFlags;
+    let tempdir = tempfile::tempdir().unwrap();
+    let dirfd = open(tempdir.path(), OFlag::empty(), Mode::empty()).unwrap();
+    let exist_file = "does_exist.txt";
+    let path = tempdir.path().join(exist_file);
+    let _file = File::create(path.clone()).unwrap();
+    assert!(faccessat(
+        Some(dirfd),
+        &path,
+        AccessFlags::R_OK | AccessFlags::W_OK,
+        AtFlags::empty(),
+    )
+    .is_ok());
+}
+
+#[test]
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "freebsd",
+    target_os = "dragonfly"
+))]
+fn test_eaccess_not_existing() {
+    let tempdir = tempdir().unwrap();
+    let dir = tempdir.path().join("does_not_exist.txt");
+    assert_eq!(
+        eaccess(&dir, AccessFlags::F_OK).err().unwrap(),
+        Errno::ENOENT
+    );
+}
+
+#[test]
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "uclibc")),
+    target_os = "freebsd",
+    target_os = "dragonfly"
+))]
+fn test_eaccess_file_exists() {
+    let tempdir = tempdir().unwrap();
+    let path = tempdir.path().join("does_exist.txt");
+    let _file = File::create(path.clone()).unwrap();
+    eaccess(&path, AccessFlags::R_OK | AccessFlags::W_OK)
+        .expect("assertion failed");
 }