Stack APIs

Macros
#define	K_STACK_DEFINE(name, stack_num_entries)
	Statically define and initialize a stack.

Functions
void	k_stack_init (struct k_stack *stack, stack_data_t *buffer, uint32_t num_entries)
	Initialize a stack.
int32_t	k_stack_alloc_init (struct k_stack *stack, uint32_t num_entries)
	Initialize a stack.
int	k_stack_cleanup (struct k_stack *stack)
	Release a stack's allocated buffer.
int	k_stack_push (struct k_stack *stack, stack_data_t data)
	Push an element onto a stack.
int	k_stack_pop (struct k_stack *stack, stack_data_t *data, k_timeout_t timeout)
	Pop an element from a stack.

Detailed Description

Macro Definition Documentation

K_STACK_DEFINE

#define K_STACK_DEFINE	(		name,
			stack_num_entries
	)

#include <zephyr/kernel.h>

Value:

        stack_data_t __noinit                                  \
                _k_stack_buf_##name[stack_num_entries];        \
        STRUCT_SECTION_ITERABLE(k_stack, name) =               \
                Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
                                    stack_num_entries)

Statically define and initialize a stack.

The stack can be accessed outside the module where it is defined using:

extern struct k_stack <name>; 

Parameters

name	Name of the stack.
stack_num_entries	Maximum number of values that can be stacked.

Function Documentation

k_stack_alloc_init()

int32_t k_stack_alloc_init	(	struct k_stack *	stack,
		uint32_t	num_entries
	)

#include <zephyr/kernel.h>

Initialize a stack.

This routine initializes a stack object, prior to its first use. Internal buffers will be allocated from the calling thread's resource pool. This memory will be released if k_stack_cleanup() is called, or userspace is enabled and the stack object loses all references to it.

Parameters

stack	Address of the stack.
num_entries	Maximum number of values that can be stacked.

Returns

-ENOMEM if memory couldn't be allocated

k_stack_cleanup()

int k_stack_cleanup

(

struct k_stack *

stack

)

#include <zephyr/kernel.h>

Release a stack's allocated buffer.

If a stack object was given a dynamically allocated buffer via k_stack_alloc_init(), this will free it. This function does nothing if the buffer wasn't dynamically allocated.

Parameters

stack

Address of the stack.

Return values

0	on success
-EAGAIN	when object is still in use

k_stack_init()

void k_stack_init	(	struct k_stack *	stack,
		stack_data_t *	buffer,
		uint32_t	num_entries
	)

#include <zephyr/kernel.h>

Initialize a stack.

This routine initializes a stack object, prior to its first use.

Parameters

stack	Address of the stack.
buffer	Address of array used to hold stacked values.
num_entries	Maximum number of values that can be stacked.

k_stack_pop()

int k_stack_pop	(	struct k_stack *	stack,
		stack_data_t *	data,
		k_timeout_t	timeout
	)

#include <zephyr/kernel.h>

Pop an element from a stack.

This routine removes a stack_data_t value from stack in a "last in, first out" manner and stores the value in data.

Note

timeout must be set to K_NO_WAIT if called from ISR.

Function properties (list may not be complete)

isr-ok

Parameters

stack	Address of the stack.
data	Address of area to hold the value popped from the stack.
timeout	Waiting period to obtain a value, or one of the special values K_NO_WAIT and K_FOREVER.

Return values

0	Element popped from stack.
-EBUSY	Returned without waiting.
-EAGAIN	Waiting period timed out.

k_stack_push()

int k_stack_push	(	struct k_stack *	stack,
		stack_data_t	data
	)

#include <zephyr/kernel.h>

Push an element onto a stack.

This routine adds a stack_data_t value data to stack.

Function properties (list may not be complete)

isr-ok

Parameters

stack	Address of the stack.
data	Value to push onto the stack.

Return values

0	on success
-ENOMEM	if stack is full