anyhow/
backtrace.rs

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

anyhow/
backtrace.rs
