Function to check how much stack is available

geebee22 · October 8, 2021, 12:20pm

If there any way to find out how much stack is available (unallocated)?

I want to use this to avoid a "hard" stack overflow.

cuviper · October 8, 2021, 4:53pm

It is OS-specific -- you can see how std does it on unix targets here:

rust-lang/rust/blob/5641481ad735c742cc669bb1e47f10116b789ee7/library/std/src/sys/unix/thread.rs#L441

    
      
              Some(stackaddr as *mut libc::c_void)
          }
          
          
#[cfg(any(
              target_os = "android",
              target_os = "freebsd",
              target_os = "linux",
              target_os = "netbsd",
              target_os = "l4re"
          ))]
          unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
              let mut ret = None;
              let mut attr: libc::pthread_attr_t = crate::mem::zeroed();
              #[cfg(target_os = "freebsd")]
              assert_eq!(libc::pthread_attr_init(&mut attr), 0);
              #[cfg(target_os = "freebsd")]
              let e = libc::pthread_attr_get_np(libc::pthread_self(), &mut attr);
              #[cfg(not(target_os = "freebsd"))]
              let e = libc::pthread_getattr_np(libc::pthread_self(), &mut attr);
              if e == 0 {
                  let mut stackaddr = crate::ptr::null_mut();

But even that is often inaccurate for the main thread, which may dynamically grow stack:

github.com

rust-lang/rust/blob/5641481ad735c742cc669bb1e47f10116b789ee7/library/std/src/sys/unix/thread.rs#L482

    
      
              // page-aligned, calculate the fix such that stackaddr <
              // new_page_aligned_stackaddr < stackaddr + stacksize
              let remainder = (stackaddr as usize) % page_size;
              Some(if remainder == 0 {
                  stackaddr
              } else {
                  ((stackaddr as usize) + page_size - remainder) as *mut libc::c_void
              })
          }
          
          
pub unsafe fn init() -> Option<Guard> {
              let page_size = os::page_size();
              PAGE_SIZE.store(page_size, Ordering::Relaxed);
          
          
    if cfg!(all(target_os = "linux", not(target_env = "musl"))) {
                  // Linux doesn't allocate the whole stack right away, and
                  // the kernel has its own stack-guard mechanism to fault
                  // when growing too close to an existing mapping.  If we map
                  // our own guard, then the kernel starts enforcing a rather
                  // large gap above that, rendering much of the possible
                  // stack space useless.  See #43052.

cole-miller · October 8, 2021, 4:55pm

I've no experience using it myself but maybe the stacker crate would be useful here? (It's owned and maintained by the Rust compiler team.)

(Not to be confused with stakker.)

geebee22 · October 8, 2021, 5:32pm

Thanks, that seems to be working perfectly for me.

system · January 6, 2022, 5:32pm

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.