fix(sort): use native sysctl for percentage buffer-size on BSD platforms

Replace subprocess-based sysctl calls with native libc::sysctl() syscalls
for macOS, FreeBSD, OpenBSD, and NetBSD to fix test_buffer_sizes failure
in CI environments.

The previous implementation spawned sysctl subprocesses which could fail
in sandboxed GitHub Actions runners. The native approach is more reliable,
performant, and includes subprocess fallback for robustness.

Fixes percentage-based buffer size parsing (e.g., sort -S 10%)

Author: naoNao89

src/uucore/src/lib/features/parser/parse_size.rs

@@ -79,9 +79,33 @@ pub fn available_memory_bytes() -> Option<u128> {
 
 /// Get the total number of bytes of physical memory on macOS.
 ///
-/// Uses the `sysctl` command to query `hw.memsize`.
+/// Uses native `sysctl` syscall to query `hw.memsize`, with subprocess fallback.
 #[cfg(target_os = "macos")]
 fn total_physical_memory() -> Result<u128, SystemError> {
+    use std::mem;
+    use std::ptr;
+
+    // Try native sysctl syscall first (more reliable in restricted environments)
+    let mut size: u64 = 0;
+    let mut len = mem::size_of::<u64>();
+    let mut mib = [libc::CTL_HW, libc::HW_MEMSIZE];
+
+    let result = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            2,
+            &mut size as *mut _ as *mut libc::c_void,
+            &mut len,
+            ptr::null_mut(),
+            0,
+        )
+    };
+
+    if result == 0 {
+        return Ok(size as u128);
+    }
+
+    // Fallback to subprocess if native call fails
     let output = std::process::Command::new("sysctl")
         .arg("-n")
         .arg("hw.memsize")
@@ -94,9 +118,36 @@ fn total_physical_memory() -> Result<u128, SystemError> {
 
 /// Get the total number of bytes of physical memory on FreeBSD.
 ///
-/// Uses the `sysctl` command to query `hw.physmem`.
+/// Uses native `sysctl` syscall to query `hw.physmem`, with subprocess fallback.
 #[cfg(target_os = "freebsd")]
 fn total_physical_memory() -> Result<u128, SystemError> {
+    use std::mem;
+    use std::ptr;
+
+    // HW_PHYSMEM constant (not always exported by libc)
+    const HW_PHYSMEM: libc::c_int = 5;
+
+    // Try native sysctl syscall first (more reliable in restricted environments)
+    let mut size: u64 = 0;
+    let mut len = mem::size_of::<u64>();
+    let mut mib = [libc::CTL_HW, HW_PHYSMEM];
+
+    let result = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            2,
+            ptr::from_mut(&mut size).cast::<libc::c_void>(),
+            &mut len,
+            ptr::null_mut(),
+            0,
+        )
+    };
+
+    if result == 0 {
+        return Ok(size as u128);
+    }
+
+    // Fallback to subprocess if native call fails
     let output = std::process::Command::new("sysctl")
         .arg("-n")
         .arg("hw.physmem")
@@ -109,9 +160,36 @@ fn total_physical_memory() -> Result<u128, SystemError> {
 
 /// Get the total number of bytes of physical memory on OpenBSD.
 ///
-/// Uses the `sysctl` command to query `hw.physmem`.
+/// Uses native `sysctl` syscall to query `hw.physmem`, with subprocess fallback.
 #[cfg(target_os = "openbsd")]
 fn total_physical_memory() -> Result<u128, SystemError> {
+    use std::mem;
+    use std::ptr;
+
+    // HW_PHYSMEM constant (not always exported by libc)
+    const HW_PHYSMEM: libc::c_int = 19;
+
+    // Try native sysctl syscall first (more reliable in restricted environments)
+    let mut size: u64 = 0;
+    let mut len = mem::size_of::<u64>();
+    let mut mib = [libc::CTL_HW, HW_PHYSMEM];
+
+    let result = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            2,
+            ptr::from_mut(&mut size).cast::<libc::c_void>(),
+            &mut len,
+            ptr::null_mut(),
+            0,
+        )
+    };
+
+    if result == 0 {
+        return Ok(size as u128);
+    }
+
+    // Fallback to subprocess if native call fails
     let output = std::process::Command::new("sysctl")
         .arg("-n")
         .arg("hw.physmem")
@@ -124,9 +202,36 @@ fn total_physical_memory() -> Result<u128, SystemError> {
 
 /// Get the total number of bytes of physical memory on NetBSD.
 ///
-/// Uses the `sysctl` command to query `hw.physmem64`.
+/// Uses native `sysctl` syscall to query `hw.physmem64`, with subprocess fallback.
 #[cfg(target_os = "netbsd")]
 fn total_physical_memory() -> Result<u128, SystemError> {
+    use std::mem;
+    use std::ptr;
+
+    // HW_PHYSMEM64 constant (not always exported by libc)
+    const HW_PHYSMEM64: libc::c_int = 9;
+
+    // Try native sysctl syscall first (more reliable in restricted environments)
+    let mut size: u64 = 0;
+    let mut len = mem::size_of::<u64>();
+    let mut mib = [libc::CTL_HW, HW_PHYSMEM64];
+
+    let result = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            2,
+            ptr::from_mut(&mut size).cast::<libc::c_void>(),
+            &mut len,
+            ptr::null_mut(),
+            0,
+        )
+    };
+
+    if result == 0 {
+        return Ok(size as u128);
+    }
+
+    // Fallback to subprocess if native call fails
     let output = std::process::Command::new("sysctl")
         .arg("-n")
         .arg("hw.physmem64")