# pthread_attr_getstack

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           pthread_attr_getstack, pthread_attr_setstack — get and set stack
           attributes
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_attr_getstack(const pthread_attr_t *restrict _attr_ ,
               void **restrict _stackaddr_ , size_t *restrict _stacksize_);
           int pthread_attr_setstack(pthread_attr_t *_attr_ , void *_stackaddr_ ,
               size_t _stacksize_);
    


## DESCRIPTION



           The _pthread_attr_getstack_() and _pthread_attr_setstack_() functions,
           respectively, shall get and set the thread creation stack
           attributes _stackaddr_ and _stacksize_ in the _attr_ object.
    
           The stack attributes specify the area of storage to be used for
           the created thread's stack. The base (lowest addressable byte) of
           the storage shall be _stackaddr_ , and the size of the storage shall
           be _stacksize_ bytes. The _stacksize_ shall be at least
           {PTHREAD_STACK_MIN}.  The _pthread_attr_setstack_() function may
           fail with **[EINVAL]** if _stackaddr_ does not meet implementation-
           defined alignment requirements.  All pages within the stack
           described by _stackaddr_ and _stacksize_ shall be both readable and
           writable by the thread.
    
           If the _pthread_attr_getstack_() function is called before the
           _stackaddr_ attribute has been set, the behavior is unspecified.
    
           The behavior is undefined if the value specified by the _attr_
           argument to _pthread_attr_getstack_() or _pthread_attr_setstack_()
           does not refer to an initialized thread attributes object.
    


## RETURN VALUE



           Upon successful completion, these functions shall return a value
           of 0; otherwise, an error number shall be returned to indicate the
           error.
    
           The _pthread_attr_getstack_() function shall store the stack
           attribute values in _stackaddr_ and _stacksize_ if successful.
    


## ERRORS



           The _pthread_attr_setstack_() function shall fail if:
    
           **EINVAL** The value of _stacksize_ is less than {PTHREAD_STACK_MIN} or
                  exceeds an implementation-defined limit.
    
           The _pthread_attr_setstack_() function may fail if:
    
           **EINVAL** The value of _stackaddr_ does not have proper alignment to be
                  used as a stack, or ((**char ***)_stackaddr_ + _stacksize_) lacks
                  proper alignment.
    
           **EACCES** The stack page(s) described by _stackaddr_ and _stacksize_ are
                  not both readable and writable by the thread.
    
           These functions shall not return an error code of **[EINTR]**.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           These functions are appropriate for use by applications in an
           environment where the stack for a thread must be placed in some
           particular region of memory.
    
           While it might seem that an application could detect stack
           overflow by providing a protected page outside the specified stack
           region, this cannot be done portably. Implementations are free to
           place the thread's initial stack pointer anywhere within the
           specified region to accommodate the machine's stack pointer
           behavior and allocation requirements. Furthermore, on some
           architectures, such as the IA‐64, ``overflow'' might mean that two
           separate stack pointers allocated within the region will overlap
           somewhere in the middle of the region.
    
           After a successful call to _pthread_attr_setstack_(), the storage
           area specified by the _stackaddr_ parameter is under the control of
           the implementation, as described in _Section 2.9.8_ , _Use of_
           _Application-Managed Thread Stacks_.
    
           The specification of the _stackaddr_ attribute presents several
           ambiguities that make portable use of these functions impossible.
           For example, the standard allows implementations to impose
           arbitrary alignment requirements on _stackaddr_.  Applications
           cannot assume that a buffer obtained from _malloc_() is suitably
           aligned. Note that although the _stacksize_ value passed to
           _pthread_attr_setstack_() must satisfy alignment requirements, the
           same is not true for _pthread_attr_setstacksize_() where the
           implementation must increase the specified size if necessary to
           achieve the proper alignment.
    


## RATIONALE



           If an implementation detects that the value specified by the _attr_
           argument to _pthread_attr_getstack_() or _pthread_attr_setstack_()
           does not refer to an initialized thread attributes object, it is
           recommended that the function should fail and report an **[EINVAL]**
           error.
    


## FUTURE DIRECTIONS



           None.
    


* * *