1 | //! Support for "weak linkage" to symbols on Unix |
2 | //! |
3 | //! Some I/O operations we do in std require newer versions of OSes but we need |
4 | //! to maintain binary compatibility with older releases for now. In order to |
5 | //! use the new functionality when available we use this module for detection. |
6 | //! |
7 | //! One option to use here is weak linkage, but that is unfortunately only |
8 | //! really workable with ELF. Otherwise, use dlsym to get the symbol value at |
9 | //! runtime. This is also done for compatibility with older versions of glibc, |
10 | //! and to avoid creating dependencies on GLIBC_PRIVATE symbols. It assumes that |
11 | //! we've been dynamically linked to the library the symbol comes from, but that |
12 | //! is currently always the case for things like libpthread/libc. |
13 | //! |
14 | //! A long time ago this used weak linkage for the __pthread_get_minstack |
15 | //! symbol, but that caused Debian to detect an unnecessarily strict versioned |
16 | //! dependency on libc6 (#23628) because it is GLIBC_PRIVATE. We now use `dlsym` |
17 | //! for a runtime lookup of that symbol to avoid the ELF versioned dependency. |
18 | |
19 | // There are a variety of `#[cfg]`s controlling which targets are involved in |
20 | // each instance of `weak!` and `syscall!`. Rather than trying to unify all of |
21 | // that, we'll just allow that some unix targets don't use this module at all. |
22 | #![allow (dead_code, unused_macros)] |
23 | |
24 | use crate::ffi::CStr; |
25 | use crate::marker::PhantomData; |
26 | use crate::sync::atomic::{self, AtomicPtr, Ordering}; |
27 | use crate::{mem, ptr}; |
28 | |
29 | // We can use true weak linkage on ELF targets. |
30 | #[cfg (all(unix, not(target_vendor = "apple" )))] |
31 | pub(crate) macro weak { |
32 | (fn $name:ident($($t:ty),*) -> $ret:ty) => ( |
33 | let ref $name: ExternWeak<unsafe extern "C" fn($($t),*) -> $ret> = { |
34 | unsafe extern "C" { |
35 | #[linkage = "extern_weak" ] |
36 | static $name: Option<unsafe extern "C" fn($($t),*) -> $ret>; |
37 | } |
38 | #[allow(unused_unsafe)] |
39 | ExternWeak::new(unsafe { $name }) |
40 | }; |
41 | ) |
42 | } |
43 | |
44 | // On non-ELF targets, use the dlsym approximation of weak linkage. |
45 | #[cfg (target_vendor = "apple" )] |
46 | pub(crate) use self::dlsym as weak; |
47 | |
48 | pub(crate) struct ExternWeak<F: Copy> { |
49 | weak_ptr: Option<F>, |
50 | } |
51 | |
52 | impl<F: Copy> ExternWeak<F> { |
53 | #[inline ] |
54 | pub(crate) fn new(weak_ptr: Option<F>) -> Self { |
55 | ExternWeak { weak_ptr } |
56 | } |
57 | |
58 | #[inline ] |
59 | pub(crate) fn get(&self) -> Option<F> { |
60 | self.weak_ptr |
61 | } |
62 | } |
63 | |
64 | pub(crate) macro dlsym { |
65 | (fn $name:ident($($t:ty),*) -> $ret:ty) => ( |
66 | dlsym!(fn $name($($t),*) -> $ret, stringify!($name)); |
67 | ), |
68 | (fn $name:ident($($t:ty),*) -> $ret:ty, $sym:expr) => ( |
69 | static DLSYM: DlsymWeak<unsafe extern "C" fn($($t),*) -> $ret> = |
70 | DlsymWeak::new(concat!($sym, ' \0' )); |
71 | let $name = &DLSYM; |
72 | ) |
73 | } |
74 | pub(crate) struct DlsymWeak<F> { |
75 | name: &'static str, |
76 | func: AtomicPtr<libc::c_void>, |
77 | _marker: PhantomData<F>, |
78 | } |
79 | |
80 | impl<F> DlsymWeak<F> { |
81 | pub(crate) const fn new(name: &'static str) -> Self { |
82 | DlsymWeak { |
83 | name, |
84 | func: AtomicPtr::new(ptr::without_provenance_mut(1)), |
85 | _marker: PhantomData, |
86 | } |
87 | } |
88 | |
89 | #[inline ] |
90 | pub(crate) fn get(&self) -> Option<F> { |
91 | unsafe { |
92 | // Relaxed is fine here because we fence before reading through the |
93 | // pointer (see the comment below). |
94 | match self.func.load(Ordering::Relaxed) { |
95 | func if func.addr() == 1 => self.initialize(), |
96 | func if func.is_null() => None, |
97 | func => { |
98 | let func = mem::transmute_copy::<*mut libc::c_void, F>(&func); |
99 | // The caller is presumably going to read through this value |
100 | // (by calling the function we've dlsymed). This means we'd |
101 | // need to have loaded it with at least C11's consume |
102 | // ordering in order to be guaranteed that the data we read |
103 | // from the pointer isn't from before the pointer was |
104 | // stored. Rust has no equivalent to memory_order_consume, |
105 | // so we use an acquire fence (sorry, ARM). |
106 | // |
107 | // Now, in practice this likely isn't needed even on CPUs |
108 | // where relaxed and consume mean different things. The |
109 | // symbols we're loading are probably present (or not) at |
110 | // init, and even if they aren't the runtime dynamic loader |
111 | // is extremely likely have sufficient barriers internally |
112 | // (possibly implicitly, for example the ones provided by |
113 | // invoking `mprotect`). |
114 | // |
115 | // That said, none of that's *guaranteed*, and so we fence. |
116 | atomic::fence(Ordering::Acquire); |
117 | Some(func) |
118 | } |
119 | } |
120 | } |
121 | } |
122 | |
123 | // Cold because it should only happen during first-time initialization. |
124 | #[cold ] |
125 | unsafe fn initialize(&self) -> Option<F> { |
126 | assert_eq!(size_of::<F>(), size_of::<*mut libc::c_void>()); |
127 | |
128 | let val = fetch(self.name); |
129 | // This synchronizes with the acquire fence in `get`. |
130 | self.func.store(val, Ordering::Release); |
131 | |
132 | if val.is_null() { None } else { Some(mem::transmute_copy::<*mut libc::c_void, F>(&val)) } |
133 | } |
134 | } |
135 | |
136 | unsafe fn fetch(name: &str) -> *mut libc::c_void { |
137 | let name: &CStr = match CStr::from_bytes_with_nul(name.as_bytes()) { |
138 | Ok(cstr: &CStr) => cstr, |
139 | Err(..) => return ptr::null_mut(), |
140 | }; |
141 | libc::dlsym(handle:libc::RTLD_DEFAULT, symbol:name.as_ptr()) |
142 | } |
143 | |
144 | #[cfg (not(any(target_os = "linux" , target_os = "android" )))] |
145 | pub(crate) macro syscall { |
146 | (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( |
147 | // FIXME(#115199): Rust currently omits weak function definitions |
148 | // and its metadata from LLVM IR. |
149 | #[no_sanitize(cfi)] |
150 | unsafe fn $name($($arg_name: $t),*) -> $ret { |
151 | weak! { fn $name($($t),*) -> $ret } |
152 | |
153 | if let Some(fun) = $name.get() { |
154 | fun($($arg_name),*) |
155 | } else { |
156 | super::os::set_errno(libc::ENOSYS); |
157 | -1 |
158 | } |
159 | } |
160 | ) |
161 | } |
162 | |
163 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
164 | pub(crate) macro syscall { |
165 | (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( |
166 | unsafe fn $name($($arg_name:$t),*) -> $ret { |
167 | weak! { fn $name($($t),*) -> $ret } |
168 | |
169 | // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` |
170 | // interposition, but if it's not found just use a raw syscall. |
171 | if let Some(fun) = $name.get() { |
172 | fun($($arg_name),*) |
173 | } else { |
174 | libc::syscall(libc::${concat(SYS_, $name)}, $($arg_name),*) as $ret |
175 | } |
176 | } |
177 | ) |
178 | } |
179 | |
180 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
181 | pub(crate) macro raw_syscall { |
182 | (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( |
183 | unsafe fn $name($($arg_name:$t),*) -> $ret { |
184 | libc::syscall(libc::${concat(SYS_, $name)}, $($arg_name),*) as $ret |
185 | } |
186 | ) |
187 | } |
188 | |