anyhow/
backtrace.rs

1#[cfg(std_backtrace)]
2pub(crate) use std::backtrace::{Backtrace, BacktraceStatus};
3
4#[cfg(all(not(std_backtrace), feature = "backtrace"))]
5pub(crate) use self::capture::{Backtrace, BacktraceStatus};
6
7#[cfg(not(any(std_backtrace, feature = "backtrace")))]
8pub(crate) enum Backtrace {}
9
10#[cfg(std_backtrace)]
11macro_rules! impl_backtrace {
12    () => {
13        std::backtrace::Backtrace
14    };
15}
16
17#[cfg(all(not(std_backtrace), feature = "backtrace"))]
18macro_rules! impl_backtrace {
19    () => {
20        impl core::fmt::Debug + core::fmt::Display
21    };
22}
23
24#[cfg(any(std_backtrace, feature = "backtrace"))]
25macro_rules! backtrace {
26    () => {
27        Some(crate::backtrace::Backtrace::capture())
28    };
29}
30
31#[cfg(not(any(std_backtrace, feature = "backtrace")))]
32macro_rules! backtrace {
33    () => {
34        None
35    };
36}
37
38#[cfg(error_generic_member_access)]
39macro_rules! backtrace_if_absent {
40    ($err:expr) => {
41        match core::error::request_ref::<std::backtrace::Backtrace>($err as &dyn core::error::Error)
42        {
43            Some(_) => None,
44            None => backtrace!(),
45        }
46    };
47}
48
49#[cfg(all(
50    any(feature = "std", not(anyhow_no_core_error)),
51    not(error_generic_member_access),
52    any(std_backtrace, feature = "backtrace")
53))]
54macro_rules! backtrace_if_absent {
55    ($err:expr) => {
56        backtrace!()
57    };
58}
59
60#[cfg(all(
61    any(feature = "std", not(anyhow_no_core_error)),
62    not(std_backtrace),
63    not(feature = "backtrace"),
64))]
65macro_rules! backtrace_if_absent {
66    ($err:expr) => {
67        None
68    };
69}
70
71#[cfg(all(not(std_backtrace), feature = "backtrace"))]
72mod capture {
73    use alloc::borrow::{Cow, ToOwned as _};
74    use alloc::vec::Vec;
75    use backtrace::{BacktraceFmt, BytesOrWideString, Frame, PrintFmt, SymbolName};
76    use core::cell::UnsafeCell;
77    use core::fmt::{self, Debug, Display};
78    use core::sync::atomic::{AtomicUsize, Ordering};
79    use std::env;
80    use std::path::{self, Path, PathBuf};
81    use std::sync::Once;
82
83    pub(crate) struct Backtrace {
84        inner: Inner,
85    }
86
87    pub(crate) enum BacktraceStatus {
88        Unsupported,
89        Disabled,
90        Captured,
91    }
92
93    enum Inner {
94        Unsupported,
95        Disabled,
96        Captured(LazilyResolvedCapture),
97    }
98
99    struct Capture {
100        actual_start: usize,
101        resolved: bool,
102        frames: Vec<BacktraceFrame>,
103    }
104
105    struct BacktraceFrame {
106        frame: Frame,
107        symbols: Vec<BacktraceSymbol>,
108    }
109
110    struct BacktraceSymbol {
111        name: Option<Vec<u8>>,
112        filename: Option<BytesOrWide>,
113        lineno: Option<u32>,
114        colno: Option<u32>,
115    }
116
117    enum BytesOrWide {
118        Bytes(Vec<u8>),
119        Wide(Vec<u16>),
120    }
121
122    impl Debug for Backtrace {
123        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
124            let capture = match &self.inner {
125                Inner::Unsupported => return fmt.write_str("<unsupported>"),
126                Inner::Disabled => return fmt.write_str("<disabled>"),
127                Inner::Captured(c) => c.force(),
128            };
129
130            let frames = &capture.frames[capture.actual_start..];
131
132            write!(fmt, "Backtrace ")?;
133
134            let mut dbg = fmt.debug_list();
135
136            for frame in frames {
137                if frame.frame.ip().is_null() {
138                    continue;
139                }
140
141                dbg.entries(&frame.symbols);
142            }
143
144            dbg.finish()
145        }
146    }
147
148    impl Debug for BacktraceFrame {
149        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
150            let mut dbg = fmt.debug_list();
151            dbg.entries(&self.symbols);
152            dbg.finish()
153        }
154    }
155
156    impl Debug for BacktraceSymbol {
157        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
158            write!(fmt, "{{ ")?;
159
160            if let Some(fn_name) = self.name.as_ref().map(|b| SymbolName::new(b)) {
161                write!(fmt, "fn: \"{:#}\"", fn_name)?;
162            } else {
163                write!(fmt, "fn: <unknown>")?;
164            }
165
166            if let Some(fname) = self.filename.as_ref() {
167                write!(fmt, ", file: \"{:?}\"", fname)?;
168            }
169
170            if let Some(line) = self.lineno {
171                write!(fmt, ", line: {:?}", line)?;
172            }
173
174            write!(fmt, " }}")
175        }
176    }
177
178    impl Debug for BytesOrWide {
179        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
180            output_filename(
181                fmt,
182                match self {
183                    BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
184                    BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
185                },
186                PrintFmt::Short,
187                env::current_dir().as_ref().ok(),
188            )
189        }
190    }
191
192    impl Backtrace {
193        fn enabled() -> bool {
194            static ENABLED: AtomicUsize = AtomicUsize::new(0);
195            match ENABLED.load(Ordering::Relaxed) {
196                0 => {}
197                1 => return false,
198                _ => return true,
199            }
200            let enabled = match env::var_os("RUST_LIB_BACKTRACE") {
201                Some(s) => s != "0",
202                None => match env::var_os("RUST_BACKTRACE") {
203                    Some(s) => s != "0",
204                    None => false,
205                },
206            };
207            ENABLED.store(enabled as usize + 1, Ordering::Relaxed);
208            enabled
209        }
210
211        #[inline(never)] // want to make sure there's a frame here to remove
212        pub(crate) fn capture() -> Backtrace {
213            if Backtrace::enabled() {
214                Backtrace::create(Backtrace::capture as usize)
215            } else {
216                let inner = Inner::Disabled;
217                Backtrace { inner }
218            }
219        }
220
221        // Capture a backtrace which starts just before the function addressed
222        // by `ip`
223        fn create(ip: usize) -> Backtrace {
224            let mut frames = Vec::new();
225            let mut actual_start = None;
226            backtrace::trace(|frame| {
227                frames.push(BacktraceFrame {
228                    frame: frame.clone(),
229                    symbols: Vec::new(),
230                });
231                if frame.symbol_address() as usize == ip && actual_start.is_none() {
232                    actual_start = Some(frames.len() + 1);
233                }
234                true
235            });
236
237            // If no frames came out assume that this is an unsupported platform
238            // since `backtrace` doesn't provide a way of learning this right
239            // now, and this should be a good enough approximation.
240            let inner = if frames.is_empty() {
241                Inner::Unsupported
242            } else {
243                Inner::Captured(LazilyResolvedCapture::new(Capture {
244                    actual_start: actual_start.unwrap_or(0),
245                    frames,
246                    resolved: false,
247                }))
248            };
249
250            Backtrace { inner }
251        }
252
253        pub(crate) fn status(&self) -> BacktraceStatus {
254            match self.inner {
255                Inner::Unsupported => BacktraceStatus::Unsupported,
256                Inner::Disabled => BacktraceStatus::Disabled,
257                Inner::Captured(_) => BacktraceStatus::Captured,
258            }
259        }
260    }
261
262    impl Display for Backtrace {
263        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
264            let capture = match &self.inner {
265                Inner::Unsupported => return fmt.write_str("unsupported backtrace"),
266                Inner::Disabled => return fmt.write_str("disabled backtrace"),
267                Inner::Captured(c) => c.force(),
268            };
269
270            let full = fmt.alternate();
271            let (frames, style) = if full {
272                (&capture.frames[..], PrintFmt::Full)
273            } else {
274                (&capture.frames[capture.actual_start..], PrintFmt::Short)
275            };
276
277            // When printing paths we try to strip the cwd if it exists,
278            // otherwise we just print the path as-is. Note that we also only do
279            // this for the short format, because if it's full we presumably
280            // want to print everything.
281            let cwd = env::current_dir();
282            let mut print_path = move |fmt: &mut fmt::Formatter, path: BytesOrWideString| {
283                output_filename(fmt, path, style, cwd.as_ref().ok())
284            };
285
286            let mut f = BacktraceFmt::new(fmt, style, &mut print_path);
287            f.add_context()?;
288            for frame in frames {
289                let mut f = f.frame();
290                if frame.symbols.is_empty() {
291                    f.print_raw(frame.frame.ip(), None, None, None)?;
292                } else {
293                    for symbol in frame.symbols.iter() {
294                        f.print_raw_with_column(
295                            frame.frame.ip(),
296                            symbol.name.as_ref().map(|b| SymbolName::new(b)),
297                            symbol.filename.as_ref().map(|b| match b {
298                                BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
299                                BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
300                            }),
301                            symbol.lineno,
302                            symbol.colno,
303                        )?;
304                    }
305                }
306            }
307            f.finish()?;
308            Ok(())
309        }
310    }
311
312    struct LazilyResolvedCapture {
313        sync: Once,
314        capture: UnsafeCell<Capture>,
315    }
316
317    impl LazilyResolvedCapture {
318        fn new(capture: Capture) -> Self {
319            LazilyResolvedCapture {
320                sync: Once::new(),
321                capture: UnsafeCell::new(capture),
322            }
323        }
324
325        fn force(&self) -> &Capture {
326            self.sync.call_once(|| {
327                // Safety: This exclusive reference can't overlap with any
328                // others. `Once` guarantees callers will block until this
329                // closure returns. `Once` also guarantees only a single caller
330                // will enter this closure.
331                unsafe { &mut *self.capture.get() }.resolve();
332            });
333
334            // Safety: This shared reference can't overlap with the exclusive
335            // reference above.
336            unsafe { &*self.capture.get() }
337        }
338    }
339
340    // Safety: Access to the inner value is synchronized using a thread-safe
341    // `Once`. So long as `Capture` is `Sync`, `LazilyResolvedCapture` is too
342    unsafe impl Sync for LazilyResolvedCapture where Capture: Sync {}
343
344    impl Capture {
345        fn resolve(&mut self) {
346            // If we're already resolved, nothing to do!
347            if self.resolved {
348                return;
349            }
350            self.resolved = true;
351
352            for frame in self.frames.iter_mut() {
353                let symbols = &mut frame.symbols;
354                let frame = &frame.frame;
355                backtrace::resolve_frame(frame, |symbol| {
356                    symbols.push(BacktraceSymbol {
357                        name: symbol.name().map(|m| m.as_bytes().to_vec()),
358                        filename: symbol.filename_raw().map(|b| match b {
359                            BytesOrWideString::Bytes(b) => BytesOrWide::Bytes(b.to_owned()),
360                            BytesOrWideString::Wide(b) => BytesOrWide::Wide(b.to_owned()),
361                        }),
362                        lineno: symbol.lineno(),
363                        colno: symbol.colno(),
364                    });
365                });
366            }
367        }
368    }
369
370    // Prints the filename of the backtrace frame.
371    fn output_filename(
372        fmt: &mut fmt::Formatter,
373        bows: BytesOrWideString,
374        print_fmt: PrintFmt,
375        cwd: Option<&PathBuf>,
376    ) -> fmt::Result {
377        let file: Cow<Path> = match bows {
378            #[cfg(unix)]
379            BytesOrWideString::Bytes(bytes) => {
380                use std::os::unix::ffi::OsStrExt;
381                Path::new(std::ffi::OsStr::from_bytes(bytes)).into()
382            }
383            #[cfg(not(unix))]
384            BytesOrWideString::Bytes(bytes) => {
385                Path::new(std::str::from_utf8(bytes).unwrap_or("<unknown>")).into()
386            }
387            #[cfg(windows)]
388            BytesOrWideString::Wide(wide) => {
389                use std::os::windows::ffi::OsStringExt;
390                Cow::Owned(std::ffi::OsString::from_wide(wide).into())
391            }
392            #[cfg(not(windows))]
393            BytesOrWideString::Wide(_wide) => Path::new("<unknown>").into(),
394        };
395        if print_fmt == PrintFmt::Short && file.is_absolute() {
396            if let Some(cwd) = cwd {
397                if let Ok(stripped) = file.strip_prefix(&cwd) {
398                    if let Some(s) = stripped.to_str() {
399                        return write!(fmt, ".{}{}", path::MAIN_SEPARATOR, s);
400                    }
401                }
402            }
403        }
404        Display::fmt(&file.display(), fmt)
405    }
406}
407
408fn _assert_send_sync() {
409    fn assert<T: Send + Sync>() {}
410    assert::<Backtrace>();
411}
anyhow/backtrace.rs

anyhow/
backtrace.rs
