Fix some test failures on illumos. (#740)

`mlock` fails if the memory is not aligned. `tcgetattr` doesn't work on
pseudoterminals. A few errno values are different. And disable some tests
that are disabled on other platforms too.

src/mm/mmap.rs

@@ -222,7 +222,8 @@ pub unsafe fn mprotect(ptr: *mut c_void, len: usize, flags: MprotectFlags) -> io
 ///
 /// Some implementations implicitly round the memory region out to the nearest
 /// page boundaries, so this function may lock more memory than explicitly
-/// requested if the memory isn't page-aligned.
+/// requested if the memory isn't page-aligned. Other implementations fail if
+/// the memory isn't page-aligned.
 ///
 /// # References
 /// - [POSIX]

tests/fs/mknodat.rs

@@ -8,8 +8,13 @@ fn test_mknodat() {
  let tmp = tempfile::tempdir().unwrap();
  let dir = openat(CWD, tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap();
 
- // Create a regular file. Not supported on FreeBSD or OpenBSD.
- #[cfg(not(any(target_os = "freebsd", target_os = "openbsd", target_os = "solaris")))]
+ // Create a regular file. Not supported on FreeBSD, OpenBSD, or illumos.
+ #[cfg(not(any(
+ target_os = "freebsd",
+ target_os = "illumos",
+ target_os = "openbsd",
+ target_os = "solaris"
+ )))]
  {
  mknodat(&dir, "foo", FileType::RegularFile, Mode::empty(), 0).unwrap();
  let stat = statat(&dir, "foo", AtFlags::empty()).unwrap();

tests/mm/mlock.rs

@@ -8,10 +8,16 @@ use std::ffi::c_void;
 #[test]
 fn test_mlock() {
  let mut buf = vec![0_u8; 4096];
+ let ptr = buf.as_mut_ptr();
+
+ // On Linux, `mlock` automatically rounds the address down to the nearest
+ // page size. On other platforms, we need to do it manually.
+ #[cfg(not(linux_kernel))]
+ let ptr = ((ptr as usize) & (-4096_isize) as usize) as *mut u8;
 
  unsafe {
- match rustix::mm::mlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()) {
- Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(),
+ match rustix::mm::mlock(ptr.cast::<c_void>(), buf.len()) {
+ Ok(()) => rustix::mm::munlock(ptr.cast::<c_void>(), buf.len()).unwrap(),
  // Tests won't always have enough memory or permissions, and that's ok.
  Err(rustix::io::Errno::PERM | rustix::io::Errno::NOMEM) => {}
  // But they shouldn't fail otherwise.

tests/mm/mmap.rs

@@ -100,8 +100,13 @@ fn test_mlock() {
  unsafe {
  let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap();
 
- mlock(addr, 8192).unwrap();
- munlock(addr, 8192).unwrap();
+ match mlock(addr, 8192) {
+ Ok(()) => munlock(addr, 8192).unwrap(),
+ // Tests won't always have enough memory or permissions, and that's ok.
+ Err(rustix::io::Errno::PERM | rustix::io::Errno::NOMEM) => (),
+ // But they shouldn't fail otherwise.
+ Err(other) => Err(other).unwrap(),
+ }
 
  #[cfg(linux_kernel)]
  {

tests/net/sockopt.rs

@@ -25,9 +25,9 @@ fn test_sockopts_ipv4() {
  assert!(!rustix::net::sockopt::get_socket_passcred(&s).unwrap());
  assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 0);
  assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77);
- #[cfg(not(any(bsd, windows)))]
+ #[cfg(not(any(bsd, windows, target_os = "illumos")))]
  assert!(rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap());
- #[cfg(not(any(bsd, windows)))]
+ #[cfg(not(any(bsd, windows, target_os = "illumos")))]
  assert_eq!(rustix::net::sockopt::get_ip_multicast_ttl(&s).unwrap(), 1);
  assert!(!rustix::net::sockopt::get_tcp_nodelay(&s).unwrap());
  // On a new socket we shouldn't have an error yet.
@@ -111,7 +111,7 @@ fn test_sockopts_ipv4() {
  // Check the ip ttl.
  assert_eq!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77);
 
- #[cfg(not(any(bsd, windows)))]
+ #[cfg(not(any(bsd, windows, target_os = "illumos")))]
  {
  // Set the multicast loop flag;
  rustix::net::sockopt::set_ip_multicast_loop(&s, false).unwrap();
@@ -152,6 +152,7 @@ fn test_sockopts_ipv6() {
  Ok(multicast_loop) => assert!(multicast_loop),
  Err(rustix::io::Errno::OPNOTSUPP) => (),
  Err(rustix::io::Errno::INVAL) => (),
+ Err(rustix::io::Errno::NOPROTOOPT) => (),
  Err(err) => Err(err).unwrap(),
  }
  assert_ne!(rustix::net::sockopt::get_ipv6_unicast_hops(&s).unwrap(), 0);
@@ -175,13 +176,12 @@ fn test_sockopts_ipv6() {
  // Check that the IPV6 multicast loop value is set.
  match rustix::net::sockopt::get_ipv6_multicast_loop(&s) {
  Ok(multicast_loop) => assert!(!multicast_loop),
- Err(rustix::io::Errno::OPNOTSUPP) => (),
- Err(rustix::io::Errno::INVAL) => (),
  Err(err) => Err(err).unwrap(),
  }
  }
  Err(rustix::io::Errno::OPNOTSUPP) => (),
  Err(rustix::io::Errno::INVAL) => (),
+ Err(rustix::io::Errno::NOPROTOOPT) => (),
  Err(err) => Err(err).unwrap(),
  }
 

tests/net/unix.rs

@@ -216,7 +216,8 @@ fn do_test_unix_msg(addr: SocketAddrUnix) {
  );
  // Don't ask me why, but this was seen to fail on FreeBSD.
  // `SocketAddrUnix::path()` returned `None` for some reason.
- #[cfg(not(target_os = "freebsd"))]
+ // illumos too.
+ #[cfg(not(any(target_os = "freebsd", target_os = "illumos")))]
  assert_eq!(
  Some(rustix::net::SocketAddrAny::Unix(addr.clone())),
  result.address

tests/termios/termios.rs

@@ -1,3 +1,6 @@
+// Disable on illumos where `tcgetattr` doesn't appear to support
+// pseudoterminals.
+#[cfg(not(target_os = "illumos"))]
 #[test]
 fn test_termios_speeds() {
  use rustix::pty::*;

tests/time/settime.rs

@@ -4,14 +4,14 @@ use rustix::time::{clock_settime, ClockId, Timespec};
 #[test]
 fn test_settime() {
  // Monotonic clocks are never settable.
- assert_eq!(
- clock_settime(
-  ClockId::Monotonic,
- Timespec {
-  tv_sec: 0,
-  tv_nsec: 0
-  }
- ),
- Err(io::Errno::INVAL)
- );
+ match clock_settime(
+ ClockId::Monotonic,
+ Timespec {
+ tv_sec: 0,
+ tv_nsec: 0,
+ },
+ ) {
+ Err(io::Errno::INVAL | io::Errno::PERM) => (),
+ _otherwise => panic!(),
+ }
 }