weak.rs.html -- source
Description: Source to the Rust file `src/libstd/sys/unix/weak.rs`.
Keywords: rust, rustlang, rust-lang

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100

    //! Support for "weak linkage" to symbols on Unix
    //!
    //! Some I/O operations we do in libstd require newer versions of OSes but we
    //! need to maintain binary compatibility with older releases for now. In order
    //! to use the new functionality when available we use this module for
    //! detection.
    //!
    //! One option to use here is weak linkage, but that is unfortunately only
    //! really workable on Linux. Hence, use dlsym to get the symbol value at
    //! runtime. This is also done for compatibility with older versions of glibc,
    //! and to avoid creating dependencies on GLIBC_PRIVATE symbols. It assumes that
    //! we've been dynamically linked to the library the symbol comes from, but that
    //! is currently always the case for things like libpthread/libc.
    //!
    //! A long time ago this used weak linkage for the __pthread_get_minstack
    //! symbol, but that caused Debian to detect an unnecessarily strict versioned
    //! dependency on libc6 (#23628).

    use crate::ffi::CStr;
    use crate::marker;
    use crate::mem;
    use crate::sync::atomic::{AtomicUsize, Ordering};

    macro_rules! weak {
        (fn $name:ident($($t:ty),*) -> $ret:ty) => (
            static $name: crate::sys::weak::Weak<unsafe extern fn($($t),*) -> $ret> =
                crate::sys::weak::Weak::new(concat!(stringify!($name), '\0'));
        )
    }

    pub struct Weak<F> {
        name: &'static str,
        addr: AtomicUsize,
        _marker: marker::PhantomData<F>,
    }

    impl<F> Weak<F> {
        pub const fn new(name: &'static str) -> Weak<F> {
            Weak {
                name,
                addr: AtomicUsize::new(1),
                _marker: marker::PhantomData,
            }
        }

        pub fn get(&self) -> Option<F> {
            assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>());
            unsafe {
                if self.addr.load(Ordering::SeqCst) == 1 {
                    self.addr.store(fetch(self.name), Ordering::SeqCst);
                }
                match self.addr.load(Ordering::SeqCst) {
                    0 => None,
                    addr => Some(mem::transmute_copy::<usize, F>(&addr)),
                }
            }
        }
    }

    unsafe fn fetch(name: &str) -> usize {
        let name = match CStr::from_bytes_with_nul(name.as_bytes()) {
            Ok(cstr) => cstr,
            Err(..) => return 0,
        };
        libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) as usize
    }

    #[cfg(not(target_os = "linux"))]
    macro_rules! syscall {
        (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
            unsafe fn $name($($arg_name: $t),*) -> $ret {
                use super::os;

                weak! { fn $name($($t),*) -> $ret }

                if let Some(fun) = $name.get() {
                    fun($($arg_name),*)
                } else {
                    os::set_errno(libc::ENOSYS);
                    -1
                }
            }
        )
    }

    #[cfg(target_os = "linux")]
    macro_rules! syscall {
        (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
            unsafe fn $name($($arg_name:$t),*) -> $ret {
                // This looks like a hack, but concat_idents only accepts idents
                // (not paths).
                use libc::*;

                syscall(
                    concat_idents!(SYS_, $name),
                    $($arg_name as c_long),*
                ) as $ret
            }
        )
    }