kernel.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016, Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_KERNEL_H_
#define ZEPHYR_INCLUDE_KERNEL_H_
 
#if !defined(_ASMLANGUAGE)
#include <zephyr/kernel_includes.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <zephyr/toolchain.h>
#include <zephyr/tracing/tracing_macros.h>
#include <zephyr/sys/mem_stats.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/sys/ring_buffer.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * Zephyr currently assumes the size of a couple standard types to simplify
 * print string formats. Let's make sure this doesn't change without notice.
 */
BUILD_ASSERT(sizeof(int32_t) == sizeof(int));
BUILD_ASSERT(sizeof(int64_t) == sizeof(long long));
BUILD_ASSERT(sizeof(intptr_t) == sizeof(long));

 
#define K_ANY NULL
 
#if (CONFIG_NUM_COOP_PRIORITIES + CONFIG_NUM_PREEMPT_PRIORITIES) == 0
#error Zero available thread priorities defined!
#endif
 
#define K_PRIO_COOP(x) (-(CONFIG_NUM_COOP_PRIORITIES - (x)))
#define K_PRIO_PREEMPT(x) (x)
 
#define K_HIGHEST_THREAD_PRIO (-CONFIG_NUM_COOP_PRIORITIES)
#define K_LOWEST_THREAD_PRIO CONFIG_NUM_PREEMPT_PRIORITIES
#define K_IDLE_PRIO K_LOWEST_THREAD_PRIO
#define K_HIGHEST_APPLICATION_THREAD_PRIO (K_HIGHEST_THREAD_PRIO)
#define K_LOWEST_APPLICATION_THREAD_PRIO (K_LOWEST_THREAD_PRIO - 1)
 
#ifdef CONFIG_POLL
#define Z_POLL_EVENT_OBJ_INIT(obj) \
        .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events),
#define Z_DECL_POLL_EVENT sys_dlist_t poll_events;
#else
#define Z_POLL_EVENT_OBJ_INIT(obj)
#define Z_DECL_POLL_EVENT
#endif
 
struct k_thread;
struct k_mutex;
struct k_sem;
struct k_msgq;
struct k_mbox;
struct k_pipe;
struct k_queue;
struct k_fifo;
struct k_lifo;
struct k_stack;
struct k_mem_slab;
struct k_timer;
struct k_poll_event;
struct k_poll_signal;
struct k_mem_domain;
struct k_mem_partition;
struct k_futex;
struct k_event;
 
enum execution_context_types {
        K_ISR = 0,
        K_COOP_THREAD,
        K_PREEMPT_THREAD,
};
 
/* private, used by k_poll and k_work_poll */
struct k_work_poll;
typedef int (*_poller_cb_t)(struct k_poll_event *event, uint32_t state);


static inline void
        k_thread_runtime_stats_longest_frame_reset(__maybe_unused struct k_thread *thread)
{
#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
        thread->base.usage.longest = 0ULL;
#endif
}
 
typedef void (*k_thread_user_cb_t)(const struct k_thread *thread,
                                   void *user_data);

void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data);

#ifdef CONFIG_SMP
void k_thread_foreach_filter_by_cpu(unsigned int cpu,
                                    k_thread_user_cb_t user_cb, void *user_data);
#else
static inline
void k_thread_foreach_filter_by_cpu(unsigned int cpu,
                                    k_thread_user_cb_t user_cb, void *user_data)
{
        __ASSERT(cpu == 0, "cpu filter out of bounds");
        ARG_UNUSED(cpu);
        k_thread_foreach(user_cb, user_data);
}
#endif

void k_thread_foreach_unlocked(
        k_thread_user_cb_t user_cb, void *user_data);

#ifdef CONFIG_SMP
void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
                                             k_thread_user_cb_t user_cb, void *user_data);
#else
static inline
void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
                                             k_thread_user_cb_t user_cb, void *user_data)
{
        __ASSERT(cpu == 0, "cpu filter out of bounds");
        ARG_UNUSED(cpu);
        k_thread_foreach_unlocked(user_cb, user_data);
}
#endif


 
#endif /* !_ASMLANGUAGE */
 
 
/*
 * Thread user options. May be needed by assembly code. Common part uses low
 * bits, arch-specific use high bits.
 */

#define K_ESSENTIAL (BIT(0))
 
#define K_FP_IDX 1
#define K_FP_REGS (BIT(K_FP_IDX))

#define K_USER (BIT(2))

#define K_INHERIT_PERMS (BIT(3))

#define K_CALLBACK_STATE (BIT(4))

#define K_DSP_IDX 13
#define K_DSP_REGS (BIT(K_DSP_IDX))

#define K_AGU_IDX 14
#define K_AGU_REGS (BIT(K_AGU_IDX))

#define K_SSE_REGS (BIT(15))
 
/* end - thread options */
 
#if !defined(_ASMLANGUAGE)
__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);

__syscall int k_thread_stack_free(k_thread_stack_t *stack);

__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
                                  k_thread_stack_t *stack,
                                  size_t stack_size,
                                  k_thread_entry_t entry,
                                  void *p1, void *p2, void *p3,
                                  int prio, uint32_t options, k_timeout_t delay);

FUNC_NORETURN void k_thread_user_mode_enter(k_thread_entry_t entry,
                                                   void *p1, void *p2,
                                                   void *p3);

#define k_thread_access_grant(thread, ...) \
        FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)

static inline void k_thread_heap_assign(struct k_thread *thread,
                                        struct k_heap *heap)
{
        thread->resource_pool = heap;
}
 
#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
__syscall int k_thread_stack_space_get(const struct k_thread *thread,
                                       size_t *unused_ptr);

__syscall int k_thread_runtime_stack_unused_threshold_pct_set(struct k_thread *thread,
                                                              uint32_t pct);

__syscall int k_thread_runtime_stack_unused_threshold_set(struct k_thread *thread,
                                                          size_t threshold);

__syscall size_t k_thread_runtime_stack_unused_threshold_get(struct k_thread *thread);

typedef void (*k_thread_stack_safety_handler_t)(const struct k_thread *thread,
                                                size_t unused_space, void *arg);

int k_thread_runtime_stack_safety_full_check(const struct k_thread *thread,
                                             size_t *unused_ptr,
                                             k_thread_stack_safety_handler_t handler,
                                             void *arg);

int k_thread_runtime_stack_safety_threshold_check(const struct k_thread *thread,
                                                  size_t *unused_ptr,
                                                  k_thread_stack_safety_handler_t handler,
                                                  void *arg);
#endif
 
#if (K_HEAP_MEM_POOL_SIZE > 0)
void k_thread_system_pool_assign(struct k_thread *thread);
#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */

__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);

__syscall int32_t k_sleep(k_timeout_t timeout);

static inline int32_t k_msleep(int32_t ms)
{
        return k_sleep(Z_TIMEOUT_MS(ms));
}

__syscall int32_t k_usleep(int32_t us);

__syscall void k_busy_wait(uint32_t usec_to_wait);

bool k_can_yield(void);

__syscall void k_yield(void);

__syscall void k_wakeup(k_tid_t thread);

__attribute_const__
__syscall k_tid_t k_sched_current_thread_query(void);

static inline bool k_is_pre_kernel(void)
{
        extern bool z_sys_post_kernel; /* in init.c */
 
        /*
         * If called from userspace, it must be post kernel.
         * This guard is necessary because z_sys_post_kernel memory
         * is not accessible to user threads.
         */
        if (k_is_user_context()) {
                return false;
        }
 
        /*
         * Some compilers might optimize by pre-reading
         * z_sys_post_kernel. This is absolutely not desirable.
         * We are trying to avoid reading it if we are in user
         * context as reading z_sys_post_kernel in user context
         * will result in access fault. So add a compiler barrier
         * here to stop that kind of optimizations.
         */
        compiler_barrier();
 
        return !z_sys_post_kernel;
}

__attribute_const__
static inline k_tid_t k_current_get(void)
{
        __ASSERT(!k_is_pre_kernel(), "k_current_get called pre-kernel");
 
#ifdef CONFIG_CURRENT_THREAD_USE_TLS
 
        /* Thread-local cache of current thread ID, set in z_thread_entry() */
        extern Z_THREAD_LOCAL k_tid_t z_tls_current;
 
        return z_tls_current;
#else
        return k_sched_current_thread_query();
#endif
}

__syscall void k_thread_abort(k_tid_t thread);
 
k_ticks_t z_timeout_expires(const struct _timeout *timeout);
k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
 
#ifdef CONFIG_SYS_CLOCK_EXISTS

__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
 
static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
                                                const struct k_thread *thread)
{
        return z_timeout_expires(&thread->base.timeout);
}

__syscall k_ticks_t k_thread_timeout_remaining_ticks(const struct k_thread *thread);
 
static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
                                                const struct k_thread *thread)
{
        return z_timeout_remaining(&thread->base.timeout);
}
 
#endif /* CONFIG_SYS_CLOCK_EXISTS */

struct _static_thread_data {
        struct k_thread *init_thread;
        k_thread_stack_t *init_stack;
        unsigned int init_stack_size;
        k_thread_entry_t init_entry;
        void *init_p1;
        void *init_p2;
        void *init_p3;
        int init_prio;
        uint32_t init_options;
        const char *init_name;
#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
        int32_t init_delay_ms;
#else
        k_timeout_t init_delay;
#endif
};
 
#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
#else
#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS_INIT(ms)
#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
#endif
 
#define Z_THREAD_INITIALIZER(thread, stack, stack_size,           \
                            entry, p1, p2, p3,                   \
                            prio, options, delay, tname)         \
        {                                                        \
        .init_thread = (thread),                                 \
        .init_stack = (stack),                                   \
        .init_stack_size = (stack_size),                         \
        .init_entry = (k_thread_entry_t)entry,                   \
        .init_p1 = (void *)p1,                                   \
        .init_p2 = (void *)p2,                                   \
        .init_p3 = (void *)p3,                                   \
        .init_prio = (prio),                                     \
        .init_options = (options),                               \
        .init_name = STRINGIFY(tname),                           \
        Z_THREAD_INIT_DELAY_INITIALIZER(delay)                   \
        }
 
/*
 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
 * information on arguments.
 */
#define Z_THREAD_COMMON_DEFINE(name, stack_size,                        \
                               entry, p1, p2, p3,                       \
                               prio, options, delay)                    \
        struct k_thread _k_thread_obj_##name;                           \
        const STRUCT_SECTION_ITERABLE(_static_thread_data,              \
                                _k_thread_data_##name) =                \
                Z_THREAD_INITIALIZER(&_k_thread_obj_##name,             \
                                     _k_thread_stack_##name, stack_size,\
                                     entry, p1, p2, p3, prio, options,  \
                                     delay, name);                      \
        __maybe_unused const k_tid_t name = (k_tid_t)&_k_thread_obj_##name

#define K_THREAD_DEFINE(name, stack_size,                                \
                        entry, p1, p2, p3,                               \
                        prio, options, delay)                            \
        K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size);       \
        Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3,      \
                               prio, options, delay)

#define K_KERNEL_THREAD_DEFINE(name, stack_size,                        \
                               entry, p1, p2, p3,                       \
                               prio, options, delay)                    \
        K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size);      \
        Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3,     \
                               prio, options, delay)

__syscall int k_thread_priority_get(k_tid_t thread);

__syscall void k_thread_priority_set(k_tid_t thread, int prio);
 
 
#ifdef CONFIG_SCHED_DEADLINE
__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);

__syscall void k_thread_absolute_deadline_set(k_tid_t thread, int deadline);
#endif

__syscall void k_reschedule(void);
 
#ifdef CONFIG_SCHED_CPU_MASK
int k_thread_cpu_mask_clear(k_tid_t thread);

int k_thread_cpu_mask_enable_all(k_tid_t thread);

int k_thread_cpu_mask_enable(k_tid_t thread, int cpu);

int k_thread_cpu_mask_disable(k_tid_t thread, int cpu);

int k_thread_cpu_pin(k_tid_t thread, int cpu);
#endif

__syscall void k_thread_suspend(k_tid_t thread);

__syscall void k_thread_resume(k_tid_t thread);

static inline void k_thread_start(k_tid_t thread)
{
        k_wakeup(thread);
}

void k_sched_time_slice_set(int32_t slice, int prio);

void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
                             k_thread_timeslice_fn_t expired, void *data);



bool k_is_in_isr(void);

__syscall int k_is_preempt_thread(void);



void k_sched_lock(void);

void k_sched_unlock(void);

__syscall void k_thread_custom_data_set(void *value);

__syscall void *k_thread_custom_data_get(void);

__syscall int k_thread_name_set(k_tid_t thread, const char *str);

const char *k_thread_name_get(k_tid_t thread);

__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
                                 size_t size);

const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);



#define K_NO_WAIT Z_TIMEOUT_NO_WAIT

#define K_NSEC(t)     Z_TIMEOUT_NS(t)

#define K_USEC(t)     Z_TIMEOUT_US(t)

#define K_CYC(t)     Z_TIMEOUT_CYC(t)

#define K_TICKS(t)     Z_TIMEOUT_TICKS(t)

#define K_MSEC(ms)     Z_TIMEOUT_MS(ms)

#define K_SECONDS(s)   K_MSEC((s) * MSEC_PER_SEC)

#define K_MINUTES(m)   K_SECONDS((m) * 60)

#define K_HOURS(h)     K_MINUTES((h) * 60)

#define K_FOREVER Z_FOREVER

#define K_TIMEOUT_SUM(timeout1, timeout2)  K_TICKS(z_timeout_sum(timeout1, timeout2))
 
#ifdef CONFIG_TIMEOUT_64BIT

#define K_TIMEOUT_ABS_TICKS(t) \
        Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)CLAMP(t, 0, (INT64_MAX - 1))))

#define K_TIMEOUT_ABS_SEC(t) K_TIMEOUT_ABS_TICKS(k_sec_to_ticks_ceil64(t))

#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))

#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))

#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))

#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
#endif


struct k_timer {
        /*
         * _timeout structure must be first here if we want to use
         * dynamic timer allocation. timeout.node is used in the double-linked
         * list of free timers
         */
        struct _timeout timeout;
 
        /* wait queue for the (single) thread waiting on this timer */
        _wait_q_t wait_q;
 
        /* runs in ISR context */
        void (*expiry_fn)(struct k_timer *timer);
 
        /* runs in the context of the thread that calls k_timer_stop() */
        void (*stop_fn)(struct k_timer *timer);
 
        /* timer period */
        k_timeout_t period;
 
        /* timer status */
        uint32_t status;
 
        /* user-specific data, also used to support legacy features */
        void *user_data;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_timer)
 
#ifdef CONFIG_OBJ_CORE_TIMER
        struct k_obj_core  obj_core;
#endif
};
 
#ifdef CONFIG_TIMER_OBSERVER
struct k_timer_observer {
        /* Invoked upon completion of k_timer initialization */
        void (*on_init)(struct k_timer *timer);
 
        /* Invoked after the timer transitions to the running state  */
        void (*on_start)(struct k_timer *timer, k_timeout_t duration,
                         k_timeout_t period);
 
        /* Invoked when the active timer is explicitly stopped */
        void (*on_stop)(struct k_timer *timer);
 
        /* Executes in ISR context, keep minimal and non-blocking */
        void (*on_expiry)(struct k_timer *timer);
};
#endif /* CONFIG_TIMER_OBSERVER */

#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
        { \
        .timeout = { \
                .node = {},\
                .fn = z_timer_expiration_handler, \
                .dticks = 0, \
        }, \
        .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
        .expiry_fn = expiry, \
        .stop_fn = stop, \
        .period = {}, \
        .status = 0, \
        .user_data = 0, \
        }


typedef void (*k_timer_expiry_t)(struct k_timer *timer);

typedef void (*k_timer_stop_t)(struct k_timer *timer);

#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
        STRUCT_SECTION_ITERABLE(k_timer, name) = \
                Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
 
 
#ifdef CONFIG_TIMER_OBSERVER

#define Z_TIMER_OBSERVER_INITIALIZER(name, init, start, stop, expiry) \
        { \
        .on_init = init, \
        .on_start = start, \
        .on_stop = stop, \
        .on_expiry = expiry \
        }

#define K_TIMER_OBSERVER_DEFINE(name, init, start, stop, expiry) \
        static const STRUCT_SECTION_ITERABLE(k_timer_observer, name) = \
                Z_TIMER_OBSERVER_INITIALIZER(name, init, start, stop, expiry)
 
#endif /* CONFIG_TIMER_OBSERVER */

void k_timer_init(struct k_timer *timer,
                         k_timer_expiry_t expiry_fn,
                         k_timer_stop_t stop_fn);

__syscall void k_timer_start(struct k_timer *timer,
                             k_timeout_t duration, k_timeout_t period);

__syscall void k_timer_stop(struct k_timer *timer);

__syscall uint32_t k_timer_status_get(struct k_timer *timer);

__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
 
#ifdef CONFIG_SYS_CLOCK_EXISTS

__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
 
static inline k_ticks_t z_impl_k_timer_expires_ticks(
                                       const struct k_timer *timer)
{
        return z_timeout_expires(&timer->timeout);
}

__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
 
static inline k_ticks_t z_impl_k_timer_remaining_ticks(
                                       const struct k_timer *timer)
{
        return z_timeout_remaining(&timer->timeout);
}

static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
{
        return k_ticks_to_ms_floor32(k_timer_remaining_ticks(timer));
}
 
#endif /* CONFIG_SYS_CLOCK_EXISTS */

__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);

static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
                                               void *user_data)
{
        timer->user_data = user_data;
}

__syscall void *k_timer_user_data_get(const struct k_timer *timer);
 
static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
{
        return timer->user_data;
}

int k_timer_cleanup(struct k_timer *timer);



__syscall int64_t k_uptime_ticks(void);

static inline int64_t k_uptime_get(void)
{
        return k_ticks_to_ms_floor64(k_uptime_ticks());
}

static inline uint32_t k_uptime_get_32(void)
{
        return (uint32_t)k_uptime_get();
}

static inline uint32_t k_uptime_seconds(void)
{
        return k_ticks_to_sec_floor32(k_uptime_ticks());
}

static inline int64_t k_uptime_delta(int64_t *reftime)
{
        int64_t uptime, delta;
 
        uptime = k_uptime_get();
        delta = uptime - *reftime;
        *reftime = uptime;
 
        return delta;
}

static inline uint32_t k_cycle_get_32(void)
{
        return arch_k_cycle_get_32();
}

static inline uint64_t k_cycle_get_64(void)
{
        if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
                __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
                            "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
                return 0;
        }
 
        return arch_k_cycle_get_64();
}


struct k_queue {
        sys_sflist_t data_q;
        struct k_spinlock lock;
        _wait_q_t wait_q;
 
        Z_DECL_POLL_EVENT
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_queue)
};

#define Z_QUEUE_INITIALIZER(obj) \
        { \
        .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
        .lock = { }, \
        .wait_q = Z_WAIT_Q_INIT(&obj.wait_q),   \
        Z_POLL_EVENT_OBJ_INIT(obj)              \
        }


__syscall void k_queue_init(struct k_queue *queue);

__syscall void k_queue_cancel_wait(struct k_queue *queue);

void k_queue_append(struct k_queue *queue, void *data);

__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);

void k_queue_prepend(struct k_queue *queue, void *data);

__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);

void k_queue_insert(struct k_queue *queue, void *prev, void *data);

int k_queue_append_list(struct k_queue *queue, void *head, void *tail);

int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);

__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);

bool k_queue_remove(struct k_queue *queue, void *data);

bool k_queue_unique_append(struct k_queue *queue, void *data);

__syscall int k_queue_is_empty(struct k_queue *queue);
 
static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
{
        return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
}

__syscall void *k_queue_peek_head(struct k_queue *queue);

__syscall void *k_queue_peek_tail(struct k_queue *queue);

#define K_QUEUE_DEFINE(name) \
        STRUCT_SECTION_ITERABLE(k_queue, name) = \
                Z_QUEUE_INITIALIZER(name)

 
#ifdef CONFIG_USERSPACE
struct k_futex {
        atomic_t val;
};

struct z_futex_data {
        _wait_q_t wait_q;
        struct k_spinlock lock;
};

#define Z_FUTEX_DATA_INITIALIZER(obj) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&obj.wait_q) \
        }


__syscall int k_futex_wait(struct k_futex *futex, int expected,
                           k_timeout_t timeout);

__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);

#endif



 
struct k_event {
        _wait_q_t         wait_q;
        uint32_t          events;
        struct k_spinlock lock;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_event)
 
#ifdef CONFIG_OBJ_CORE_EVENT
        struct k_obj_core obj_core;
#endif
};

#define Z_EVENT_INITIALIZER(obj) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
        .events = 0, \
        .lock = {}, \
        }

__syscall void k_event_init(struct k_event *event);

__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);

__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);

__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
                                  uint32_t events_mask);

__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);

__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
                                bool reset, k_timeout_t timeout);

__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
                                    bool reset, k_timeout_t timeout);

__syscall uint32_t k_event_wait_safe(struct k_event *event, uint32_t events,
                                     bool reset, k_timeout_t timeout);

__syscall uint32_t k_event_wait_all_safe(struct k_event *event, uint32_t events,
                                         bool reset, k_timeout_t timeout);

static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
{
        return k_event_wait(event, events_mask, false, K_NO_WAIT);
}

#define K_EVENT_DEFINE(name)                                   \
        STRUCT_SECTION_ITERABLE(k_event, name) =               \
                Z_EVENT_INITIALIZER(name);


struct k_fifo {
        struct k_queue _queue;
#ifdef CONFIG_OBJ_CORE_FIFO
        struct k_obj_core  obj_core;
#endif
};

#define Z_FIFO_INITIALIZER(obj) \
        { \
        ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
        }


#define k_fifo_init(fifo)                                    \
        ({                                                   \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
        k_queue_init(&(fifo)->_queue);                       \
        K_OBJ_CORE_INIT(K_OBJ_CORE(fifo), _obj_type_fifo);   \
        K_OBJ_CORE_LINK(K_OBJ_CORE(fifo));                   \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo);  \
        })

#define k_fifo_cancel_wait(fifo) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
        k_queue_cancel_wait(&(fifo)->_queue); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
        })

#define k_fifo_put(fifo, data) \
        ({ \
        void *_data = data; \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, _data); \
        k_queue_append(&(fifo)->_queue, _data); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, _data); \
        })

#define k_fifo_alloc_put(fifo, data) \
        ({ \
        void *_data = data; \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, _data); \
        int fap_ret = k_queue_alloc_append(&(fifo)->_queue, _data); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, _data, fap_ret); \
        fap_ret; \
        })

#define k_fifo_put_list(fifo, head, tail) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
        k_queue_append_list(&(fifo)->_queue, head, tail); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
        })

#define k_fifo_put_slist(fifo, list) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
        k_queue_merge_slist(&(fifo)->_queue, list); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
        })

#define k_fifo_get(fifo, timeout) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
        void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
        fg_ret; \
        })

#define k_fifo_is_empty(fifo) \
        k_queue_is_empty(&(fifo)->_queue)

#define k_fifo_peek_head(fifo) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
        void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
        fph_ret; \
        })

#define k_fifo_peek_tail(fifo) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
        void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
        fpt_ret; \
        })

#define K_FIFO_DEFINE(name) \
        STRUCT_SECTION_ITERABLE(k_fifo, name) = \
                Z_FIFO_INITIALIZER(name)


struct k_lifo {
        struct k_queue _queue;
#ifdef CONFIG_OBJ_CORE_LIFO
        struct k_obj_core  obj_core;
#endif
};

#define Z_LIFO_INITIALIZER(obj) \
        { \
        ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
        }


#define k_lifo_init(lifo)                                    \
        ({                                                   \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
        k_queue_init(&(lifo)->_queue);                       \
        K_OBJ_CORE_INIT(K_OBJ_CORE(lifo), _obj_type_lifo);   \
        K_OBJ_CORE_LINK(K_OBJ_CORE(lifo));                   \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo);  \
        })

#define k_lifo_put(lifo, data) \
        ({ \
        void *_data = data; \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, _data); \
        k_queue_prepend(&(lifo)->_queue, _data); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, _data); \
        })

#define k_lifo_alloc_put(lifo, data) \
        ({ \
        void *_data = data; \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, _data); \
        int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, _data); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, _data, lap_ret); \
        lap_ret; \
        })

#define k_lifo_get(lifo, timeout) \
        ({ \
        SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
        void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
        lg_ret; \
        })

#define K_LIFO_DEFINE(name) \
        STRUCT_SECTION_ITERABLE(k_lifo, name) = \
                Z_LIFO_INITIALIZER(name)


#define K_STACK_FLAG_ALLOC      ((uint8_t)1)    /* Buffer was allocated */
 
typedef uintptr_t stack_data_t;
 
struct k_stack {
        _wait_q_t wait_q;
        struct k_spinlock lock;
        stack_data_t *base, *next, *top;
 
        uint8_t flags;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_stack)
 
#ifdef CONFIG_OBJ_CORE_STACK
        struct k_obj_core  obj_core;
#endif
};
 
#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
        .base = (stack_buffer), \
        .next = (stack_buffer), \
        .top = (stack_buffer) + (stack_num_entries), \
        }


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

 
__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
                                   uint32_t num_entries);

int k_stack_cleanup(struct k_stack *stack);

__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);

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

#define K_STACK_DEFINE(name, stack_num_entries)                \
        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)


struct k_work;
struct k_work_q;
struct k_work_queue_config;
extern struct k_work_q k_sys_work_q;


struct k_mutex {
        _wait_q_t wait_q;
        struct k_thread *owner;

        uint32_t lock_count;

        int owner_orig_prio;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_mutex)
 
#ifdef CONFIG_OBJ_CORE_MUTEX
        struct k_obj_core obj_core;
#endif
};

#define Z_MUTEX_INITIALIZER(obj) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
        .owner = NULL, \
        .lock_count = 0, \
        .owner_orig_prio = K_LOWEST_APPLICATION_THREAD_PRIO, \
        }

#define K_MUTEX_DEFINE(name) \
        STRUCT_SECTION_ITERABLE(k_mutex, name) = \
                Z_MUTEX_INITIALIZER(name)

__syscall int k_mutex_init(struct k_mutex *mutex);
 

__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);

__syscall int k_mutex_unlock(struct k_mutex *mutex);


struct k_condvar {
        _wait_q_t wait_q;
 
#ifdef CONFIG_OBJ_CORE_CONDVAR
        struct k_obj_core  obj_core;
#endif
};

#define Z_CONDVAR_INITIALIZER(obj)                                             \
        {                                                                      \
                .wait_q = Z_WAIT_Q_INIT(&obj.wait_q),                          \
        }


__syscall int k_condvar_init(struct k_condvar *condvar);

__syscall int k_condvar_signal(struct k_condvar *condvar);

__syscall int k_condvar_broadcast(struct k_condvar *condvar);

__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
                             k_timeout_t timeout);

#define K_CONDVAR_DEFINE(name)                                                 \
        STRUCT_SECTION_ITERABLE(k_condvar, name) =                             \
                Z_CONDVAR_INITIALIZER(name)



struct k_sem {
        _wait_q_t wait_q;
        unsigned int count;
        unsigned int limit;
 
        Z_DECL_POLL_EVENT
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_sem)
 
#ifdef CONFIG_OBJ_CORE_SEM
        struct k_obj_core  obj_core;
#endif
};

#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
        .count = (initial_count), \
        .limit = (count_limit), \
        Z_POLL_EVENT_OBJ_INIT(obj) \
        }

#define K_SEM_MAX_LIMIT UINT_MAX

__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
                          unsigned int limit);

__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);

__syscall void k_sem_give(struct k_sem *sem);

__syscall void k_sem_reset(struct k_sem *sem);

__syscall unsigned int k_sem_count_get(struct k_sem *sem);

static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
{
        return sem->count;
}

#define K_SEM_DEFINE(name, initial_count, count_limit)                                             \
        STRUCT_SECTION_ITERABLE(k_sem, name) =                                                     \
                Z_SEM_INITIALIZER(name, initial_count, count_limit);                               \
        BUILD_ASSERT(((count_limit) != 0) &&                                                       \
                     (((initial_count) < (count_limit)) || ((initial_count) == (count_limit))) &&  \
                     ((count_limit) <= K_SEM_MAX_LIMIT));

 
#if defined(CONFIG_SCHED_IPI_SUPPORTED) || defined(__DOXYGEN__)
struct k_ipi_work;
 
 
typedef void (*k_ipi_func_t)(struct k_ipi_work *work);

struct k_ipi_work {
        sys_dnode_t    node[CONFIG_MP_MAX_NUM_CPUS];   /* Node in IPI work queue */
        k_ipi_func_t   func;     /* Function to execute on target CPU */
        struct k_event event;    /* Event to signal when processed */
        uint32_t       bitmask;  /* Bitmask of targeted CPUs */
};
 

static inline void k_ipi_work_init(struct k_ipi_work *work)
{
        k_event_init(&work->event);
        for (unsigned int i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
                sys_dnode_init(&work->node[i]);
        }
        work->bitmask = 0;
}

int k_ipi_work_add(struct k_ipi_work *work, uint32_t cpu_bitmask,
                   k_ipi_func_t func);

int k_ipi_work_wait(struct k_ipi_work *work, k_timeout_t timeout);

void k_ipi_work_signal(void);
 
#endif /* CONFIG_SCHED_IPI_SUPPORTED */

struct k_work_delayable;
struct k_work_sync;


typedef void (*k_work_handler_t)(struct k_work *work);

void k_work_init(struct k_work *work,
                  k_work_handler_t handler);

int k_work_busy_get(const struct k_work *work);

static inline bool k_work_is_pending(const struct k_work *work);

int k_work_submit_to_queue(struct k_work_q *queue,
                           struct k_work *work);

int k_work_submit(struct k_work *work);

bool k_work_flush(struct k_work *work,
                  struct k_work_sync *sync);

int k_work_cancel(struct k_work *work);

bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);

void k_work_queue_init(struct k_work_q *queue);

void k_work_queue_start(struct k_work_q *queue,
                        k_thread_stack_t *stack, size_t stack_size,
                        int prio, const struct k_work_queue_config *cfg);

void k_work_queue_run(struct k_work_q *queue, const struct k_work_queue_config *cfg);

static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);

int k_work_queue_drain(struct k_work_q *queue, bool plug);

int k_work_queue_unplug(struct k_work_q *queue);

int k_work_queue_stop(struct k_work_q *queue, k_timeout_t timeout);

void k_work_init_delayable(struct k_work_delayable *dwork,
                           k_work_handler_t handler);

static inline struct k_work_delayable *
k_work_delayable_from_work(struct k_work *work);

int k_work_delayable_busy_get(const struct k_work_delayable *dwork);

static inline bool k_work_delayable_is_pending(
        const struct k_work_delayable *dwork);

static inline k_ticks_t k_work_delayable_expires_get(
        const struct k_work_delayable *dwork);

static inline k_ticks_t k_work_delayable_remaining_get(
        const struct k_work_delayable *dwork);

int k_work_schedule_for_queue(struct k_work_q *queue,
                               struct k_work_delayable *dwork,
                               k_timeout_t delay);

int k_work_schedule(struct k_work_delayable *dwork,
                                   k_timeout_t delay);

int k_work_reschedule_for_queue(struct k_work_q *queue,
                                 struct k_work_delayable *dwork,
                                 k_timeout_t delay);

int k_work_reschedule(struct k_work_delayable *dwork,
                                     k_timeout_t delay);

bool k_work_flush_delayable(struct k_work_delayable *dwork,
                            struct k_work_sync *sync);

int k_work_cancel_delayable(struct k_work_delayable *dwork);

bool k_work_cancel_delayable_sync(struct k_work_delayable *dwork,
                                  struct k_work_sync *sync);
 
enum {
        /* The atomic API is used for all work and queue flags fields to
         * enforce sequential consistency in SMP environments.
         */
 
        /* Bits that represent the work item states.  At least nine of the
         * combinations are distinct valid stable states.
         */
        K_WORK_RUNNING_BIT = 0,
        K_WORK_CANCELING_BIT = 1,
        K_WORK_QUEUED_BIT = 2,
        K_WORK_DELAYED_BIT = 3,
        K_WORK_FLUSHING_BIT = 4,
 
        K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
                | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
 
        /* Static work flags */
        K_WORK_DELAYABLE_BIT = 8,
        K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
 
        /* Dynamic work queue flags */
        K_WORK_QUEUE_STARTED_BIT = 0,
        K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
        K_WORK_QUEUE_BUSY_BIT = 1,
        K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
        K_WORK_QUEUE_DRAIN_BIT = 2,
        K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
        K_WORK_QUEUE_PLUGGED_BIT = 3,
        K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
        K_WORK_QUEUE_STOP_BIT = 4,
        K_WORK_QUEUE_STOP = BIT(K_WORK_QUEUE_STOP_BIT),
 
        /* Static work queue flags */
        K_WORK_QUEUE_NO_YIELD_BIT = 8,
        K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
        /* Transient work flags */

        K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),

        K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),

        K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),

        K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),

        K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
};

struct k_work {
        /* All fields are protected by the work module spinlock. */
 
        /* Node to link into k_work_q pending list. */
        sys_snode_t node;
 
        /* The function to be invoked by the work queue thread. */
        k_work_handler_t handler;
 
        /* The queue on which the work item was last submitted. */
        struct k_work_q *queue;
 
        /* State of the work item.
         *
         * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
         *
         * It can be RUNNING and CANCELING simultaneously.
         */
        uint32_t flags;
};

#define Z_WORK_INITIALIZER(work_handler) { \
        .handler = (work_handler), \
}

struct k_work_delayable {
        /* The work item. */
        struct k_work work;
 
        /* Timeout used to submit work after a delay. */
        struct _timeout timeout;
 
        /* The queue to which the work should be submitted. */
        struct k_work_q *queue;
};

#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
        .work = { \
                .handler = (work_handler), \
                .flags = K_WORK_DELAYABLE, \
        }, \
}

#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
        struct k_work_delayable work \
          = Z_WORK_DELAYABLE_INITIALIZER(work_handler)

/* Record used to wait for work to flush.
 *
 * The work item is inserted into the queue that will process (or is
 * processing) the item, and will be processed as soon as the item
 * completes.  When the flusher is processed the semaphore will be
 * signaled, releasing the thread waiting for the flush.
 */
struct z_work_flusher {
        struct k_work work;
        struct k_sem sem;
};
 
/* Record used to wait for work to complete a cancellation.
 *
 * The work item is inserted into a global queue of pending cancels.
 * When a cancelling work item goes idle any matching waiters are
 * removed from pending_cancels and are woken.
 */
struct z_work_canceller {
        sys_snode_t node;
        struct k_work *work;
        struct k_sem sem;
};

struct k_work_sync {
        union {
                struct z_work_flusher flusher;
                struct z_work_canceller canceller;
        };
};

struct k_work_queue_config {
        const char *name;

        bool no_yield;

        bool essential;

        uint32_t work_timeout_ms;
};

struct k_work_q {
        /* The thread that animates the work. */
        struct k_thread thread;
 
        /* The thread ID that animates the work. This may be an external thread
         * if k_work_queue_run() is used.
         */
        k_tid_t thread_id;
 
        /* All the following fields must be accessed only while the
         * work module spinlock is held.
         */
 
        /* List of k_work items to be worked. */
        sys_slist_t pending;
 
        /* Wait queue for idle work thread. */
        _wait_q_t notifyq;
 
        /* Wait queue for threads waiting for the queue to drain. */
        _wait_q_t drainq;
 
        /* Flags describing queue state. */
        uint32_t flags;
 
#if defined(CONFIG_WORKQUEUE_WORK_TIMEOUT)
        struct _timeout work_timeout_record;
        struct k_work *work;
        k_timeout_t work_timeout;
        bool finished;
#endif /* defined(CONFIG_WORKQUEUE_WORK_TIMEOUT) */
};
 
/* Provide the implementation for inline functions declared above */
 
static inline bool k_work_is_pending(const struct k_work *work)
{
        return k_work_busy_get(work) != 0;
}
 
static inline struct k_work_delayable *
k_work_delayable_from_work(struct k_work *work)
{
        return CONTAINER_OF(work, struct k_work_delayable, work);
}
 
static inline bool k_work_delayable_is_pending(
        const struct k_work_delayable *dwork)
{
        return k_work_delayable_busy_get(dwork) != 0;
}
 
static inline k_ticks_t k_work_delayable_expires_get(
        const struct k_work_delayable *dwork)
{
        return z_timeout_expires(&dwork->timeout);
}
 
static inline k_ticks_t k_work_delayable_remaining_get(
        const struct k_work_delayable *dwork)
{
        return z_timeout_remaining(&dwork->timeout);
}
 
static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue)
{
        return queue->thread_id;
}

 
struct k_work_user;


typedef void (*k_work_user_handler_t)(struct k_work_user *work);

struct k_work_user_q {
        struct k_queue queue;
        struct k_thread thread;
};
 
enum {
        K_WORK_USER_STATE_PENDING,      /* Work item pending state */
};
 
struct k_work_user {
        void *_reserved;                /* Used by k_queue implementation. */
        k_work_user_handler_t handler;
        atomic_t flags;
};
 
#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
#else
#define Z_WORK_USER_INITIALIZER(work_handler) \
        { \
        ._reserved = NULL, \
        .handler = (work_handler), \
        .flags = 0 \
        }
#endif

#define K_WORK_USER_DEFINE(work, work_handler) \
        struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)

static inline void k_work_user_init(struct k_work_user *work,
                                    k_work_user_handler_t handler)
{
        *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
}

static inline bool k_work_user_is_pending(struct k_work_user *work)
{
        return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
}

static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
                                              struct k_work_user *work)
{
        int ret = -EBUSY;
 
        if (!atomic_test_and_set_bit(&work->flags,
                                     K_WORK_USER_STATE_PENDING)) {
                ret = k_queue_alloc_append(&work_q->queue, work);
 
                /* Couldn't insert into the queue. Clear the pending bit
                 * so the work item can be submitted again
                 */
                if (ret != 0) {
                        atomic_clear_bit(&work->flags,
                                         K_WORK_USER_STATE_PENDING);
                }
        }
 
        return ret;
}

void k_work_user_queue_start(struct k_work_user_q *work_q,
                                    k_thread_stack_t *stack,
                                    size_t stack_size, int prio,
                                    const char *name);

static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
{
        return &work_q->thread;
}


struct k_work_poll {
        struct k_work work;
        struct k_work_q *workq;
        struct z_poller poller;
        struct k_poll_event *events;
        int num_events;
        k_work_handler_t real_handler;
        struct _timeout timeout;
        int poll_result;
};


#define K_WORK_DEFINE(work, work_handler) \
        struct k_work work = Z_WORK_INITIALIZER(work_handler)

void k_work_poll_init(struct k_work_poll *work,
                             k_work_handler_t handler);

int k_work_poll_submit_to_queue(struct k_work_q *work_q,
                                       struct k_work_poll *work,
                                       struct k_poll_event *events,
                                       int num_events,
                                       k_timeout_t timeout);

int k_work_poll_submit(struct k_work_poll *work,
                                     struct k_poll_event *events,
                                     int num_events,
                                     k_timeout_t timeout);

int k_work_poll_cancel(struct k_work_poll *work);



struct k_msgq {
        _wait_q_t wait_q;
        struct k_spinlock lock;
        size_t msg_size;
        uint32_t max_msgs;
        char *buffer_start;
        char *buffer_end;
        char *read_ptr;
        char *write_ptr;
        uint32_t used_msgs;
 
        Z_DECL_POLL_EVENT

        uint8_t flags;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_msgq)
 
#ifdef CONFIG_OBJ_CORE_MSGQ
        struct k_obj_core  obj_core;
#endif
};

#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
        { \
        .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
        .lock = {}, \
        .msg_size = q_msg_size, \
        .max_msgs = q_max_msgs, \
        .buffer_start = q_buffer, \
        .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
        .read_ptr = q_buffer, \
        .write_ptr = q_buffer, \
        .used_msgs = 0, \
        Z_POLL_EVENT_OBJ_INIT(obj) \
        .flags = 0, \
        }
 
 
#define K_MSGQ_FLAG_ALLOC       BIT(0)

struct k_msgq_attrs {
        size_t msg_size;
        uint32_t max_msgs;
        uint32_t used_msgs;
};
 

#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align)          \
        static char __noinit __aligned(q_align)                         \
                _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)];      \
        STRUCT_SECTION_ITERABLE(k_msgq, q_name) =                       \
               Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
                                  (q_msg_size), (q_max_msgs))

void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
                 uint32_t max_msgs);

__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
                                uint32_t max_msgs);

int k_msgq_cleanup(struct k_msgq *msgq);

__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);

__syscall int k_msgq_put_front(struct k_msgq *msgq, const void *data);

__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);

__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);

__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);

__syscall void k_msgq_purge(struct k_msgq *msgq);

__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);

__syscall void  k_msgq_get_attrs(struct k_msgq *msgq,
                                 struct k_msgq_attrs *attrs);
 
 
static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
{
        return msgq->max_msgs - msgq->used_msgs;
}

__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
 
static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
{
        return msgq->used_msgs;
}



struct k_mbox_msg {
        size_t size;
        uint32_t info;
        void *tx_data;
        k_tid_t rx_source_thread;
        k_tid_t tx_target_thread;
        k_tid_t _syncing_thread;
#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
        struct k_sem *_async_sem;
#endif
};

struct k_mbox {
        _wait_q_t tx_msg_queue;
        _wait_q_t rx_msg_queue;
        struct k_spinlock lock;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_mbox)
 
#ifdef CONFIG_OBJ_CORE_MAILBOX
        struct k_obj_core  obj_core;
#endif
};

#define Z_MBOX_INITIALIZER(obj) \
        { \
        .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
        .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
        }

#define K_MBOX_DEFINE(name) \
        STRUCT_SECTION_ITERABLE(k_mbox, name) = \
                Z_MBOX_INITIALIZER(name) \


void k_mbox_init(struct k_mbox *mbox);

int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
                      k_timeout_t timeout);

void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
                             struct k_sem *sem);

int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
                      void *buffer, k_timeout_t timeout);

void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);



__syscall void k_pipe_init(struct k_pipe *pipe, uint8_t *buffer, size_t buffer_size);
 
enum pipe_flags {
        PIPE_FLAG_OPEN = BIT(0),
        PIPE_FLAG_RESET = BIT(1),
};

struct k_pipe {
        size_t waiting;
        struct ring_buf buf;
        struct k_spinlock lock;
        _wait_q_t data;
        _wait_q_t space;
        uint8_t flags;
 
        Z_DECL_POLL_EVENT
#ifdef CONFIG_OBJ_CORE_PIPE
        struct k_obj_core  obj_core;
#endif
        SYS_PORT_TRACING_TRACKING_FIELD(k_pipe)
};

#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size)  \
{                                                               \
        .waiting = 0,                                           \
        .buf = RING_BUF_INIT(pipe_buffer, pipe_buffer_size),    \
        .data = Z_WAIT_Q_INIT(&obj.data),                       \
        .space = Z_WAIT_Q_INIT(&obj.space),                     \
        .flags = PIPE_FLAG_OPEN,                                \
        Z_POLL_EVENT_OBJ_INIT(obj)                              \
}

#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align)               \
        static unsigned char __noinit __aligned(pipe_align)             \
                _k_pipe_buf_##name[pipe_buffer_size];                   \
        STRUCT_SECTION_ITERABLE(k_pipe, name) =                         \
                Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
 

__syscall int k_pipe_write(struct k_pipe *pipe, const uint8_t *data, size_t len,
                           k_timeout_t timeout);

__syscall int k_pipe_read(struct k_pipe *pipe, uint8_t *data, size_t len,
                          k_timeout_t timeout);

__syscall void k_pipe_reset(struct k_pipe *pipe);

__syscall void k_pipe_close(struct k_pipe *pipe);

struct k_mem_slab_info {
        uint32_t num_blocks;
        size_t   block_size;
        uint32_t num_used;
#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
        uint32_t max_used;
#endif
};
 
struct k_mem_slab {
        _wait_q_t wait_q;
        struct k_spinlock lock;
        char *buffer;
        char *free_list;
        struct k_mem_slab_info info;
 
        SYS_PORT_TRACING_TRACKING_FIELD(k_mem_slab)
 
#ifdef CONFIG_OBJ_CORE_MEM_SLAB
        struct k_obj_core  obj_core;
#endif
};
 
#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
                               _slab_num_blocks)                      \
        {                                                             \
        .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q),                     \
        .lock = {},                                                   \
        .buffer = _slab_buffer,                                       \
        .free_list = NULL,                                            \
        .info = {_slab_num_blocks, _slab_block_size, 0}               \
        }


#define K_MEM_SLAB_DEFINE_IN_SECT(name, in_section, slab_block_size, slab_num_blocks, slab_align)  \
        BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0,                                      \
                     "slab_block_size must be a multiple of slab_align");                          \
        BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0),                                   \
                     "slab_align must be a power of 2");                                           \
        char in_section __aligned(WB_UP(                                                           \
                slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)];   \
        STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER(                        \
                name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)

#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align)                      \
        K_MEM_SLAB_DEFINE_IN_SECT(name, __noinit_named(k_mem_slab_buf_##name), slab_block_size,    \
                                  slab_num_blocks, slab_align)

#define K_MEM_SLAB_DEFINE_TYPE(name, type, slab_num_blocks)                                        \
        K_MEM_SLAB_DEFINE(name, sizeof(type), slab_num_blocks, __alignof(type))

#define K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, in_section, slab_block_size, slab_num_blocks,       \
                                         slab_align)                                               \
        BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0,                                      \
                     "slab_block_size must be a multiple of slab_align");                          \
        BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0),                                   \
                     "slab_align must be a power of 2");                                           \
        static char in_section __aligned(WB_UP(                                                    \
                slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)];   \
        static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER(                 \
                name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)

#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align)               \
        K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, __noinit_named(k_mem_slab_buf_##name),              \
                                         slab_block_size, slab_num_blocks, slab_align)

#define K_MEM_SLAB_DEFINE_STATIC_TYPE(name, type, slab_num_blocks)                                 \
        K_MEM_SLAB_DEFINE_STATIC(name, sizeof(type), slab_num_blocks, __alignof(type))

int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
                           size_t block_size, uint32_t num_blocks);

int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
                            k_timeout_t timeout);

void k_mem_slab_free(struct k_mem_slab *slab, void *mem);

static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
{
        return slab->info.num_used;
}

static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
{
#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
        return slab->info.max_used;
#else
        ARG_UNUSED(slab);
        return 0;
#endif
}

static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
{
        return slab->info.num_blocks - slab->info.num_used;
}

 
int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);

int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);



struct k_heap {
        struct sys_heap heap;
        _wait_q_t wait_q;
        struct k_spinlock lock;
};

void k_heap_init(struct k_heap *h, void *mem,
                size_t bytes) __attribute_nonnull(1);

void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
                        k_timeout_t timeout) __attribute_nonnull(1);

void *k_heap_alloc(struct k_heap *h, size_t bytes,
                k_timeout_t timeout) __attribute_nonnull(1);

void *k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
        __attribute_nonnull(1);

void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
        __attribute_nonnull(1);

void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
 
/*
 * Heap sizing constants computed at build time from actual struct layouts
 * in lib/heap/heap_constants.c via the gen_offset mechanism.
 */
#include <zephyr/heap_constants.h>
 
/* chunk0 size in bytes for nb buckets (includes trailer metadata) */
#define _Z_HEAP_C0(nb) \
        (ROUND_UP(___z_heap_struct_SIZEOF + \
                  (nb) * ___z_heap_bucket_SIZEOF, ___z_heap_chunk_unit_SIZEOF) + \
         ___z_heap_trailer_SIZEOF)
 
/* Allocation chunk size in bytes (header + data rounded up, plus trailer) */
#define _Z_HEAP_AC(ab) \
        (ROUND_UP(___z_heap_hdr_SIZEOF + (ab), ___z_heap_chunk_unit_SIZEOF) + \
         ___z_heap_trailer_SIZEOF)
 
/* Total heap size in chunk units */
#define _Z_HEAP_SZ(nb, ab) \
        ((_Z_HEAP_C0(nb) + _Z_HEAP_AC(ab)) / ___z_heap_chunk_unit_SIZEOF)
 
/* Bucket count from heap size in chunk units (mirrors bucket_idx() + 1) */
#define _Z_HEAP_NB(sz) \
        (32 - __builtin_clz((unsigned int)((sz) - \
         ___z_heap_min_chunk_SIZEOF + 1)))
 
/* 3-round convergent iteration starting from 1 bucket */
#define _Z_HEAP_NB1(ab) _Z_HEAP_NB(_Z_HEAP_SZ(1, ab))
#define _Z_HEAP_NB2(ab) _Z_HEAP_NB(_Z_HEAP_SZ(_Z_HEAP_NB1(ab), ab))
#define _Z_HEAP_NB3(ab) _Z_HEAP_NB(_Z_HEAP_SZ(_Z_HEAP_NB2(ab), ab))

#define Z_HEAP_MIN_SIZE_FOR(alloc_bytes) \
        (_Z_HEAP_C0(_Z_HEAP_NB3(alloc_bytes)) + \
         _Z_HEAP_AC(alloc_bytes) + ___z_heap_ftr_SIZEOF)
 
#define Z_HEAP_MIN_SIZE Z_HEAP_MIN_SIZE_FOR(1)

#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section)          \
        char in_section                                         \
             __aligned(8) /* CHUNK_UNIT */                      \
             kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)];         \
        STRUCT_SECTION_ITERABLE(k_heap, name) = {               \
                .heap = {                                       \
                        .init_mem = kheap_##name,               \
                        .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
                 },                                             \
        }

#define K_HEAP_DEFINE(name, bytes)                              \
        Z_HEAP_DEFINE_IN_SECT(name, bytes,                      \
                              __noinit_named(kheap_buf_##name))

#define K_HEAP_DEFINE_NOCACHE(name, bytes)                      \
        Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)

int k_heap_array_get(struct k_heap **heap);



void *k_aligned_alloc(size_t align, size_t size);

void *k_malloc(size_t size);

void k_free(void *ptr);

void *k_calloc(size_t nmemb, size_t size);

void *k_realloc(void *ptr, size_t size);

 
/* polling API - PRIVATE */
 
#ifdef CONFIG_POLL
#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
#else
#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
#endif
 
/* private - types bit positions */
enum _poll_types_bits {
        /* can be used to ignore an event */
        _POLL_TYPE_IGNORE,
 
        /* to be signaled by k_poll_signal_raise() */
        _POLL_TYPE_SIGNAL,
 
        /* semaphore availability */
        _POLL_TYPE_SEM_AVAILABLE,
 
        /* queue/FIFO/LIFO data availability */
        _POLL_TYPE_DATA_AVAILABLE,
 
        /* msgq data availability */
        _POLL_TYPE_MSGQ_DATA_AVAILABLE,
 
        /* pipe data availability */
        _POLL_TYPE_PIPE_DATA_AVAILABLE,
 
        _POLL_NUM_TYPES
};
 
#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
 
/* private - states bit positions */
enum _poll_states_bits {
        /* default state when creating event */
        _POLL_STATE_NOT_READY,
 
        /* signaled by k_poll_signal_raise() */
        _POLL_STATE_SIGNALED,
 
        /* semaphore is available */
        _POLL_STATE_SEM_AVAILABLE,
 
        /* data is available to read on queue/FIFO/LIFO */
        _POLL_STATE_DATA_AVAILABLE,
 
        /* queue/FIFO/LIFO wait was cancelled */
        _POLL_STATE_CANCELLED,
 
        /* data is available to read on a message queue */
        _POLL_STATE_MSGQ_DATA_AVAILABLE,
 
        /* data is available to read from a pipe */
        _POLL_STATE_PIPE_DATA_AVAILABLE,
 
        _POLL_NUM_STATES
};
 
#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
 
#define _POLL_EVENT_NUM_UNUSED_BITS \
        (32 - (0 \
               + 8 /* tag */ \
               + _POLL_NUM_TYPES \
               + _POLL_NUM_STATES \
               + 1 /* modes */ \
              ))
 
/* end of polling API - PRIVATE */
 

 
/* Public polling API */
 
/* public - values for k_poll_event.type bitfield */
#define K_POLL_TYPE_IGNORE 0
#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
 
/* public - polling modes */
enum k_poll_modes {
        /* polling thread does not take ownership of objects when available */
        K_POLL_MODE_NOTIFY_ONLY = 0,
 
        K_POLL_NUM_MODES
};
 
/* public - values for k_poll_event.state bitfield */
#define K_POLL_STATE_NOT_READY 0
#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
 
/* public - poll signal object */
struct k_poll_signal {
        sys_dlist_t poll_events;

        unsigned int signaled;

        int result;
};
 
#define K_POLL_SIGNAL_INITIALIZER(obj) \
        { \
        .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
        .signaled = 0, \
        .result = 0, \
        }

struct k_poll_event {
        sys_dnode_t _node;

        struct z_poller *poller;

        uint32_t tag:8;

        uint32_t type:_POLL_NUM_TYPES;

        uint32_t state:_POLL_NUM_STATES;

        uint32_t mode:1;

        uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;

        union {
                /* The typed_* fields below are used by K_POLL_EVENT_*INITIALIZER() macros to ensure
                 * type safety of polled objects.
                 */
                void *obj, *typed_K_POLL_TYPE_IGNORE;
                struct k_poll_signal *signal, *typed_K_POLL_TYPE_SIGNAL;
                struct k_sem *sem, *typed_K_POLL_TYPE_SEM_AVAILABLE;
                struct k_fifo *fifo, *typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE;
                struct k_queue *queue, *typed_K_POLL_TYPE_DATA_AVAILABLE;
                struct k_msgq *msgq, *typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE;
                struct k_pipe *pipe, *typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE;
        };
};
 
#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
        { \
        .poller = NULL, \
        .type = _event_type, \
        .state = K_POLL_STATE_NOT_READY, \
        .mode = _event_mode, \
        .unused = 0, \
        { \
                .typed_##_event_type = _event_obj, \
        }, \
        }
 
#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
                                        event_tag) \
        { \
        .tag = event_tag, \
        .type = _event_type, \
        .state = K_POLL_STATE_NOT_READY, \
        .mode = _event_mode, \
        .unused = 0, \
        { \
                .typed_##_event_type = _event_obj, \
        }, \
        }

 
void k_poll_event_init(struct k_poll_event *event, uint32_t type,
                              int mode, void *obj);

 
__syscall int k_poll(struct k_poll_event *events, int num_events,
                     k_timeout_t timeout);

 
__syscall void k_poll_signal_init(struct k_poll_signal *sig);

__syscall void k_poll_signal_reset(struct k_poll_signal *sig);

__syscall void k_poll_signal_check(struct k_poll_signal *sig,
                                   unsigned int *signaled, int *result);

 
__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);


static inline void k_cpu_idle(void)
{
        arch_cpu_idle();
}

static inline void k_cpu_atomic_idle(unsigned int key)
{
        arch_cpu_atomic_idle(key);
}


#ifdef ARCH_EXCEPT
/* This architecture has direct support for triggering a CPU exception */
#define z_except_reason(reason) ARCH_EXCEPT(reason)
#else
 
#if !defined(CONFIG_ASSERT_NO_FILE_INFO)
#define __EXCEPT_LOC() __ASSERT_PRINT("@ %s:%d\n", __FILE__, __LINE__)
#else
#define __EXCEPT_LOC()
#endif
 
/* NOTE: This is the implementation for arches that do not implement
 * ARCH_EXCEPT() to generate a real CPU exception.
 *
 * We won't have a real exception frame to determine the PC value when
 * the oops occurred, so print file and line number before we jump into
 * the fatal error handler.
 */
#define z_except_reason(reason) do { \
                __EXCEPT_LOC();              \
                z_fatal_error(reason, NULL); \
        } while (false)
 
#endif /* _ARCH__EXCEPT */

#define k_oops()        z_except_reason(K_ERR_KERNEL_OOPS)

#define k_panic()       z_except_reason(K_ERR_KERNEL_PANIC)

/*
 * private APIs that are utilized by one or more public APIs
 */

void z_timer_expiration_handler(struct _timeout *timeout);
 
#ifdef CONFIG_PRINTK
__syscall void k_str_out(char *c, size_t n);
#endif


__syscall int k_float_disable(struct k_thread *thread);

__syscall int k_float_enable(struct k_thread *thread, unsigned int options);


int k_thread_runtime_stats_get(k_tid_t thread,
                               k_thread_runtime_stats_t *stats);

int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats);

int k_thread_runtime_stats_cpu_get(int cpu, k_thread_runtime_stats_t *stats);

int k_thread_runtime_stats_enable(k_tid_t thread);

int k_thread_runtime_stats_disable(k_tid_t thread);

bool k_thread_runtime_stats_is_enabled(k_tid_t thread);

void k_sys_runtime_stats_enable(void);

void k_sys_runtime_stats_disable(void);
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/tracing/tracing.h>
#include <zephyr/syscalls/kernel.h>
 
#endif /* !_ASMLANGUAGE */
 
#endif /* ZEPHYR_INCLUDE_KERNEL_H_ */