Fix CI by relaxing our MSRV constraint (#2689)

* Fix CI by relaxing our MSRV constraint

Recently a transitive dev-dependency published a new version that is
incompatible with Nix's MSRV, causing CI to break.  That's annoying,
because there's really no reason why a crate's dev-dependencies ought to
respect the MSRV.  Fix Nix's CI by:

* Running all tests with stable Rust (or nightly, for certain targets)
* Adding an additional set of CI checks to ensure that the crate will
  compile with MSRV, on all of the major operating systems, but don't
  try to compile its tests.
* Eliminate the now-redundant "rust-stable" CI task.

* Don't use --all-targets when testing MSRV

* Fix some Clippy warnings on apple

I think these never showed up in CI before, because we've never run
clippy on Rust stable on apple until now.

* Suppress a Clippy false positive

* GetCString only needs to be build with features=net

* Fix Clippy on Solarish, with Rust stable

* Disable the libc::personality doc test on QEMU

It's failing there with EPERM.  It's probably seccomp's fault

* Skip lio_listio doc test on musl/aarch64/i686 as it hangs

Do not run this doc test on:

* aarch64-unknown-linux-musl
* i686-unknown-linux-musl

because it hangs on these targets. After further debugging, we think this is
likely a bug of musl. Since we only test our bindings and do not intend to
fix the underlying libc bug, we skip this test here. See this thread [1] for
the discussion of this issue

[1]: #2689 (comment)

* Run rustfmt on src/sys/aio.rs

* Set RUST_BACKTRACE=1 when running tests

Set this to enable the backtrace to make debugging easier

* Cross env var passthrough: RUSTDOCFLAGS and RUST_BACKTRACE

I don't know if "RUSTDOCFLAGS" will be passed automatically, but from
their doc [1]:

> In the instances that you do want to pass through additional environment
> variables, this can be done via build.env.passthrough in your Cross.toml:
>
> ```toml
> [build.env]
> passthrough = [
>    "RUST_BACKTRACE"
> ]
> ```

We do need to specify "RUST_BACKTRACE" here. Anyway, let's pass both in
case Cross won't do this for us.

[1]: https://github.com/cross-rs/cross/blob/49cd054de9b832dfc11a4895c72b0aef533b5c6a/docs/environment_variables.md#environment-variable-passthrough

* Disable the ScmTimestamp doc test on 32-bit musl

Because this platform has very unique behavior.  It can be worked
around, but our doc test does not include that workaround.

#2698

---------

Co-authored-by: Steve Lau <stevelauc@outlook.com>

Author: asomers

.cirrus.yml

@@ -50,7 +50,7 @@ task:
   setup_script:
     - kldload mqueuefs
     - fetch https://sh.rustup.rs -o rustup.sh
-    - sh rustup.sh -y --profile=minimal --default-toolchain $MSRV
+    - sh rustup.sh -y --profile=minimal --default-toolchain stable
     - . $HOME/.cargo/env
     - rustup target add i686-unknown-freebsd
     - rustup component add clippy

.github/actions/build/action.yml

@@ -21,6 +21,11 @@ inputs:
     required: false
     default: -D warnings
 
+  TARGETS:
+    description: 'Build all targets or only default?'
+    required: false
+    default: "--all-targets"
+
   TOOL: 
     description: 'Tool used to involve the BUILD command, can be cargo or cross'
     required: false
@@ -30,6 +35,16 @@ inputs:
     required: false
     default: 
 
+  NOCLIPPY:
+    description: "whether to run cargo clippy"
+    required: false
+    default: false
+
+  NODOC:
+    description: "whether to run cargo doc"
+    required: false
+    default: false
+
   NOHACK:
     description: "whether to run cargo hack"
     required: false
@@ -52,13 +67,15 @@ runs:
 
     - name: build
       shell: bash
-      run: ${{ inputs.TOOL }} ${{ inputs.BUILD }} ${{ inputs.ZFLAGS }} --target ${{ inputs.TARGET }} --all-targets --all-features  
+      run: ${{ inputs.TOOL }} ${{ inputs.BUILD }} ${{ inputs.ZFLAGS }} --target ${{ inputs.TARGET }} ${{ inputs.TARGETS }} --all-features
 
     - name: doc
+      if: inputs.NODOC == 'false'
       shell: bash
       run: ${{ inputs.TOOL }} doc ${{ inputs.ZFLAGS }} --no-deps --target ${{ inputs.TARGET }} --all-features
 
     - name: clippy
+      if: inputs.NOCLIPPY == 'false'
       shell: bash
       run: ${{ inputs.TOOL}} clippy ${{ inputs.ZFLAGS }} --target ${{ inputs.TARGET }} --all-targets --all-features -- ${{ inputs.CLIPPYFLAGS }}
 

.github/actions/test/action.yml

@@ -19,13 +19,20 @@ inputs:
     required: false
     default: -D warnings -A unknown-lints
 
+  RUSTDOCFLAGS:
+    required: false
+    default: -D warnings
+
 runs:
   using: "composite"
   steps:
     - name: set up Rust env
       shell: bash
       run: |
         echo "RUSTFLAGS=${{ inputs.RUSTFLAGS }}" >> $GITHUB_ENV
+        echo "RUSTDOCFLAGS=${{ inputs.RUSTDOCFLAGS }}" >> $GITHUB_ENV
+        # Enable backtrace to make debugging easier
+        echo "RUST_BACKTRACE=1" >> $GITHUB_ENV
 
     - name: test
       shell: bash

.github/workflows/ci.yml

@@ -14,10 +14,6 @@ permissions:
 
 env: 
   MSRV: 1.69.0
-  # Rust's Loongarch support merged in 1.71.0
-  MSRV_LOONGARCH: 1.71.0
-  # Minimal Rust version to support all 3 official OpenHarmony targets as tier2
-  MSRV_OHOS: 1.78.0 
   RUSTFLAGS: -Dwarnings
 
 jobs:
@@ -32,7 +28,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-          toolchain: '${{ env.MSRV }}'
+          toolchain: stable
           components: clippy
 
       - name: build
@@ -59,7 +55,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-          toolchain: '${{ env.MSRV }}'
+          toolchain: stable
           components: clippy
 
       - name: build
@@ -79,7 +75,7 @@ jobs:
   # cross needs to execute Docker, GitHub Action already has it installed
   cross:
     runs-on: ubuntu-24.04
-    needs: [rustfmt, minver, macos, x86_64_linux_native_builds, rust_stable]
+    needs: [rustfmt, minver, macos, x86_64_linux_native_builds]
     strategy:
       fail-fast: false
       matrix:
@@ -108,8 +104,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-          # Use a newer version rustc if the target is Loongarch, remove this workaround after MSRV is newer than 1.71.0
-          toolchain: "${{ matrix.target == 'loongarch64-unknown-linux-gnu' && env.MSRV_LOONGARCH || env.MSRV }}"
+          toolchain: stable
           components: clippy
 
       # cross relies on docker or podman, GitHub Acton already has it installed.
@@ -132,6 +127,7 @@ jobs:
           SUDO: ""
           TOOL: cross
           RUSTFLAGS: --cfg qemu -D warnings
+          RUSTDOCFLAGS: --cfg qemu
 
       - name: before_cache_script
         run: rm -rf $CARGO_HOME/registry/index
@@ -156,7 +152,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-          toolchain: '${{ env.MSRV }}'
+          toolchain: stable
           components: clippy
 
       - name: install targets
@@ -193,7 +189,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-          toolchain: '${{ env.MSRV }}'
+          toolchain: stable
           components: clippy
 
       - name: install targets
@@ -212,38 +208,11 @@ jobs:
       - name: before_cache_script
         run: sudo rm -rf $CARGO_HOME/registry/index;
 
-  rust_stable:
-    runs-on: ubuntu-latest
-    env: 
-      TARGET: x86_64-unknown-linux-gnu
-    steps:
-      - name: checkout
-        uses: actions/checkout@v4
-
-      - name: setup Rust
-        uses: dtolnay/rust-toolchain@stable
-        with: 
-          components: clippy
-
-      - name: build
-        uses: ./.github/actions/build
-        with:
-          TARGET: '${{ env.TARGET }}'
-
-      - name: test
-        uses: ./.github/actions/test
-        with:
-          TARGET: '${{ env.TARGET }}'
-
-      - name: before_cache_script
-        run: sudo rm -rf $CARGO_HOME/registry/index
-
-
 
   # Tasks for cross-compiling, but no testing
   cross_compiling:
     runs-on: ubuntu-latest
-    needs: [rustfmt, minver, macos, x86_64_linux_native_builds, rust_stable]
+    needs: [rustfmt, minver, macos, x86_64_linux_native_builds]
     env:
       BUILD: check
     strategy:
@@ -282,8 +251,7 @@ jobs:
       - name: setup Rust
         uses: dtolnay/rust-toolchain@master
         with: 
-           # Use a newer version rustc if it is OpenHarmony, remove this workaround after MSRV is newer than 1.78.0 
-          toolchain: "${{ contains(matrix.target, 'ohos')  && env.MSRV_OHOS || env.MSRV }}" 
+          toolchain: stable
           components: clippy
 
       - name: install targets
@@ -299,10 +267,56 @@ jobs:
       - name: before_cache_script
         run: rm -rf $CARGO_HOME/registry/index
 
+  # Check that Nix will build on the MSRV, on a variety of operating systems.
+  # But don't check the tests.  Those are not required to build on MSRV.
+  msrv:
+    runs-on: ubuntu-latest
+    needs: [rustfmt, minver, macos, x86_64_linux_native_builds]
+    env:
+      BUILD: check
+      NOCLIPPY: true
+      NODOC: true
+      NOHACK: true
+      TARGETS: ""
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: aarch64-linux-android
+          - target: x86_64-unknown-linux-gnu
+          - target: x86_64-unknown-linux-musl
+          - target: aarch64-apple-darwin
+          - target: x86_64-unknown-freebsd
+          - target: x86_64-unknown-netbsd
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: setup Rust
+        uses: dtolnay/rust-toolchain@master
+        with: 
+          toolchain: $MSRV
+
+      - name: install targets
+        run: rustup target add ${{ matrix.target }}
+
+      - name: build
+        uses: ./.github/actions/build
+        with:
+          TARGET: '${{ matrix.target }}'
+          TARGETS: '${{ env.TARGETS }}'
+          BUILD: '${{ env.BUILD }}'
+          NOCLIPPY: '${{ env.NOCLIPPY  }}'
+          NODOC: '${{ env.NODOC  }}'
+          NOHACK: '${{ env.NOHACK  }}'
+
+      - name: before_cache_script
+        run: rm -rf $CARGO_HOME/registry/index
+
 
   redox:
     runs-on: ubuntu-latest
-    needs: [rustfmt, minver, macos, x86_64_linux_native_builds, rust_stable]
+    needs: [rustfmt, minver, macos, x86_64_linux_native_builds]
     env: 
       TARGET: x86_64-unknown-redox
       CLIPPYFLAGS: -D warnings

Cross.toml

@@ -1,7 +1,9 @@
 [build.env]
 passthrough = [
 	"RUSTFLAGS",
-	"RUST_TEST_THREADS"
+	"RUSTDOCFLAGS",
+	"RUST_TEST_THREADS",
+	"RUST_BACKTRACE",
 ]
 
 [target.loongarch64-unknown-linux-gnu]

src/sys/aio.rs

@@ -456,7 +456,7 @@ impl<'a> AioFsync<'a> {
     /// * `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 
+    ///   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(
@@ -1141,7 +1141,29 @@ pub fn aio_suspend(
 /// `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.
-/// ```
+///
+// Do not run this doc test on:
+//   * aarch64-unknown-linux-musl
+//   * i686-unknown-linux-musl
+// because it hangs on these targets. After further debugging, we think this is
+// likely a bug of musl. Since we only test our bindings and do not intend to
+// fix the underlying libc bug, we skip this test here.
+// See this thread for the discussion of this issue:
+// https://github.com/nix-rust/nix/pull/2689#issuecomment-3419813159
+#[cfg_attr(
+    all(
+        target_env = "musl",
+        any(target_arch = "aarch64", target_arch = "x86")
+    ),
+    doc = " ```no_run"
+)]
+#[cfg_attr(
+    not(all(
+        target_env = "musl",
+        any(target_arch = "aarch64", target_arch = "x86")
+    )),
+    doc = " ```"
+)]
 /// # use libc::c_int;
 /// # use std::os::unix::io::AsFd;
 /// # use std::sync::atomic::{AtomicBool, Ordering};

src/sys/personality.rs

@@ -54,7 +54,8 @@ libc_bitflags! {
 ///
 /// Example:
 ///
-/// ```
+#[cfg_attr(any(qemu, target_arch = "aarch64"), doc = " ```no_run")]
+#[cfg_attr(not(any(qemu, target_arch = "aarch64")), doc = " ```")]
 /// # use nix::sys::personality::{self, Persona};
 /// let pers = personality::get().unwrap();
 /// assert!(!pers.contains(Persona::WHOLE_SECONDS));
@@ -78,10 +79,10 @@ pub fn get() -> Result<Persona> {
 ///
 /// Example:
 ///
-// Disable test on aarch64 until we know why it fails.
+// Disable test on aarch64 and with QEMU.  seccomp interference is suspected.
 // https://github.com/nix-rust/nix/issues/2060
-#[cfg_attr(target_arch = "aarch64", doc = " ```no_run")]
-#[cfg_attr(not(target_arch = "aarch64"), doc = " ```")]
+#[cfg_attr(any(qemu, target_arch = "aarch64"), doc = " ```no_run")]
+#[cfg_attr(not(any(qemu, target_arch = "aarch64")), doc = " ```")]
 /// # use nix::sys::personality::{self, Persona};
 /// let mut pers = personality::get().unwrap();
 /// assert!(!pers.contains(Persona::ADDR_NO_RANDOMIZE));

src/sys/socket/mod.rs

@@ -772,7 +772,9 @@ pub enum ControlMessageOwned {
     ///
     /// # Examples
     ///
-    /// ```
+#[cfg_attr(all(target_env = "musl", target_pointer_width = "32"), doc = "See <https://github.com/nix-rust/nix/issues/2698> for notes regarding 32-bit musl")]
+#[cfg_attr(all(target_env = "musl", target_pointer_width = "32"), doc = "```no_run")]
+#[cfg_attr(any(not(target_env = "musl"), target_pointer_width = "64"), doc="```")]
     /// # #[macro_use] extern crate nix;
     /// # use nix::sys::socket::*;
     /// # use nix::sys::time::*;

src/sys/socket/sockopt.rs

@@ -1972,12 +1972,14 @@ impl<'a> Set<'a, OsString> for SetOsString<'a> {
 
 /// Getter for a `CString` value.
 #[cfg(apple_targets)]
+#[cfg(feature = "net")]
 struct GetCString<T: AsMut<[u8]>> {
     len: socklen_t,
     val: MaybeUninit<T>,
 }
 
 #[cfg(apple_targets)]
+#[cfg(feature = "net")]
 impl<T: AsMut<[u8]>> Get<CString> for GetCString<T> {
     fn uninit() -> Self {
         GetCString {

test/test_sendfile.rs

@@ -159,10 +159,10 @@ fn test_sendfile_dragonfly() {
 fn test_sendfile_darwin() {
     // Declare the content
     let header_strings =
-        vec!["HTTP/1.1 200 OK\n", "Content-Type: text/plain\n", "\n"];
+        ["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"];
+    let trailer_strings = ["\n", "Served by Make Believe\n"];
 
     // Write the body to a file
     let mut tmp = tempfile().unwrap();
@@ -195,7 +195,7 @@ fn test_sendfile_darwin() {
         + &trailer_strings.concat();
 
     // Verify the message that was sent
-    assert_eq!(bytes_written as usize, expected_string.as_bytes().len());
+    assert_eq!(bytes_written as usize, expected_string.len());
 
     let mut read_string = String::new();
     let bytes_read = rd.read_to_string(&mut read_string).unwrap();
@@ -258,7 +258,7 @@ fn test_sendfilev() {
         + &trailer_strings.concat();
 
     // Verify the message that was sent
-    assert_eq!(bytes_written, expected_string.as_bytes().len());
+    assert_eq!(bytes_written, expected_string.len());
 
     let mut read_string = String::new();
     let bytes_read = rd.read_to_string(&mut read_string).unwrap();