Test that for BSD's normal threads niceness is used.

Also attempts to solve the CI issue with the registry.

Author: iddm

.github/workflows/ci.yml

@@ -56,9 +56,17 @@ jobs:
         if: matrix.features == ''
         run: cargo build --all-features
 
-      - name: Test all features (other)
-        if: matrix.features == '' && runner.os != 'Linux'
-        run: cargo test --all-features -- --skip set_deadline_policy
+      - name: Test all features (macos)
+        if: matrix.features == '' && runner.os == 'macOS'
+        run: sudo -E /Users/runner/.cargo/bin/cargo test --all-features
+
+      - name: Test all features (Windows)
+        if: matrix.features == '' && runner.os == 'Windows'
+        run: cargo test --all-features
+
+      - name: Test all features (non-linux and non-macOS)
+        if: matrix.features == '' && runner.os != 'Linux' && runner.os != 'macOS' && runner.os != 'Windows'
+        run: sudo -E /home/runner/.cargo/bin/cargo test --all-features -- --skip set_deadline_policy
 
       - name: Test all features (Linux)
         if: matrix.features == '' && runner.os == 'Linux'

Cargo.toml

@@ -12,7 +12,7 @@ categories = ["concurrency", "asynchronous", "os"]
 edition = "2018"
 
 [dev-dependencies]
-rstest = "0.15"
+rstest = "0.13"
 
 [dependencies]
 log = "0.4"

src/unix.rs

@@ -54,6 +54,22 @@ fn errno() -> libc::c_int {
     }
 }
 
+fn set_errno(number: libc::c_int) {
+    unsafe {
+        cfg_if::cfg_if! {
+            if #[cfg(any(target_os = "openbsd", target_os = "netbsd"))] {
+                *libc::__errno() = number;
+            } else if #[cfg(target_os = "linux")] {
+                *libc::__errno_location() = number;
+            } else if #[cfg(any(target_os = "macos", target_os = "freebsd"))] {
+                *libc::__error() = number;
+            } else {
+                compile_error!("Your OS is probably not supported.")
+            }
+        }
+    }
+}
+
 /// Copy of the Linux kernel's sched_attr type
 #[repr(C)]
 #[derive(Debug, Default)]
@@ -315,7 +331,6 @@ impl ThreadPriority {
                     let niceness_values = NICENESS_MAX.abs() + NICENESS_MIN.abs();
                     let ratio = p as f32 / ThreadPriorityValue::MAX as f32;
                     let niceness = ((niceness_values as f32 * ratio) as i8 + NICENESS_MAX) as i32;
-                    dbg!(niceness_values, ratio, niceness);
                     Self::to_allowed_value_for_policy(niceness, policy).map(|v| v as u32)
                 }
             },
@@ -446,7 +461,6 @@ pub fn set_thread_priority_and_policy(
         }
         _ => {
             let fixed_priority = priority.to_posix(policy)?;
-            dbg!(policy, priority, fixed_priority);
             if let ThreadSchedulePolicy::Realtime(_) = policy {
                 // If the policy is a realtime one, the priority is set via
                 // pthread_setschedparam.
@@ -470,11 +484,13 @@ pub fn set_thread_priority_and_policy(
             } else {
                 // If this is a normal-scheduled thread, the priority is
                 // set via niceness.
-                let ret = unsafe { libc::nice(fixed_priority) };
+                set_errno(0);
 
-                match ret {
-                    -1 => Err(Error::OS(errno())),
-                    _ => Ok(()),
+                unsafe { libc::nice(fixed_priority) };
+
+                match errno() {
+                    0 => Ok(()),
+                    e => Err(Error::OS(e)),
                 }
             }
         }

tests/unix.rs

@@ -26,6 +26,7 @@ fn get_and_set_priority_with_normal_policies(
     }
 }
 
+// In macOS it is allowed to specify number as a SCHED_OTHER policy priority.
 #[cfg(any(
     target_os = "macos",
     target_os = "openbsd",
@@ -39,8 +40,7 @@ fn get_and_set_priority_with_normal_policies(
     #[values(ThreadPriority::Min, ThreadPriority::Max, ThreadPriority::Crossplatform(23u8.try_into().unwrap()))]
     priority: ThreadPriority,
 ) {
-    // In macOS it is allowed to specify number as a SCHED_OTHER policy priority.
-    assert!(set_thread_priority_and_policy(thread_native_id(), priority, policy,).is_ok());
+    assert!(set_thread_priority_and_policy(thread_native_id(), priority, policy).is_ok());
 }
 
 #[rstest]
@@ -69,6 +69,7 @@ fn check_min_and_max_priority_values(
 #[case(ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Other))]
 fn set_priority_with_normal_policy_but_with_invalid_value(#[case] policy: ThreadSchedulePolicy) {
     let thread_id = thread_native_id();
+    #[cfg(target_os = "linux")]
     let expected = if policy == ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Idle) {
         // In Linux we should get an error whenever a non-zero value is passed as priority and a normal
         // scheduling policy is used.
@@ -94,7 +95,8 @@ fn set_priority_with_normal_policy_but_with_invalid_value(#[case] policy: Thread
     target_os = "netbsd"
 ))]
 #[test]
-// In macOS the SCHED_OTHER policy allows having a non-zero priority value.
+// In macOS the SCHED_OTHER policy allows having a non-zero priority value,
+// but the crate doesn't use this opportunity for normal threads and uses niceness instead.
 fn get_and_set_priority_with_normal_policy() {
     let thread_id = thread_native_id();
     let normal_policy = ThreadSchedulePolicy::Normal(NormalThreadSchedulePolicy::Other);
@@ -108,17 +110,6 @@ fn get_and_set_priority_with_normal_policy() {
         Ok(())
     );
     assert_eq!(thread_schedule_policy(), Ok(normal_policy));
-    assert_eq!(
-        thread_schedule_policy_param(thread_native_id()),
-        Ok((normal_policy, ScheduleParams { sched_priority: 23 }))
-    );
-    assert_eq!(
-        Thread::current(),
-        Ok(Thread {
-            priority: ThreadPriority::Crossplatform(23u8.try_into().unwrap()),
-            id: thread_native_id()
-        })
-    );
 }
 
 #[rstest]