1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 //! The `rt` module provides a narrow set of runtime services,
14 //! including the global heap (exported in `heap`) and unwinding and
15 //! backtrace support. The APIs in this module are highly unstable,
16 //! and should be considered as private implementation details for the
21 // FIXME: this should not be here.
22 #![allow(missing_docs)]
31 // Reexport some of our utilities which are expected by other crates.
32 pub use self::util::{default_sched_threads, min_stack, running_on_valgrind};
33 pub use self::unwind::{begin_unwind, begin_unwind_fmt};
35 // Reexport some functionality from liballoc.
38 // Simple backtrace functionality (to print on panic)
44 // These should be refactored/moved/made private over time
52 /// The default error code of the rust runtime if the main thread panics instead
53 /// of exiting cleanly.
54 pub const DEFAULT_ERROR_CODE: int = 101;
56 #[cfg(any(windows, android))]
57 const OS_DEFAULT_STACK_ESTIMATE: uint = 1 << 20;
58 #[cfg(all(unix, not(android)))]
59 const OS_DEFAULT_STACK_ESTIMATE: uint = 2 * (1 << 20);
63 fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int {
69 use sys_common::thread_info::{self, NewThread};
73 let something_around_the_top_of_the_stack = 1;
74 let addr = &something_around_the_top_of_the_stack as *const int;
75 let my_stack_top = addr as uint;
77 // FIXME #11359 we just assume that this thread has a stack of a
78 // certain size, and estimate that there's at most 20KB of stack
79 // frames above our current position.
80 let my_stack_bottom = my_stack_top + 20000 - OS_DEFAULT_STACK_ESTIMATE;
83 // First, make sure we don't trigger any __morestack overflow checks,
84 // and next set up our stack to have a guard page and run through our
85 // own fault handlers if we hit it.
86 sys_common::stack::record_os_managed_stack_bounds(my_stack_bottom,
88 sys::thread::guard::init();
89 sys::stack_overflow::init();
91 // Next, set up the current Thread with the guard information we just
92 // created. Note that this isn't necessary in general for new threads,
93 // but we just do this to name the main thread and to give it correct
94 // info about the stack bounds.
95 let thread: Thread = NewThread::new(Some("<main>".to_string()));
96 thread_info::set((my_stack_bottom, my_stack_top),
97 sys::thread::guard::main(),
100 // By default, some platforms will send a *signal* when a EPIPE error
101 // would otherwise be delivered. This runtime doesn't install a SIGPIPE
102 // handler, causing it to kill the program, which isn't exactly what we
105 // Hence, we set SIGPIPE to ignore when the program starts up in order
106 // to prevent this problem.
107 #[cfg(windows)] fn ignore_sigpipe() {}
108 #[cfg(unix)] fn ignore_sigpipe() {
110 use libc::funcs::posix01::signal::signal;
112 assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != -1);
117 // Store our args if necessary in a squirreled away location
118 args::init(argc, argv);
120 // And finally, let's run some code!
121 let res = unwind::try(|| {
122 let main: fn() = mem::transmute(main);
129 // If the exit code wasn't set, then the try block must have panicked.
131 rt::DEFAULT_ERROR_CODE
133 os::get_exit_status()
137 /// Enqueues a procedure to run when the runtime is cleaned up
139 /// The procedure passed to this function will be executed as part of the
140 /// runtime cleanup phase. For normal rust programs, this means that it will run
141 /// after all other threads have exited.
143 /// The procedure is *not* executed with a local `Thread` available to it, so
144 /// primitives like logging, I/O, channels, spawning, etc, are *not* available.
145 /// This is meant for "bare bones" usage to clean up runtime details, this is
146 /// not meant as a general-purpose "let's clean everything up" function.
148 /// It is forbidden for procedures to register more `at_exit` handlers when they
149 /// are running, and doing so will lead to a process abort.
150 pub fn at_exit<F:FnOnce()+Send>(f: F) {
151 at_exit_imp::push(Thunk::new(f));
154 /// One-time runtime cleanup.
156 /// This function is unsafe because it performs no checks to ensure that the
157 /// runtime has completely ceased running. It is the responsibility of the
158 /// caller to ensure that the runtime is entirely shut down and nothing will be
159 /// poking around at the internal components.
161 /// Invoking cleanup while portions of the runtime are still in use may cause
162 /// undefined behavior.
163 pub unsafe fn cleanup() {
165 sys::stack_overflow::cleanup();
166 // FIXME: (#20012): the resources being cleaned up by at_exit
167 // currently are not prepared for cleanup to happen asynchronously
168 // with detached threads using the resources; for now, we leak.
169 // at_exit_imp::cleanup();