rust-hg-core: use correct type for libc hostname buffer

The type of libc::c_char is u8 on aarch64 rather than i8, which causes
the use of a specifically-typed constant to fail.

Differential Revision: https://phab.mercurial-scm.org/D12373

rust/hg-core/src/lock.rs

@@ -1,187 +1,187 b''
 //! Filesystem-based locks for local repositories
 
 use crate::errors::HgError;
 use crate::errors::HgResultExt;
 use crate::utils::StrExt;
 use crate::vfs::Vfs;
 use std::io;
 use std::io::ErrorKind;
 
 #[derive(derive_more::From)]
 pub enum LockError {
     AlreadyHeld,
     #[from]
     Other(HgError),
 }
 
 /// Try to call `f` with the lock acquired, without waiting.
 ///
 /// If the lock is aready held, `f` is not called and `LockError::AlreadyHeld`
 /// is returned. `LockError::Io` is returned for any unexpected I/O error
 /// accessing the lock file, including for removing it after `f` was called.
 /// The return value of `f` is dropped in that case. If all is successful, the
 /// return value of `f` is forwarded.
 pub fn try_with_lock_no_wait<R>(
     hg_vfs: Vfs,
     lock_filename: &str,
     f: impl FnOnce() -> R,
 ) -> Result<R, LockError> {
     let our_lock_data = &*OUR_LOCK_DATA;
     for _retry in 0..5 {
         match make_lock(hg_vfs, lock_filename, our_lock_data) {
             Ok(()) => {
                 let result = f();
                 unlock(hg_vfs, lock_filename)?;
                 return Ok(result);
             }
             Err(HgError::IoError { error, .. })
                 if error.kind() == ErrorKind::AlreadyExists =>
             {
                 let lock_data = read_lock(hg_vfs, lock_filename)?;
                 if lock_data.is_none() {
                     // Lock was apparently just released, retry acquiring it
                     continue;
                 }
                 if !lock_should_be_broken(&lock_data) {
                     return Err(LockError::AlreadyHeld);
                 }
                 // The lock file is left over from a process not running
                 // anymore. Break it, but with another lock to
                 // avoid a race.
                 break_lock(hg_vfs, lock_filename)?;
 
                 // Retry acquiring
             }
             Err(error) => Err(error)?,
         }
     }
     Err(LockError::AlreadyHeld)
 }
 
 fn break_lock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), LockError> {
     try_with_lock_no_wait(hg_vfs, &format!("{}.break", lock_filename), || {
         // Check again in case some other process broke and
         // acquired the lock in the meantime
         let lock_data = read_lock(hg_vfs, lock_filename)?;
         if !lock_should_be_broken(&lock_data) {
             return Err(LockError::AlreadyHeld);
         }
         Ok(hg_vfs.remove_file(lock_filename)?)
     })?
 }
 
 #[cfg(unix)]
 fn make_lock(
     hg_vfs: Vfs,
     lock_filename: &str,
     data: &str,
 ) -> Result<(), HgError> {
     // Use a symbolic link because creating it is atomic.
     // The link’s "target" contains data not representing any path.
     let fake_symlink_target = data;
     hg_vfs.create_symlink(lock_filename, fake_symlink_target)
 }
 
 fn read_lock(
     hg_vfs: Vfs,
     lock_filename: &str,
 ) -> Result<Option<String>, HgError> {
     let link_target =
         hg_vfs.read_link(lock_filename).io_not_found_as_none()?;
     if let Some(target) = link_target {
         let data = target
             .into_os_string()
             .into_string()
             .map_err(|_| HgError::corrupted("non-UTF-8 lock data"))?;
         Ok(Some(data))
     } else {
         Ok(None)
     }
 }
 
 fn unlock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), HgError> {
     hg_vfs.remove_file(lock_filename)
 }
 
 /// Return whether the process that is/was holding the lock is known not to be
 /// running anymore.
 fn lock_should_be_broken(data: &Option<String>) -> bool {
     (|| -> Option<bool> {
         let (prefix, pid) = data.as_ref()?.split_2(':')?;
         if prefix != &*LOCK_PREFIX {
             return Some(false);
         }
         let process_is_running;
 
         #[cfg(unix)]
         {
             let pid: libc::pid_t = pid.parse().ok()?;
             unsafe {
                 let signal = 0; // Test if we could send a signal, without sending
                 let result = libc::kill(pid, signal);
                 if result == 0 {
                     process_is_running = true
                 } else {
                     let errno =
                         io::Error::last_os_error().raw_os_error().unwrap();
                     process_is_running = errno != libc::ESRCH
                 }
             }
         }
 
         Some(!process_is_running)
     })()
     .unwrap_or(false)
 }
 
 lazy_static::lazy_static! {
     /// A string which is used to differentiate pid namespaces
     ///
     /// It's useful to detect "dead" processes and remove stale locks with
     /// confidence. Typically it's just hostname. On modern linux, we include an
     /// extra Linux-specific pid namespace identifier.
     static ref LOCK_PREFIX: String = {
         // Note: this must match the behavior of `_getlockprefix` in `mercurial/lock.py`
 
         /// Same as https://github.com/python/cpython/blob/v3.10.0/Modules/socketmodule.c#L5414
         const BUFFER_SIZE: usize = 1024;
-        let mut buffer = [0_i8; BUFFER_SIZE];
+        let mut buffer = [0 as libc::c_char; BUFFER_SIZE];
         let hostname_bytes = unsafe {
             let result = libc::gethostname(buffer.as_mut_ptr(), BUFFER_SIZE);
             if result != 0 {
                 panic!("gethostname: {}", io::Error::last_os_error())
             }
             std::ffi::CStr::from_ptr(buffer.as_mut_ptr()).to_bytes()
         };
         let hostname =
             std::str::from_utf8(hostname_bytes).expect("non-UTF-8 hostname");
 
         #[cfg(target_os = "linux")]
         {
             use std::os::linux::fs::MetadataExt;
             match std::fs::metadata("/proc/self/ns/pid") {
                 Ok(meta) => {
                     return format!("{}/{:x}", hostname, meta.st_ino())
                 }
                 Err(error) => {
                     // TODO: match on `error.kind()` when `NotADirectory`
                     // is available on all supported Rust versions:
                     // https://github.com/rust-lang/rust/issues/86442
                     use libc::{
                         ENOENT, // ErrorKind::NotFound
                         ENOTDIR, // ErrorKind::NotADirectory
                         EACCES, // ErrorKind::PermissionDenied
                     };
                     match error.raw_os_error() {
                         Some(ENOENT) | Some(ENOTDIR) | Some(EACCES) => {}
                         _ => panic!("stat /proc/self/ns/pid: {}", error),
                     }
                 }
             }
         }
 
         hostname.to_owned()
     };
 
     static ref OUR_LOCK_DATA: String = format!("{}:{}", &*LOCK_PREFIX, std::process::id());
 }