Zephyr API Documentation 4.0.99
A Scalable Open Source RTOS
 4.0.99
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
kernel.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016, Wind River Systems, Inc.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
13#ifndef ZEPHYR_INCLUDE_KERNEL_H_
14#define ZEPHYR_INCLUDE_KERNEL_H_
15
16#if !defined(_ASMLANGUAGE)
18#include <errno.h>
19#include <limits.h>
20#include <stdbool.h>
21#include <zephyr/toolchain.h>
25
26#ifdef __cplusplus
27extern "C" {
28#endif
29
30/*
31 * Zephyr currently assumes the size of a couple standard types to simplify
32 * print string formats. Let's make sure this doesn't change without notice.
33 */
34BUILD_ASSERT(sizeof(int32_t) == sizeof(int));
35BUILD_ASSERT(sizeof(int64_t) == sizeof(long long));
36BUILD_ASSERT(sizeof(intptr_t) == sizeof(long));
37
47#define K_ANY NULL
48
49#if (CONFIG_NUM_COOP_PRIORITIES + CONFIG_NUM_PREEMPT_PRIORITIES) == 0
50#error Zero available thread priorities defined!
51#endif
52
53#define K_PRIO_COOP(x) (-(CONFIG_NUM_COOP_PRIORITIES - (x)))
54#define K_PRIO_PREEMPT(x) (x)
55
56#define K_HIGHEST_THREAD_PRIO (-CONFIG_NUM_COOP_PRIORITIES)
57#define K_LOWEST_THREAD_PRIO CONFIG_NUM_PREEMPT_PRIORITIES
58#define K_IDLE_PRIO K_LOWEST_THREAD_PRIO
59#define K_HIGHEST_APPLICATION_THREAD_PRIO (K_HIGHEST_THREAD_PRIO)
60#define K_LOWEST_APPLICATION_THREAD_PRIO (K_LOWEST_THREAD_PRIO - 1)
61
62#ifdef CONFIG_POLL
63#define Z_POLL_EVENT_OBJ_INIT(obj) \
64 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events),
65#define Z_DECL_POLL_EVENT sys_dlist_t poll_events;
66#else
67#define Z_POLL_EVENT_OBJ_INIT(obj)
68#define Z_DECL_POLL_EVENT
69#endif
70
71struct k_thread;
72struct k_mutex;
73struct k_sem;
74struct k_msgq;
75struct k_mbox;
76struct k_pipe;
77struct k_queue;
78struct k_fifo;
79struct k_lifo;
80struct k_stack;
81struct k_mem_slab;
82struct k_timer;
83struct k_poll_event;
84struct k_poll_signal;
85struct k_mem_domain;
86struct k_mem_partition;
87struct k_futex;
88struct k_event;
89
95
96/* private, used by k_poll and k_work_poll */
97struct k_work_poll;
98typedef int (*_poller_cb_t)(struct k_poll_event *event, uint32_t state);
99
105typedef void (*k_thread_user_cb_t)(const struct k_thread *thread,
106 void *user_data);
107
123void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data);
124
143#ifdef CONFIG_SMP
144void k_thread_foreach_filter_by_cpu(unsigned int cpu,
145 k_thread_user_cb_t user_cb, void *user_data);
146#else
147static inline
148void k_thread_foreach_filter_by_cpu(unsigned int cpu,
149 k_thread_user_cb_t user_cb, void *user_data)
150{
151 __ASSERT(cpu == 0, "cpu filter out of bounds");
152 ARG_UNUSED(cpu);
153 k_thread_foreach(user_cb, user_data);
154}
155#endif
156
185 k_thread_user_cb_t user_cb, void *user_data);
186
218#ifdef CONFIG_SMP
220 k_thread_user_cb_t user_cb, void *user_data);
221#else
222static inline
223void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
224 k_thread_user_cb_t user_cb, void *user_data)
225{
226 __ASSERT(cpu == 0, "cpu filter out of bounds");
227 ARG_UNUSED(cpu);
228 k_thread_foreach_unlocked(user_cb, user_data);
229}
230#endif
231
240#endif /* !_ASMLANGUAGE */
241
242
243/*
244 * Thread user options. May be needed by assembly code. Common part uses low
245 * bits, arch-specific use high bits.
246 */
247
251#define K_ESSENTIAL (BIT(0))
252
253#define K_FP_IDX 1
263#define K_FP_REGS (BIT(K_FP_IDX))
264
271#define K_USER (BIT(2))
272
281#define K_INHERIT_PERMS (BIT(3))
282
292#define K_CALLBACK_STATE (BIT(4))
293
303#define K_DSP_IDX 6
304#define K_DSP_REGS (BIT(K_DSP_IDX))
305
314#define K_AGU_IDX 7
315#define K_AGU_REGS (BIT(K_AGU_IDX))
316
326#define K_SSE_REGS (BIT(7))
327
328/* end - thread options */
329
330#if !defined(_ASMLANGUAGE)
345__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);
346
360
409__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
410 k_thread_stack_t *stack,
411 size_t stack_size,
413 void *p1, void *p2, void *p3,
414 int prio, uint32_t options, k_timeout_t delay);
415
438 void *p1, void *p2,
439 void *p3);
440
454#define k_thread_access_grant(thread, ...) \
455 FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)
456
471static inline void k_thread_heap_assign(struct k_thread *thread,
472 struct k_heap *heap)
473{
474 thread->resource_pool = heap;
475}
476
477#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
498__syscall int k_thread_stack_space_get(const struct k_thread *thread,
499 size_t *unused_ptr);
500#endif
501
502#if (K_HEAP_MEM_POOL_SIZE > 0)
515void k_thread_system_pool_assign(struct k_thread *thread);
516#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */
517
537__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);
538
551__syscall int32_t k_sleep(k_timeout_t timeout);
552
564static inline int32_t k_msleep(int32_t ms)
565{
566 return k_sleep(Z_TIMEOUT_MS(ms));
567}
568
586
603__syscall void k_busy_wait(uint32_t usec_to_wait);
604
616bool k_can_yield(void);
617
625__syscall void k_yield(void);
626
636__syscall void k_wakeup(k_tid_t thread);
637
651__attribute_const__
653
660__attribute_const__
661static inline k_tid_t k_current_get(void)
662{
663#ifdef CONFIG_CURRENT_THREAD_USE_TLS
664
665 /* Thread-local cache of current thread ID, set in z_thread_entry() */
666 extern Z_THREAD_LOCAL k_tid_t z_tls_current;
667
668 return z_tls_current;
669#else
671#endif
672}
673
693__syscall void k_thread_abort(k_tid_t thread);
694
695k_ticks_t z_timeout_expires(const struct _timeout *timeout);
696k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
697
698#ifdef CONFIG_SYS_CLOCK_EXISTS
699
707__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
708
709static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
710 const struct k_thread *thread)
711{
712 return z_timeout_expires(&thread->base.timeout);
713}
714
723
724static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
725 const struct k_thread *thread)
726{
727 return z_timeout_remaining(&thread->base.timeout);
728}
729
730#endif /* CONFIG_SYS_CLOCK_EXISTS */
731
736struct _static_thread_data {
737 struct k_thread *init_thread;
738 k_thread_stack_t *init_stack;
739 unsigned int init_stack_size;
741 void *init_p1;
742 void *init_p2;
743 void *init_p3;
744 int init_prio;
745 uint32_t init_options;
746 const char *init_name;
747#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
748 int32_t init_delay_ms;
749#else
750 k_timeout_t init_delay;
751#endif
752};
753
754#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
755#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
756#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
757#else
758#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS(ms)
759#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
760#endif
761
762#define Z_THREAD_INITIALIZER(thread, stack, stack_size, \
763 entry, p1, p2, p3, \
764 prio, options, delay, tname) \
765 { \
766 .init_thread = (thread), \
767 .init_stack = (stack), \
768 .init_stack_size = (stack_size), \
769 .init_entry = (k_thread_entry_t)entry, \
770 .init_p1 = (void *)p1, \
771 .init_p2 = (void *)p2, \
772 .init_p3 = (void *)p3, \
773 .init_prio = (prio), \
774 .init_options = (options), \
775 .init_name = STRINGIFY(tname), \
776 Z_THREAD_INIT_DELAY_INITIALIZER(delay) \
777 }
778
779/*
780 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
781 * information on arguments.
782 */
783#define Z_THREAD_COMMON_DEFINE(name, stack_size, \
784 entry, p1, p2, p3, \
785 prio, options, delay) \
786 struct k_thread _k_thread_obj_##name; \
787 STRUCT_SECTION_ITERABLE(_static_thread_data, \
788 _k_thread_data_##name) = \
789 Z_THREAD_INITIALIZER(&_k_thread_obj_##name, \
790 _k_thread_stack_##name, stack_size,\
791 entry, p1, p2, p3, prio, options, \
792 delay, name); \
793 const k_tid_t name = (k_tid_t)&_k_thread_obj_##name
794
830#define K_THREAD_DEFINE(name, stack_size, \
831 entry, p1, p2, p3, \
832 prio, options, delay) \
833 K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
834 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
835 prio, options, delay)
836
867#define K_KERNEL_THREAD_DEFINE(name, stack_size, \
868 entry, p1, p2, p3, \
869 prio, options, delay) \
870 K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
871 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
872 prio, options, delay)
873
883__syscall int k_thread_priority_get(k_tid_t thread);
884
910__syscall void k_thread_priority_set(k_tid_t thread, int prio);
911
912
913#ifdef CONFIG_SCHED_DEADLINE
946__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);
947#endif
948
967__syscall void k_reschedule(void);
968
969#ifdef CONFIG_SCHED_CPU_MASK
983
997
1011
1025
1036int k_thread_cpu_pin(k_tid_t thread, int cpu);
1037#endif
1038
1060__syscall void k_thread_suspend(k_tid_t thread);
1061
1073__syscall void k_thread_resume(k_tid_t thread);
1074
1088static inline void k_thread_start(k_tid_t thread)
1089{
1090 k_wakeup(thread);
1091}
1092
1119void k_sched_time_slice_set(int32_t slice, int prio);
1120
1159void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
1160 k_thread_timeslice_fn_t expired, void *data);
1161
1180bool k_is_in_isr(void);
1181
1198__syscall int k_is_preempt_thread(void);
1199
1211static inline bool k_is_pre_kernel(void)
1212{
1213 extern bool z_sys_post_kernel; /* in init.c */
1214
1215 return !z_sys_post_kernel;
1216}
1217
1252void k_sched_lock(void);
1253
1262
1275__syscall void k_thread_custom_data_set(void *value);
1276
1284__syscall void *k_thread_custom_data_get(void);
1285
1299__syscall int k_thread_name_set(k_tid_t thread, const char *str);
1300
1309const char *k_thread_name_get(k_tid_t thread);
1310
1322__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
1323 size_t size);
1324
1337const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);
1338
1356#define K_NO_WAIT Z_TIMEOUT_NO_WAIT
1357
1370#define K_NSEC(t) Z_TIMEOUT_NS(t)
1371
1384#define K_USEC(t) Z_TIMEOUT_US(t)
1385
1396#define K_CYC(t) Z_TIMEOUT_CYC(t)
1397
1408#define K_TICKS(t) Z_TIMEOUT_TICKS(t)
1409
1420#define K_MSEC(ms) Z_TIMEOUT_MS(ms)
1421
1432#define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
1433
1444#define K_MINUTES(m) K_SECONDS((m) * 60)
1445
1456#define K_HOURS(h) K_MINUTES((h) * 60)
1457
1466#define K_FOREVER Z_FOREVER
1467
1468#ifdef CONFIG_TIMEOUT_64BIT
1469
1481#define K_TIMEOUT_ABS_TICKS(t) \
1482 Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)MAX(t, 0)))
1483
1495#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))
1496
1509#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))
1510
1523#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))
1524
1537#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
1538
1539#endif
1540
1549struct k_timer {
1550 /*
1551 * _timeout structure must be first here if we want to use
1552 * dynamic timer allocation. timeout.node is used in the double-linked
1553 * list of free timers
1554 */
1555 struct _timeout timeout;
1556
1557 /* wait queue for the (single) thread waiting on this timer */
1558 _wait_q_t wait_q;
1559
1560 /* runs in ISR context */
1561 void (*expiry_fn)(struct k_timer *timer);
1562
1563 /* runs in the context of the thread that calls k_timer_stop() */
1564 void (*stop_fn)(struct k_timer *timer);
1565
1566 /* timer period */
1567 k_timeout_t period;
1568
1569 /* timer status */
1570 uint32_t status;
1571
1572 /* user-specific data, also used to support legacy features */
1573 void *user_data;
1574
1576
1577#ifdef CONFIG_OBJ_CORE_TIMER
1578 struct k_obj_core obj_core;
1579#endif
1580};
1581
1582#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
1583 { \
1584 .timeout = { \
1585 .node = {},\
1586 .fn = z_timer_expiration_handler, \
1587 .dticks = 0, \
1588 }, \
1589 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1590 .expiry_fn = expiry, \
1591 .stop_fn = stop, \
1592 .status = 0, \
1593 .user_data = 0, \
1594 }
1595
1616typedef void (*k_timer_expiry_t)(struct k_timer *timer);
1617
1632typedef void (*k_timer_stop_t)(struct k_timer *timer);
1633
1645#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
1646 STRUCT_SECTION_ITERABLE(k_timer, name) = \
1647 Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
1648
1658void k_timer_init(struct k_timer *timer,
1659 k_timer_expiry_t expiry_fn,
1660 k_timer_stop_t stop_fn);
1661
1676__syscall void k_timer_start(struct k_timer *timer,
1677 k_timeout_t duration, k_timeout_t period);
1678
1695__syscall void k_timer_stop(struct k_timer *timer);
1696
1709__syscall uint32_t k_timer_status_get(struct k_timer *timer);
1710
1728__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
1729
1730#ifdef CONFIG_SYS_CLOCK_EXISTS
1731
1742__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
1743
1744static inline k_ticks_t z_impl_k_timer_expires_ticks(
1745 const struct k_timer *timer)
1746{
1747 return z_timeout_expires(&timer->timeout);
1748}
1749
1760__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
1761
1762static inline k_ticks_t z_impl_k_timer_remaining_ticks(
1763 const struct k_timer *timer)
1764{
1765 return z_timeout_remaining(&timer->timeout);
1766}
1767
1778static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
1779{
1781}
1782
1783#endif /* CONFIG_SYS_CLOCK_EXISTS */
1784
1797__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);
1798
1802static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
1803 void *user_data)
1804{
1805 timer->user_data = user_data;
1806}
1807
1815__syscall void *k_timer_user_data_get(const struct k_timer *timer);
1816
1817static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
1818{
1819 return timer->user_data;
1820}
1821
1839__syscall int64_t k_uptime_ticks(void);
1840
1854static inline int64_t k_uptime_get(void)
1855{
1857}
1858
1878static inline uint32_t k_uptime_get_32(void)
1879{
1880 return (uint32_t)k_uptime_get();
1881}
1882
1891static inline uint32_t k_uptime_seconds(void)
1892{
1894}
1895
1907static inline int64_t k_uptime_delta(int64_t *reftime)
1908{
1909 int64_t uptime, delta;
1910
1911 uptime = k_uptime_get();
1912 delta = uptime - *reftime;
1913 *reftime = uptime;
1914
1915 return delta;
1916}
1917
1926static inline uint32_t k_cycle_get_32(void)
1927{
1928 return arch_k_cycle_get_32();
1929}
1930
1941static inline uint64_t k_cycle_get_64(void)
1942{
1943 if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
1944 __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
1945 "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
1946 return 0;
1947 }
1948
1949 return arch_k_cycle_get_64();
1950}
1951
1956struct k_queue {
1959 _wait_q_t wait_q;
1960
1961 Z_DECL_POLL_EVENT
1962
1964};
1965
1970#define Z_QUEUE_INITIALIZER(obj) \
1971 { \
1972 .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
1973 .lock = { }, \
1974 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1975 Z_POLL_EVENT_OBJ_INIT(obj) \
1976 }
1977
1995__syscall void k_queue_init(struct k_queue *queue);
1996
2010__syscall void k_queue_cancel_wait(struct k_queue *queue);
2011
2024void k_queue_append(struct k_queue *queue, void *data);
2025
2042__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);
2043
2056void k_queue_prepend(struct k_queue *queue, void *data);
2057
2074__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);
2075
2089void k_queue_insert(struct k_queue *queue, void *prev, void *data);
2090
2109int k_queue_append_list(struct k_queue *queue, void *head, void *tail);
2110
2126int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);
2127
2145__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);
2146
2163bool k_queue_remove(struct k_queue *queue, void *data);
2164
2179bool k_queue_unique_append(struct k_queue *queue, void *data);
2180
2194__syscall int k_queue_is_empty(struct k_queue *queue);
2195
2196static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
2197{
2198 return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
2199}
2200
2210__syscall void *k_queue_peek_head(struct k_queue *queue);
2211
2221__syscall void *k_queue_peek_tail(struct k_queue *queue);
2222
2232#define K_QUEUE_DEFINE(name) \
2233 STRUCT_SECTION_ITERABLE(k_queue, name) = \
2234 Z_QUEUE_INITIALIZER(name)
2235
2238#ifdef CONFIG_USERSPACE
2248struct k_futex {
2250};
2251
2259struct z_futex_data {
2260 _wait_q_t wait_q;
2261 struct k_spinlock lock;
2262};
2263
2264#define Z_FUTEX_DATA_INITIALIZER(obj) \
2265 { \
2266 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q) \
2267 }
2268
2294__syscall int k_futex_wait(struct k_futex *futex, int expected,
2295 k_timeout_t timeout);
2296
2311__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);
2312
2314#endif
2315
2327struct k_event {
2328 _wait_q_t wait_q;
2331
2333
2334#ifdef CONFIG_OBJ_CORE_EVENT
2335 struct k_obj_core obj_core;
2336#endif
2337
2338};
2339
2340#define Z_EVENT_INITIALIZER(obj) \
2341 { \
2342 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2343 .events = 0 \
2344 }
2345
2353__syscall void k_event_init(struct k_event *event);
2354
2370__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);
2371
2387__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);
2388
2403__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
2404 uint32_t events_mask);
2405
2416__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);
2417
2439__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
2440 bool reset, k_timeout_t timeout);
2441
2463__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
2464 bool reset, k_timeout_t timeout);
2465
2474static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
2475{
2476 return k_event_wait(event, events_mask, false, K_NO_WAIT);
2477}
2478
2488#define K_EVENT_DEFINE(name) \
2489 STRUCT_SECTION_ITERABLE(k_event, name) = \
2490 Z_EVENT_INITIALIZER(name);
2491
2494struct k_fifo {
2495 struct k_queue _queue;
2496#ifdef CONFIG_OBJ_CORE_FIFO
2497 struct k_obj_core obj_core;
2498#endif
2499};
2500
2504#define Z_FIFO_INITIALIZER(obj) \
2505 { \
2506 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2507 }
2508
2526#define k_fifo_init(fifo) \
2527 ({ \
2528 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
2529 k_queue_init(&(fifo)->_queue); \
2530 K_OBJ_CORE_INIT(K_OBJ_CORE(fifo), _obj_type_fifo); \
2531 K_OBJ_CORE_LINK(K_OBJ_CORE(fifo)); \
2532 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo); \
2533 })
2534
2546#define k_fifo_cancel_wait(fifo) \
2547 ({ \
2548 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
2549 k_queue_cancel_wait(&(fifo)->_queue); \
2550 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
2551 })
2552
2565#define k_fifo_put(fifo, data) \
2566 ({ \
2567 void *_data = data; \
2568 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, _data); \
2569 k_queue_append(&(fifo)->_queue, _data); \
2570 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, _data); \
2571 })
2572
2589#define k_fifo_alloc_put(fifo, data) \
2590 ({ \
2591 void *_data = data; \
2592 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, _data); \
2593 int fap_ret = k_queue_alloc_append(&(fifo)->_queue, _data); \
2594 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, _data, fap_ret); \
2595 fap_ret; \
2596 })
2597
2612#define k_fifo_put_list(fifo, head, tail) \
2613 ({ \
2614 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
2615 k_queue_append_list(&(fifo)->_queue, head, tail); \
2616 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
2617 })
2618
2632#define k_fifo_put_slist(fifo, list) \
2633 ({ \
2634 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
2635 k_queue_merge_slist(&(fifo)->_queue, list); \
2636 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
2637 })
2638
2656#define k_fifo_get(fifo, timeout) \
2657 ({ \
2658 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
2659 void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
2660 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
2661 fg_ret; \
2662 })
2663
2677#define k_fifo_is_empty(fifo) \
2678 k_queue_is_empty(&(fifo)->_queue)
2679
2693#define k_fifo_peek_head(fifo) \
2694 ({ \
2695 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
2696 void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
2697 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
2698 fph_ret; \
2699 })
2700
2712#define k_fifo_peek_tail(fifo) \
2713 ({ \
2714 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
2715 void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
2716 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
2717 fpt_ret; \
2718 })
2719
2729#define K_FIFO_DEFINE(name) \
2730 STRUCT_SECTION_ITERABLE(k_fifo, name) = \
2731 Z_FIFO_INITIALIZER(name)
2732
2735struct k_lifo {
2736 struct k_queue _queue;
2737#ifdef CONFIG_OBJ_CORE_LIFO
2738 struct k_obj_core obj_core;
2739#endif
2740};
2741
2746#define Z_LIFO_INITIALIZER(obj) \
2747 { \
2748 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2749 }
2750
2768#define k_lifo_init(lifo) \
2769 ({ \
2770 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
2771 k_queue_init(&(lifo)->_queue); \
2772 K_OBJ_CORE_INIT(K_OBJ_CORE(lifo), _obj_type_lifo); \
2773 K_OBJ_CORE_LINK(K_OBJ_CORE(lifo)); \
2774 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo); \
2775 })
2776
2789#define k_lifo_put(lifo, data) \
2790 ({ \
2791 void *_data = data; \
2792 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, _data); \
2793 k_queue_prepend(&(lifo)->_queue, _data); \
2794 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, _data); \
2795 })
2796
2813#define k_lifo_alloc_put(lifo, data) \
2814 ({ \
2815 void *_data = data; \
2816 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, _data); \
2817 int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, _data); \
2818 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, _data, lap_ret); \
2819 lap_ret; \
2820 })
2821
2839#define k_lifo_get(lifo, timeout) \
2840 ({ \
2841 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
2842 void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
2843 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
2844 lg_ret; \
2845 })
2846
2856#define K_LIFO_DEFINE(name) \
2857 STRUCT_SECTION_ITERABLE(k_lifo, name) = \
2858 Z_LIFO_INITIALIZER(name)
2859
2865#define K_STACK_FLAG_ALLOC ((uint8_t)1) /* Buffer was allocated */
2866
2867typedef uintptr_t stack_data_t;
2868
2869struct k_stack {
2870 _wait_q_t wait_q;
2871 struct k_spinlock lock;
2872 stack_data_t *base, *next, *top;
2873
2874 uint8_t flags;
2875
2877
2878#ifdef CONFIG_OBJ_CORE_STACK
2879 struct k_obj_core obj_core;
2880#endif
2881};
2882
2883#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
2884 { \
2885 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
2886 .base = (stack_buffer), \
2887 .next = (stack_buffer), \
2888 .top = (stack_buffer) + (stack_num_entries), \
2889 }
2890
2910void k_stack_init(struct k_stack *stack,
2911 stack_data_t *buffer, uint32_t num_entries);
2912
2913
2928__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
2929 uint32_t num_entries);
2930
2942int k_stack_cleanup(struct k_stack *stack);
2943
2957__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);
2958
2979__syscall int k_stack_pop(struct k_stack *stack, stack_data_t *data,
2980 k_timeout_t timeout);
2981
2992#define K_STACK_DEFINE(name, stack_num_entries) \
2993 stack_data_t __noinit \
2994 _k_stack_buf_##name[stack_num_entries]; \
2995 STRUCT_SECTION_ITERABLE(k_stack, name) = \
2996 Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
2997 stack_num_entries)
2998
3005struct k_work;
3006struct k_work_q;
3007struct k_work_queue_config;
3008extern struct k_work_q k_sys_work_q;
3009
3024struct k_mutex {
3026 _wait_q_t wait_q;
3029
3032
3035
3037
3038#ifdef CONFIG_OBJ_CORE_MUTEX
3039 struct k_obj_core obj_core;
3040#endif
3041};
3042
3046#define Z_MUTEX_INITIALIZER(obj) \
3047 { \
3048 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3049 .owner = NULL, \
3050 .lock_count = 0, \
3051 .owner_orig_prio = K_LOWEST_APPLICATION_THREAD_PRIO, \
3052 }
3053
3067#define K_MUTEX_DEFINE(name) \
3068 STRUCT_SECTION_ITERABLE(k_mutex, name) = \
3069 Z_MUTEX_INITIALIZER(name)
3070
3083__syscall int k_mutex_init(struct k_mutex *mutex);
3084
3085
3107__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);
3108
3129__syscall int k_mutex_unlock(struct k_mutex *mutex);
3130
3137 _wait_q_t wait_q;
3138
3139#ifdef CONFIG_OBJ_CORE_CONDVAR
3140 struct k_obj_core obj_core;
3141#endif
3142};
3143
3144#define Z_CONDVAR_INITIALIZER(obj) \
3145 { \
3146 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
3147 }
3148
3161__syscall int k_condvar_init(struct k_condvar *condvar);
3162
3169__syscall int k_condvar_signal(struct k_condvar *condvar);
3170
3178__syscall int k_condvar_broadcast(struct k_condvar *condvar);
3179
3197__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
3198 k_timeout_t timeout);
3199
3210#define K_CONDVAR_DEFINE(name) \
3211 STRUCT_SECTION_ITERABLE(k_condvar, name) = \
3212 Z_CONDVAR_INITIALIZER(name)
3221struct k_sem {
3222 _wait_q_t wait_q;
3223 unsigned int count;
3224 unsigned int limit;
3225
3226 Z_DECL_POLL_EVENT
3227
3229
3230#ifdef CONFIG_OBJ_CORE_SEM
3231 struct k_obj_core obj_core;
3232#endif
3233};
3234
3235#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
3236 { \
3237 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3238 .count = (initial_count), \
3239 .limit = (count_limit), \
3240 Z_POLL_EVENT_OBJ_INIT(obj) \
3241 }
3242
3261#define K_SEM_MAX_LIMIT UINT_MAX
3262
3278__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
3279 unsigned int limit);
3280
3299__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);
3300
3311__syscall void k_sem_give(struct k_sem *sem);
3312
3322__syscall void k_sem_reset(struct k_sem *sem);
3323
3333__syscall unsigned int k_sem_count_get(struct k_sem *sem);
3334
3338static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
3339{
3340 return sem->count;
3341}
3342
3354#define K_SEM_DEFINE(name, initial_count, count_limit) \
3355 STRUCT_SECTION_ITERABLE(k_sem, name) = \
3356 Z_SEM_INITIALIZER(name, initial_count, count_limit); \
3357 BUILD_ASSERT(((count_limit) != 0) && \
3358 (((initial_count) < (count_limit)) || ((initial_count) == (count_limit))) && \
3359 ((count_limit) <= K_SEM_MAX_LIMIT));
3360
3367struct k_work_delayable;
3368struct k_work_sync;
3369
3386typedef void (*k_work_handler_t)(struct k_work *work);
3387
3401void k_work_init(struct k_work *work,
3403
3418int k_work_busy_get(const struct k_work *work);
3419
3433static inline bool k_work_is_pending(const struct k_work *work);
3434
3456 struct k_work *work);
3457
3466int k_work_submit(struct k_work *work);
3467
3492bool k_work_flush(struct k_work *work,
3493 struct k_work_sync *sync);
3494
3514int k_work_cancel(struct k_work *work);
3515
3546bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);
3547
3558
3579 k_thread_stack_t *stack, size_t stack_size,
3580 int prio, const struct k_work_queue_config *cfg);
3581
3591static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);
3592
3616int k_work_queue_drain(struct k_work_q *queue, bool plug);
3617
3632
3648
3664
3676static inline struct k_work_delayable *
3678
3693
3708static inline bool k_work_delayable_is_pending(
3709 const struct k_work_delayable *dwork);
3710
3725 const struct k_work_delayable *dwork);
3726
3741 const struct k_work_delayable *dwork);
3742
3771 struct k_work_delayable *dwork,
3772 k_timeout_t delay);
3773
3788 k_timeout_t delay);
3789
3826 struct k_work_delayable *dwork,
3827 k_timeout_t delay);
3828
3842 k_timeout_t delay);
3843
3869 struct k_work_sync *sync);
3870
3892
3922 struct k_work_sync *sync);
3923
3924enum {
3929 /* The atomic API is used for all work and queue flags fields to
3930 * enforce sequential consistency in SMP environments.
3931 */
3932
3933 /* Bits that represent the work item states. At least nine of the
3934 * combinations are distinct valid stable states.
3935 */
3936 K_WORK_RUNNING_BIT = 0,
3937 K_WORK_CANCELING_BIT = 1,
3938 K_WORK_QUEUED_BIT = 2,
3939 K_WORK_DELAYED_BIT = 3,
3940 K_WORK_FLUSHING_BIT = 4,
3941
3942 K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
3943 | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
3944
3945 /* Static work flags */
3946 K_WORK_DELAYABLE_BIT = 8,
3947 K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
3948
3949 /* Dynamic work queue flags */
3950 K_WORK_QUEUE_STARTED_BIT = 0,
3951 K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
3952 K_WORK_QUEUE_BUSY_BIT = 1,
3953 K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
3954 K_WORK_QUEUE_DRAIN_BIT = 2,
3955 K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
3956 K_WORK_QUEUE_PLUGGED_BIT = 3,
3957 K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
3958 K_WORK_QUEUE_STOP_BIT = 4,
3959 K_WORK_QUEUE_STOP = BIT(K_WORK_QUEUE_STOP_BIT),
3960
3961 /* Static work queue flags */
3962 K_WORK_QUEUE_NO_YIELD_BIT = 8,
3963 K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
3964
3968 /* Transient work flags */
3969
3975 K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),
3976
3981 K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),
3982
3988 K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),
3989
3995 K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),
3996
4001 K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
4002};
4003
4005struct k_work {
4006 /* All fields are protected by the work module spinlock. No fields
4007 * are to be accessed except through kernel API.
4008 */
4009
4010 /* Node to link into k_work_q pending list. */
4012
4013 /* The function to be invoked by the work queue thread. */
4015
4016 /* The queue on which the work item was last submitted. */
4018
4019 /* State of the work item.
4020 *
4021 * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
4022 *
4023 * It can be RUNNING and CANCELING simultaneously.
4024 */
4026};
4027
4028#define Z_WORK_INITIALIZER(work_handler) { \
4029 .handler = (work_handler), \
4030}
4031
4034 /* The work item. */
4035 struct k_work work;
4036
4037 /* Timeout used to submit work after a delay. */
4038 struct _timeout timeout;
4039
4040 /* The queue to which the work should be submitted. */
4042};
4043
4044#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
4045 .work = { \
4046 .handler = (work_handler), \
4047 .flags = K_WORK_DELAYABLE, \
4048 }, \
4049}
4050
4067#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
4068 struct k_work_delayable work \
4069 = Z_WORK_DELAYABLE_INITIALIZER(work_handler)
4070
4075/* Record used to wait for work to flush.
4076 *
4077 * The work item is inserted into the queue that will process (or is
4078 * processing) the item, and will be processed as soon as the item
4079 * completes. When the flusher is processed the semaphore will be
4080 * signaled, releasing the thread waiting for the flush.
4081 */
4082struct z_work_flusher {
4083 struct k_work work;
4084 struct k_sem sem;
4085};
4086
4087/* Record used to wait for work to complete a cancellation.
4088 *
4089 * The work item is inserted into a global queue of pending cancels.
4090 * When a cancelling work item goes idle any matching waiters are
4091 * removed from pending_cancels and are woken.
4092 */
4093struct z_work_canceller {
4094 sys_snode_t node;
4095 struct k_work *work;
4096 struct k_sem sem;
4097};
4098
4117 union {
4118 struct z_work_flusher flusher;
4119 struct z_work_canceller canceller;
4120 };
4121};
4122
4134 const char *name;
4135
4149
4154};
4155
4157struct k_work_q {
4158 /* The thread that animates the work. */
4160
4161 /* All the following fields must be accessed only while the
4162 * work module spinlock is held.
4163 */
4164
4165 /* List of k_work items to be worked. */
4167
4168 /* Wait queue for idle work thread. */
4169 _wait_q_t notifyq;
4170
4171 /* Wait queue for threads waiting for the queue to drain. */
4172 _wait_q_t drainq;
4173
4174 /* Flags describing queue state. */
4176};
4177
4178/* Provide the implementation for inline functions declared above */
4179
4180static inline bool k_work_is_pending(const struct k_work *work)
4181{
4182 return k_work_busy_get(work) != 0;
4183}
4184
4185static inline struct k_work_delayable *
4190
4192 const struct k_work_delayable *dwork)
4193{
4194 return k_work_delayable_busy_get(dwork) != 0;
4195}
4196
4198 const struct k_work_delayable *dwork)
4199{
4200 return z_timeout_expires(&dwork->timeout);
4201}
4202
4204 const struct k_work_delayable *dwork)
4205{
4206 return z_timeout_remaining(&dwork->timeout);
4207}
4208
4210{
4211 return &queue->thread;
4212}
4213
4216struct k_work_user;
4217
4232typedef void (*k_work_user_handler_t)(struct k_work_user *work);
4233
4238struct k_work_user_q {
4239 struct k_queue queue;
4240 struct k_thread thread;
4241};
4242
4243enum {
4244 K_WORK_USER_STATE_PENDING, /* Work item pending state */
4245};
4246
4247struct k_work_user {
4248 void *_reserved; /* Used by k_queue implementation. */
4249 k_work_user_handler_t handler;
4251};
4252
4257#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
4258#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
4259#else
4260#define Z_WORK_USER_INITIALIZER(work_handler) \
4261 { \
4262 ._reserved = NULL, \
4263 .handler = (work_handler), \
4264 .flags = 0 \
4265 }
4266#endif
4267
4279#define K_WORK_USER_DEFINE(work, work_handler) \
4280 struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)
4281
4291static inline void k_work_user_init(struct k_work_user *work,
4292 k_work_user_handler_t handler)
4293{
4294 *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
4295}
4296
4313static inline bool k_work_user_is_pending(struct k_work_user *work)
4314{
4315 return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
4316}
4317
4336static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
4337 struct k_work_user *work)
4338{
4339 int ret = -EBUSY;
4340
4341 if (!atomic_test_and_set_bit(&work->flags,
4342 K_WORK_USER_STATE_PENDING)) {
4343 ret = k_queue_alloc_append(&work_q->queue, work);
4344
4345 /* Couldn't insert into the queue. Clear the pending bit
4346 * so the work item can be submitted again
4347 */
4348 if (ret != 0) {
4349 atomic_clear_bit(&work->flags,
4350 K_WORK_USER_STATE_PENDING);
4351 }
4352 }
4353
4354 return ret;
4355}
4356
4376void k_work_user_queue_start(struct k_work_user_q *work_q,
4377 k_thread_stack_t *stack,
4378 size_t stack_size, int prio,
4379 const char *name);
4380
4391static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
4392{
4393 return &work_q->thread;
4394}
4395
4402struct k_work_poll {
4403 struct k_work work;
4404 struct k_work_q *workq;
4405 struct z_poller poller;
4406 struct k_poll_event *events;
4407 int num_events;
4408 k_work_handler_t real_handler;
4409 struct _timeout timeout;
4410 int poll_result;
4411};
4412
4433#define K_WORK_DEFINE(work, work_handler) \
4434 struct k_work work = Z_WORK_INITIALIZER(work_handler)
4435
4445void k_work_poll_init(struct k_work_poll *work,
4446 k_work_handler_t handler);
4447
4483 struct k_work_poll *work,
4484 struct k_poll_event *events,
4485 int num_events,
4486 k_timeout_t timeout);
4487
4519int k_work_poll_submit(struct k_work_poll *work,
4520 struct k_poll_event *events,
4521 int num_events,
4522 k_timeout_t timeout);
4523
4538int k_work_poll_cancel(struct k_work_poll *work);
4539
4551struct k_msgq {
4553 _wait_q_t wait_q;
4557 size_t msg_size;
4570
4571 Z_DECL_POLL_EVENT
4572
4575
4577
4578#ifdef CONFIG_OBJ_CORE_MSGQ
4579 struct k_obj_core obj_core;
4580#endif
4581};
4587#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
4588 { \
4589 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
4590 .msg_size = q_msg_size, \
4591 .max_msgs = q_max_msgs, \
4592 .buffer_start = q_buffer, \
4593 .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
4594 .read_ptr = q_buffer, \
4595 .write_ptr = q_buffer, \
4596 .used_msgs = 0, \
4597 Z_POLL_EVENT_OBJ_INIT(obj) \
4598 }
4599
4605#define K_MSGQ_FLAG_ALLOC BIT(0)
4606
4618
4619
4638#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align) \
4639 static char __noinit __aligned(q_align) \
4640 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
4641 STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
4642 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
4643 (q_msg_size), (q_max_msgs))
4644
4659void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
4660 uint32_t max_msgs);
4661
4681__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
4682 uint32_t max_msgs);
4683
4694int k_msgq_cleanup(struct k_msgq *msgq);
4695
4716__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);
4717
4738__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);
4739
4754__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);
4755
4772__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);
4773
4783__syscall void k_msgq_purge(struct k_msgq *msgq);
4784
4795__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);
4796
4805__syscall void k_msgq_get_attrs(struct k_msgq *msgq,
4806 struct k_msgq_attrs *attrs);
4807
4808
4809static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
4810{
4811 return msgq->max_msgs - msgq->used_msgs;
4812}
4813
4823__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
4824
4825static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
4826{
4827 return msgq->used_msgs;
4828}
4829
4844 size_t size;
4848 void *tx_data;
4854 k_tid_t _syncing_thread;
4855#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
4857 struct k_sem *_async_sem;
4858#endif
4859};
4864struct k_mbox {
4866 _wait_q_t tx_msg_queue;
4868 _wait_q_t rx_msg_queue;
4870
4872
4873#ifdef CONFIG_OBJ_CORE_MAILBOX
4874 struct k_obj_core obj_core;
4875#endif
4876};
4881#define Z_MBOX_INITIALIZER(obj) \
4882 { \
4883 .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
4884 .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
4885 }
4886
4900#define K_MBOX_DEFINE(name) \
4901 STRUCT_SECTION_ITERABLE(k_mbox, name) = \
4902 Z_MBOX_INITIALIZER(name) \
4903
4911void k_mbox_init(struct k_mbox *mbox);
4912
4932int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
4933 k_timeout_t timeout);
4934
4948void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
4949 struct k_sem *sem);
4950
4968int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
4969 void *buffer, k_timeout_t timeout);
4970
4984void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);
4985
4995struct k_pipe {
4996 unsigned char *buffer;
4997 size_t size;
4998 size_t bytes_used;
4999 size_t read_index;
5003 struct {
5004 _wait_q_t readers;
5005 _wait_q_t writers;
5008 Z_DECL_POLL_EVENT
5009
5013
5014#ifdef CONFIG_OBJ_CORE_PIPE
5015 struct k_obj_core obj_core;
5016#endif
5017};
5018
5022#define K_PIPE_FLAG_ALLOC BIT(0)
5024#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size) \
5025 { \
5026 .buffer = pipe_buffer, \
5027 .size = pipe_buffer_size, \
5028 .bytes_used = 0, \
5029 .read_index = 0, \
5030 .write_index = 0, \
5031 .lock = {}, \
5032 .wait_q = { \
5033 .readers = Z_WAIT_Q_INIT(&obj.wait_q.readers), \
5034 .writers = Z_WAIT_Q_INIT(&obj.wait_q.writers) \
5035 }, \
5036 Z_POLL_EVENT_OBJ_INIT(obj) \
5037 .flags = 0, \
5038 }
5039
5057#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align) \
5058 static unsigned char __noinit __aligned(pipe_align) \
5059 _k_pipe_buf_##name[pipe_buffer_size]; \
5060 STRUCT_SECTION_ITERABLE(k_pipe, name) = \
5061 Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
5062
5074void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size);
5075
5087int k_pipe_cleanup(struct k_pipe *pipe);
5088
5104__syscall int k_pipe_alloc_init(struct k_pipe *pipe, size_t size);
5105
5124__syscall int k_pipe_put(struct k_pipe *pipe, const void *data,
5125 size_t bytes_to_write, size_t *bytes_written,
5126 size_t min_xfer, k_timeout_t timeout);
5127
5147__syscall int k_pipe_get(struct k_pipe *pipe, void *data,
5148 size_t bytes_to_read, size_t *bytes_read,
5149 size_t min_xfer, k_timeout_t timeout);
5150
5159__syscall size_t k_pipe_read_avail(struct k_pipe *pipe);
5160
5169__syscall size_t k_pipe_write_avail(struct k_pipe *pipe);
5170
5181__syscall void k_pipe_flush(struct k_pipe *pipe);
5182
5194__syscall void k_pipe_buffer_flush(struct k_pipe *pipe);
5195
5202struct k_mem_slab_info {
5203 uint32_t num_blocks;
5204 size_t block_size;
5205 uint32_t num_used;
5206#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5207 uint32_t max_used;
5208#endif
5209};
5210
5211struct k_mem_slab {
5212 _wait_q_t wait_q;
5213 struct k_spinlock lock;
5214 char *buffer;
5215 char *free_list;
5216 struct k_mem_slab_info info;
5217
5219
5220#ifdef CONFIG_OBJ_CORE_MEM_SLAB
5221 struct k_obj_core obj_core;
5222#endif
5223};
5224
5225#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
5226 _slab_num_blocks) \
5227 { \
5228 .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q), \
5229 .lock = {}, \
5230 .buffer = _slab_buffer, \
5231 .free_list = NULL, \
5232 .info = {_slab_num_blocks, _slab_block_size, 0} \
5233 }
5234
5235
5269#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align) \
5270 char __noinit_named(k_mem_slab_buf_##name) \
5271 __aligned(WB_UP(slab_align)) \
5272 _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5273 STRUCT_SECTION_ITERABLE(k_mem_slab, name) = \
5274 Z_MEM_SLAB_INITIALIZER(name, _k_mem_slab_buf_##name, \
5275 WB_UP(slab_block_size), slab_num_blocks)
5276
5291#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align) \
5292 static char __noinit_named(k_mem_slab_buf_##name) \
5293 __aligned(WB_UP(slab_align)) \
5294 _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5295 static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = \
5296 Z_MEM_SLAB_INITIALIZER(name, _k_mem_slab_buf_##name, \
5297 WB_UP(slab_block_size), slab_num_blocks)
5298
5320int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
5321 size_t block_size, uint32_t num_blocks);
5322
5345int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
5346 k_timeout_t timeout);
5347
5357void k_mem_slab_free(struct k_mem_slab *slab, void *mem);
5358
5369static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
5370{
5371 return slab->info.num_used;
5372}
5373
5384static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
5385{
5386#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5387 return slab->info.max_used;
5388#else
5389 ARG_UNUSED(slab);
5390 return 0;
5391#endif
5392}
5393
5404static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
5405{
5406 return slab->info.num_blocks - slab->info.num_used;
5407}
5408
5421int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);
5422
5434int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);
5435
5443/* kernel synchronized heap struct */
5444
5445struct k_heap {
5447 _wait_q_t wait_q;
5449};
5450
5464void k_heap_init(struct k_heap *h, void *mem,
5465 size_t bytes) __attribute_nonnull(1);
5466
5487void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
5488 k_timeout_t timeout) __attribute_nonnull(1);
5489
5511void *k_heap_alloc(struct k_heap *h, size_t bytes,
5512 k_timeout_t timeout) __attribute_nonnull(1);
5513
5536void *k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
5537 __attribute_nonnull(1);
5538
5562void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
5563 __attribute_nonnull(1);
5564
5575void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
5576
5577/* Hand-calculated minimum heap sizes needed to return a successful
5578 * 1-byte allocation. See details in lib/os/heap.[ch]
5579 */
5580#define Z_HEAP_MIN_SIZE ((sizeof(void *) > 4) ? 56 : 44)
5581
5598#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section) \
5599 char in_section \
5600 __aligned(8) /* CHUNK_UNIT */ \
5601 kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)]; \
5602 STRUCT_SECTION_ITERABLE(k_heap, name) = { \
5603 .heap = { \
5604 .init_mem = kheap_##name, \
5605 .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
5606 }, \
5607 }
5608
5623#define K_HEAP_DEFINE(name, bytes) \
5624 Z_HEAP_DEFINE_IN_SECT(name, bytes, \
5625 __noinit_named(kheap_buf_##name))
5626
5641#define K_HEAP_DEFINE_NOCACHE(name, bytes) \
5642 Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)
5643
5672void *k_aligned_alloc(size_t align, size_t size);
5673
5685void *k_malloc(size_t size);
5686
5697void k_free(void *ptr);
5698
5710void *k_calloc(size_t nmemb, size_t size);
5711
5729void *k_realloc(void *ptr, size_t size);
5730
5733/* polling API - PRIVATE */
5734
5735#ifdef CONFIG_POLL
5736#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
5737#else
5738#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
5739#endif
5740
5741/* private - types bit positions */
5742enum _poll_types_bits {
5743 /* can be used to ignore an event */
5744 _POLL_TYPE_IGNORE,
5745
5746 /* to be signaled by k_poll_signal_raise() */
5747 _POLL_TYPE_SIGNAL,
5748
5749 /* semaphore availability */
5750 _POLL_TYPE_SEM_AVAILABLE,
5751
5752 /* queue/FIFO/LIFO data availability */
5753 _POLL_TYPE_DATA_AVAILABLE,
5754
5755 /* msgq data availability */
5756 _POLL_TYPE_MSGQ_DATA_AVAILABLE,
5757
5758 /* pipe data availability */
5759 _POLL_TYPE_PIPE_DATA_AVAILABLE,
5760
5761 _POLL_NUM_TYPES
5762};
5763
5764#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
5765
5766/* private - states bit positions */
5767enum _poll_states_bits {
5768 /* default state when creating event */
5769 _POLL_STATE_NOT_READY,
5770
5771 /* signaled by k_poll_signal_raise() */
5772 _POLL_STATE_SIGNALED,
5773
5774 /* semaphore is available */
5775 _POLL_STATE_SEM_AVAILABLE,
5776
5777 /* data is available to read on queue/FIFO/LIFO */
5778 _POLL_STATE_DATA_AVAILABLE,
5779
5780 /* queue/FIFO/LIFO wait was cancelled */
5781 _POLL_STATE_CANCELLED,
5782
5783 /* data is available to read on a message queue */
5784 _POLL_STATE_MSGQ_DATA_AVAILABLE,
5785
5786 /* data is available to read from a pipe */
5787 _POLL_STATE_PIPE_DATA_AVAILABLE,
5788
5789 _POLL_NUM_STATES
5790};
5791
5792#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
5793
5794#define _POLL_EVENT_NUM_UNUSED_BITS \
5795 (32 - (0 \
5796 + 8 /* tag */ \
5797 + _POLL_NUM_TYPES \
5798 + _POLL_NUM_STATES \
5799 + 1 /* modes */ \
5800 ))
5801
5802/* end of polling API - PRIVATE */
5803
5804
5811/* Public polling API */
5812
5813/* public - values for k_poll_event.type bitfield */
5814#define K_POLL_TYPE_IGNORE 0
5815#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
5816#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
5817#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
5818#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
5819#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
5820#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
5821
5822/* public - polling modes */
5824 /* polling thread does not take ownership of objects when available */
5826
5829
5830/* public - values for k_poll_event.state bitfield */
5831#define K_POLL_STATE_NOT_READY 0
5832#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
5833#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
5834#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
5835#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
5836#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
5837#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
5838#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
5839
5840/* public - poll signal object */
5844
5849 unsigned int signaled;
5850
5853};
5854
5855#define K_POLL_SIGNAL_INITIALIZER(obj) \
5856 { \
5857 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
5858 .signaled = 0, \
5859 .result = 0, \
5860 }
5867 sys_dnode_t _node;
5868
5870 struct z_poller *poller;
5871
5874
5876 uint32_t type:_POLL_NUM_TYPES;
5877
5879 uint32_t state:_POLL_NUM_STATES;
5880
5883
5885 uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
5886
5888 union {
5889 /* The typed_* fields below are used by K_POLL_EVENT_*INITIALIZER() macros to ensure
5890 * type safety of polled objects.
5891 */
5892 void *obj, *typed_K_POLL_TYPE_IGNORE;
5893 struct k_poll_signal *signal, *typed_K_POLL_TYPE_SIGNAL;
5894 struct k_sem *sem, *typed_K_POLL_TYPE_SEM_AVAILABLE;
5895 struct k_fifo *fifo, *typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE;
5896 struct k_queue *queue, *typed_K_POLL_TYPE_DATA_AVAILABLE;
5897 struct k_msgq *msgq, *typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE;
5898#ifdef CONFIG_PIPES
5899 struct k_pipe *pipe, *typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE;
5900#endif
5901 };
5902};
5903
5904#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
5905 { \
5906 .poller = NULL, \
5907 .type = _event_type, \
5908 .state = K_POLL_STATE_NOT_READY, \
5909 .mode = _event_mode, \
5910 .unused = 0, \
5911 { \
5912 .typed_##_event_type = _event_obj, \
5913 }, \
5914 }
5915
5916#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
5917 event_tag) \
5918 { \
5919 .tag = event_tag, \
5920 .type = _event_type, \
5921 .state = K_POLL_STATE_NOT_READY, \
5922 .mode = _event_mode, \
5923 .unused = 0, \
5924 { \
5925 .typed_##_event_type = _event_obj, \
5926 }, \
5927 }
5928
5944void k_poll_event_init(struct k_poll_event *event, uint32_t type,
5945 int mode, void *obj);
5946
5990__syscall int k_poll(struct k_poll_event *events, int num_events,
5991 k_timeout_t timeout);
5992
6001__syscall void k_poll_signal_init(struct k_poll_signal *sig);
6002
6008__syscall void k_poll_signal_reset(struct k_poll_signal *sig);
6009
6020__syscall void k_poll_signal_check(struct k_poll_signal *sig,
6021 unsigned int *signaled, int *result);
6022
6047__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);
6048
6069static inline void k_cpu_idle(void)
6070{
6071 arch_cpu_idle();
6072}
6073
6088static inline void k_cpu_atomic_idle(unsigned int key)
6089{
6091}
6092
6101#ifdef ARCH_EXCEPT
6102/* This architecture has direct support for triggering a CPU exception */
6103#define z_except_reason(reason) ARCH_EXCEPT(reason)
6104#else
6105
6106#if !defined(CONFIG_ASSERT_NO_FILE_INFO)
6107#define __EXCEPT_LOC() __ASSERT_PRINT("@ %s:%d\n", __FILE__, __LINE__)
6108#else
6109#define __EXCEPT_LOC()
6110#endif
6111
6112/* NOTE: This is the implementation for arches that do not implement
6113 * ARCH_EXCEPT() to generate a real CPU exception.
6114 *
6115 * We won't have a real exception frame to determine the PC value when
6116 * the oops occurred, so print file and line number before we jump into
6117 * the fatal error handler.
6118 */
6119#define z_except_reason(reason) do { \
6120 __EXCEPT_LOC(); \
6121 z_fatal_error(reason, NULL); \
6122 } while (false)
6123
6124#endif /* _ARCH__EXCEPT */
6140#define k_oops() z_except_reason(K_ERR_KERNEL_OOPS)
6141
6150#define k_panic() z_except_reason(K_ERR_KERNEL_PANIC)
6151
6156/*
6157 * private APIs that are utilized by one or more public APIs
6158 */
6159
6163void z_timer_expiration_handler(struct _timeout *timeout);
6168#ifdef CONFIG_PRINTK
6176__syscall void k_str_out(char *c, size_t n);
6177#endif
6178
6205__syscall int k_float_disable(struct k_thread *thread);
6206
6245__syscall int k_float_enable(struct k_thread *thread, unsigned int options);
6246
6260
6268
6277
6288
6299
6308
6317
6318#ifdef __cplusplus
6319}
6320#endif
6321
6322#include <zephyr/tracing/tracing.h>
6323#include <zephyr/syscalls/kernel.h>
6324
6325#endif /* !_ASMLANGUAGE */
6326
6327#endif /* ZEPHYR_INCLUDE_KERNEL_H_ */
static uint32_t arch_k_cycle_get_32(void)
Definition misc.h:26
static uint64_t arch_k_cycle_get_64(void)
Definition misc.h:33
void(* k_thread_entry_t)(void *p1, void *p2, void *p3)
Thread entry point function type.
Definition arch_interface.h:48
struct z_thread_stack_element k_thread_stack_t
Typedef of struct z_thread_stack_element.
Definition arch_interface.h:46
long atomic_t
Definition atomic_types.h:15
System error numbers.
void arch_cpu_atomic_idle(unsigned int key)
Atomically re-enable interrupts and enter low power mode.
void arch_cpu_idle(void)
Power save idle routine.
static bool atomic_test_bit(const atomic_t *target, int bit)
Atomically get and test a bit.
Definition atomic.h:127
static void atomic_clear_bit(atomic_t *target, int bit)
Atomically clear a bit.
Definition atomic.h:191
static bool atomic_test_and_set_bit(atomic_t *target, int bit)
Atomically set a bit and test it.
Definition atomic.h:170
static uint32_t k_cycle_get_32(void)
Read the hardware clock.
Definition kernel.h:1926
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1356
int64_t k_uptime_ticks(void)
Get system uptime, in system ticks.
static uint32_t k_uptime_get_32(void)
Get system uptime (32-bit version).
Definition kernel.h:1878
uint32_t k_ticks_t
Tick precision used in timeout APIs.
Definition sys_clock.h:48
static int64_t k_uptime_delta(int64_t *reftime)
Get elapsed time.
Definition kernel.h:1907
static uint32_t k_uptime_seconds(void)
Get system uptime in seconds.
Definition kernel.h:1891
static uint64_t k_cycle_get_64(void)
Read the 64-bit hardware clock.
Definition kernel.h:1941
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:1854
int k_condvar_signal(struct k_condvar *condvar)
Signals one thread that is pending on the condition variable.
int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex, k_timeout_t timeout)
Waits on the condition variable releasing the mutex lock.
int k_condvar_init(struct k_condvar *condvar)
Initialize a condition variable.
int k_condvar_broadcast(struct k_condvar *condvar)
Unblock all threads that are pending on the condition variable.
static void k_cpu_idle(void)
Make the CPU idle.
Definition kernel.h:6069
static void k_cpu_atomic_idle(unsigned int key)
Make the CPU idle in an atomic fashion.
Definition kernel.h:6088
struct _dnode sys_dnode_t
Doubly-linked list node structure.
Definition dlist.h:54
struct _dnode sys_dlist_t
Doubly-linked list structure.
Definition dlist.h:50
uint32_t k_event_wait(struct k_event *event, uint32_t events, bool reset, k_timeout_t timeout)
Wait for any of the specified events.
uint32_t k_event_set_masked(struct k_event *event, uint32_t events, uint32_t events_mask)
Set or clear the events in an event object.
static uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
Test the events currently tracked in the event object.
Definition kernel.h:2474
uint32_t k_event_set(struct k_event *event, uint32_t events)
Set the events in an event object.
uint32_t k_event_post(struct k_event *event, uint32_t events)
Post one or more events to an event object.
void k_event_init(struct k_event *event)
Initialize an event object.
uint32_t k_event_clear(struct k_event *event, uint32_t events)
Clear the events in an event object.
uint32_t k_event_wait_all(struct k_event *event, uint32_t events, bool reset, k_timeout_t timeout)
Wait for all of the specified events.
struct _sflist sys_sflist_t
Flagged single-linked list structure.
Definition sflist.h:54
static bool sys_sflist_is_empty(sys_sflist_t *list)
Test if the given list is empty.
Definition sflist.h:336
int k_float_disable(struct k_thread *thread)
Disable preservation of floating point context information.
int k_float_enable(struct k_thread *thread, unsigned int options)
Enable preservation of floating point context information.
int k_futex_wait(struct k_futex *futex, int expected, k_timeout_t timeout)
Pend the current thread on a futex.
int k_futex_wake(struct k_futex *futex, bool wake_all)
Wake one/all threads pending on a futex.
void * k_heap_alloc(struct k_heap *h, size_t bytes, k_timeout_t timeout)
Allocate memory from a k_heap.
void * k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
Allocate and initialize memory for an array of objects from a k_heap.
void k_heap_free(struct k_heap *h, void *mem)
Free memory allocated by k_heap_alloc()
void k_free(void *ptr)
Free memory allocated from heap.
void * k_realloc(void *ptr, size_t size)
Expand the size of an existing allocation.
void k_heap_init(struct k_heap *h, void *mem, size_t bytes)
Initialize a k_heap.
void * k_malloc(size_t size)
Allocate memory from the heap.
void * k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
Reallocate memory from a k_heap.
void * k_calloc(size_t nmemb, size_t size)
Allocate memory from heap, array style.
void * k_aligned_alloc(size_t align, size_t size)
Allocate memory from the heap with a specified alignment.
void * k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes, k_timeout_t timeout)
Allocate aligned memory from a k_heap.
bool k_is_in_isr(void)
Determine if code is running at interrupt level.
int k_is_preempt_thread(void)
Determine if code is running in a preemptible thread.
static bool k_is_pre_kernel(void)
Test whether startup is in the before-main-task phase.
Definition kernel.h:1211
int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg, void *buffer, k_timeout_t timeout)
Receive a mailbox message.
void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer)
Retrieve mailbox message data into a buffer.
void k_mbox_init(struct k_mbox *mbox)
Initialize a mailbox.
int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, k_timeout_t timeout)
Send a mailbox message in a synchronous manner.
void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, struct k_sem *sem)
Send a mailbox message in an asynchronous manner.
int k_mem_slab_init(struct k_mem_slab *slab, void *buffer, size_t block_size, uint32_t num_blocks)
Initialize a memory slab.
void k_mem_slab_free(struct k_mem_slab *slab, void *mem)
Free memory allocated from a memory slab.
int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats)
Get the memory stats for a memory slab.
int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab)
Reset the maximum memory usage for a slab.
int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem, k_timeout_t timeout)
Allocate memory from a memory slab.
static uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
Get the number of used blocks in a memory slab.
Definition kernel.h:5369
static uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
Get the number of maximum used blocks so far in a memory slab.
Definition kernel.h:5384
static uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
Get the number of unused blocks in a memory slab.
Definition kernel.h:5404
int k_msgq_peek(struct k_msgq *msgq, void *data)
Peek/read a message from a message queue.
uint32_t k_msgq_num_used_get(struct k_msgq *msgq)
Get the number of messages in a message queue.
void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size, uint32_t max_msgs)
Initialize a message queue.
int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout)
Send a message to a message queue.
int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx)
Peek/read a message from a message queue at the specified index.
uint32_t k_msgq_num_free_get(struct k_msgq *msgq)
Get the amount of free space in a message queue.
void k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs *attrs)
Get basic attributes of a message queue.
void k_msgq_purge(struct k_msgq *msgq)
Purge a message queue.
int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size, uint32_t max_msgs)
Initialize a message queue.
int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout)
Receive a message from a message queue.
int k_msgq_cleanup(struct k_msgq *msgq)
Release allocated buffer for a queue.
int k_mutex_unlock(struct k_mutex *mutex)
Unlock a mutex.
int k_mutex_init(struct k_mutex *mutex)
Initialize a mutex.
int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout)
Lock a mutex.
size_t k_pipe_read_avail(struct k_pipe *pipe)
Query the number of bytes that may be read from pipe.
int k_pipe_alloc_init(struct k_pipe *pipe, size_t size)
Initialize a pipe and allocate a buffer for it.
void k_pipe_flush(struct k_pipe *pipe)
Flush the pipe of write data.
void k_pipe_buffer_flush(struct k_pipe *pipe)
Flush the pipe's internal buffer.
int k_pipe_cleanup(struct k_pipe *pipe)
Release a pipe's allocated buffer.
int k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read, size_t *bytes_read, size_t min_xfer, k_timeout_t timeout)
Read data from a pipe.
void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)
Initialize a pipe.
size_t k_pipe_write_avail(struct k_pipe *pipe)
Query the number of bytes that may be written to pipe.
int k_pipe_put(struct k_pipe *pipe, const void *data, size_t bytes_to_write, size_t *bytes_written, size_t min_xfer, k_timeout_t timeout)
Write data to a pipe.
void k_poll_signal_reset(struct k_poll_signal *sig)
Reset a poll signal object's state to unsignaled.
k_poll_modes
Definition kernel.h:5823
void k_poll_signal_check(struct k_poll_signal *sig, unsigned int *signaled, int *result)
Fetch the signaled state and result value of a poll signal.
void k_poll_event_init(struct k_poll_event *event, uint32_t type, int mode, void *obj)
Initialize one struct k_poll_event instance.
int k_poll(struct k_poll_event *events, int num_events, k_timeout_t timeout)
Wait for one or many of multiple poll events to occur.
int k_poll_signal_raise(struct k_poll_signal *sig, int result)
Signal a poll signal object.
void k_poll_signal_init(struct k_poll_signal *sig)
Initialize a poll signal object.
@ K_POLL_MODE_NOTIFY_ONLY
Definition kernel.h:5825
@ K_POLL_NUM_MODES
Definition kernel.h:5827
void k_queue_init(struct k_queue *queue)
Initialize a queue.
void * k_queue_get(struct k_queue *queue, k_timeout_t timeout)
Get an element from a queue.
void * k_queue_peek_tail(struct k_queue *queue)
Peek element at the tail of queue.
bool k_queue_unique_append(struct k_queue *queue, void *data)
Append an element to a queue only if it's not present already.
bool k_queue_remove(struct k_queue *queue, void *data)
Remove an element from a queue.
int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list)
Atomically add a list of elements to a queue.
int32_t k_queue_alloc_append(struct k_queue *queue, void *data)
Append an element to a queue.
void k_queue_cancel_wait(struct k_queue *queue)
Cancel waiting on a queue.
void * k_queue_peek_head(struct k_queue *queue)
Peek element at the head of queue.
void k_queue_prepend(struct k_queue *queue, void *data)
Prepend an element to a queue.
int k_queue_append_list(struct k_queue *queue, void *head, void *tail)
Atomically append a list of elements to a queue.
void k_queue_append(struct k_queue *queue, void *data)
Append an element to the end of a queue.
int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data)
Prepend an element to a queue.
void k_queue_insert(struct k_queue *queue, void *prev, void *data)
Inserts an element to a queue.
int k_queue_is_empty(struct k_queue *queue)
Query a queue to see if it has data available.
void k_sem_reset(struct k_sem *sem)
Resets a semaphore's count to zero.
unsigned int k_sem_count_get(struct k_sem *sem)
Get a semaphore's count.
void k_sem_give(struct k_sem *sem)
Give a semaphore.
int k_sem_take(struct k_sem *sem, k_timeout_t timeout)
Take a semaphore.
int k_sem_init(struct k_sem *sem, unsigned int initial_count, unsigned int limit)
Initialize a semaphore.
struct _slist sys_slist_t
Single-linked list structure.
Definition slist.h:49
struct _snode sys_snode_t
Single-linked list node structure.
Definition slist.h:39
int k_stack_pop(struct k_stack *stack, stack_data_t *data, k_timeout_t timeout)
Pop an element from a stack.
void k_stack_init(struct k_stack *stack, stack_data_t *buffer, 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.
int32_t k_stack_alloc_init(struct k_stack *stack, uint32_t num_entries)
Initialize a stack.
#define SYS_PORT_TRACING_TRACKING_FIELD(type)
Field added to kernel objects so they are tracked.
Definition tracing_macros.h:366
#define IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition util_macro.h:148
#define BIT(n)
Unsigned integer with bit position n set (signed in assembly language).
Definition util_macro.h:44
#define CONTAINER_OF(ptr, type, field)
Get a pointer to a structure containing the element.
Definition util.h:284
#define EBUSY
Mount device busy.
Definition errno.h:54
int k_thread_name_copy(k_tid_t thread, char *buf, size_t size)
Copy the thread name into a supplied buffer.
void k_yield(void)
Yield the current thread.
const char * k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size)
Get thread state string.
void k_thread_resume(k_tid_t thread)
Resume a suspended thread.
void * k_thread_custom_data_get(void)
Get current thread's custom data.
void k_thread_abort(k_tid_t thread)
Abort a thread.
int k_thread_name_set(k_tid_t thread, const char *str)
Set current thread name.
void k_thread_priority_set(k_tid_t thread, int prio)
Set a thread's priority.
int k_thread_cpu_mask_enable(k_tid_t thread, int cpu)
Enable thread to run on specified CPU.
void k_thread_foreach_unlocked(k_thread_user_cb_t user_cb, void *user_data)
Iterate over all the threads in the system without locking.
bool k_can_yield(void)
Check whether it is possible to yield in the current context.
int k_thread_priority_get(k_tid_t thread)
Get a thread's priority.
static void k_thread_heap_assign(struct k_thread *thread, struct k_heap *heap)
Assign a resource memory pool to a thread.
Definition kernel.h:471
FUNC_NORETURN void k_thread_user_mode_enter(k_thread_entry_t entry, void *p1, void *p2, void *p3)
Drop a thread's privileges permanently to user mode.
int k_thread_join(struct k_thread *thread, k_timeout_t timeout)
Sleep until a thread exits.
k_ticks_t k_thread_timeout_remaining_ticks(const struct k_thread *thread)
Get time remaining before a thread wakes up, in system ticks.
void k_thread_custom_data_set(void *value)
Set current thread's custom data.
int32_t k_sleep(k_timeout_t timeout)
Put the current thread to sleep.
void k_sched_lock(void)
Lock the scheduler.
static int32_t k_msleep(int32_t ms)
Put the current thread to sleep.
Definition kernel.h:564
void k_busy_wait(uint32_t usec_to_wait)
Cause the current thread to busy wait.
void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks, k_thread_timeslice_fn_t expired, void *data)
Set thread time slice.
void k_thread_suspend(k_tid_t thread)
Suspend a thread.
void k_sched_unlock(void)
Unlock the scheduler.
static __attribute_const__ k_tid_t k_current_get(void)
Get thread ID of the current thread.
Definition kernel.h:661
int k_thread_cpu_mask_clear(k_tid_t thread)
Sets all CPU enable masks to zero.
void k_thread_foreach_filter_by_cpu(unsigned int cpu, k_thread_user_cb_t user_cb, void *user_data)
Iterate over all the threads in running on specified cpu.
void k_sched_time_slice_set(int32_t slice, int prio)
Set time-slicing period and scope.
int k_thread_cpu_mask_disable(k_tid_t thread, int cpu)
Prevent thread to run on specified CPU.
void k_wakeup(k_tid_t thread)
Wake up a sleeping thread.
int k_thread_stack_free(k_thread_stack_t *stack)
Free a dynamically allocated thread stack.
k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread)
Get time when a thread wakes up, in system ticks.
__attribute_const__ k_tid_t k_sched_current_thread_query(void)
Query thread ID of the current thread.
static void k_thread_start(k_tid_t thread)
Start an inactive thread.
Definition kernel.h:1088
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)
Create a thread.
void k_reschedule(void)
Invoke the scheduler.
void k_thread_deadline_set(k_tid_t thread, int deadline)
Set deadline expiration time for scheduler.
void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu, k_thread_user_cb_t user_cb, void *user_data)
Iterate over the threads in running on current cpu without locking.
const char * k_thread_name_get(k_tid_t thread)
Get thread name.
void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data)
Iterate over all the threads in the system.
int k_thread_cpu_pin(k_tid_t thread, int cpu)
Pin a thread to a CPU.
int32_t k_usleep(int32_t us)
Put the current thread to sleep with microsecond resolution.
int k_thread_cpu_mask_enable_all(k_tid_t thread)
Sets all CPU enable masks to one.
void(* k_thread_user_cb_t)(const struct k_thread *thread, void *user_data)
Definition kernel.h:105
k_thread_stack_t * k_thread_stack_alloc(size_t size, int flags)
Dynamically allocate a thread stack.
k_ticks_t k_timer_expires_ticks(const struct k_timer *timer)
Get next expiration time of a timer, in system ticks.
void(* k_timer_stop_t)(struct k_timer *timer)
Timer stop function type.
Definition kernel.h:1632
k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer)
Get time remaining before a timer next expires, in system ticks.
void * k_timer_user_data_get(const struct k_timer *timer)
Retrieve the user-specific data from a timer.
void(* k_timer_expiry_t)(struct k_timer *timer)
Timer expiry function type.
Definition kernel.h:1616
void k_timer_init(struct k_timer *timer, k_timer_expiry_t expiry_fn, k_timer_stop_t stop_fn)
Initialize a timer.
void k_timer_start(struct k_timer *timer, k_timeout_t duration, k_timeout_t period)
Start a timer.
static uint32_t k_timer_remaining_get(struct k_timer *timer)
Get time remaining before a timer next expires.
Definition kernel.h:1778
uint32_t k_timer_status_sync(struct k_timer *timer)
Synchronize thread to timer expiration.
void k_timer_stop(struct k_timer *timer)
Stop a timer.
uint32_t k_timer_status_get(struct k_timer *timer)
Read timer status.
void k_timer_user_data_set(struct k_timer *timer, void *user_data)
Associate user-specific data with a timer.
#define k_ticks_to_ms_floor32(t)
Convert ticks to milliseconds.
Definition time_units.h:1701
#define k_ticks_to_sec_floor32(t)
Convert ticks to seconds.
Definition time_units.h:1605
#define k_ticks_to_ms_floor64(t)
Convert ticks to milliseconds.
Definition time_units.h:1717
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)
Submit a triggered work item.
static k_tid_t k_work_queue_thread_get(struct k_work_q *queue)
Access the thread that animates a work queue.
Definition kernel.h:4209
static bool k_work_is_pending(const struct k_work *work)
Test whether a work item is currently pending.
Definition kernel.h:4180
int k_work_queue_drain(struct k_work_q *queue, bool plug)
Wait until the work queue has drained, optionally plugging it.
static k_ticks_t k_work_delayable_expires_get(const struct k_work_delayable *dwork)
Get the absolute tick count at which a scheduled delayable work will be submitted.
Definition kernel.h:4197
int k_work_schedule_for_queue(struct k_work_q *queue, struct k_work_delayable *dwork, k_timeout_t delay)
Submit an idle work item to a queue after a delay.
int k_work_delayable_busy_get(const struct k_work_delayable *dwork)
Busy state flags from the delayable work item.
int k_work_queue_stop(struct k_work_q *queue, k_timeout_t timeout)
Stop a work queue.
void k_work_init_delayable(struct k_work_delayable *dwork, k_work_handler_t handler)
Initialize a delayable work structure.
int k_work_poll_cancel(struct k_work_poll *work)
Cancel a triggered work item.
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)
Start a workqueue in user mode.
void k_work_poll_init(struct k_work_poll *work, k_work_handler_t handler)
Initialize a triggered work item.
int k_work_cancel(struct k_work *work)
Cancel a work item.
static int k_work_user_submit_to_queue(struct k_work_user_q *work_q, struct k_work_user *work)
Submit a work item to a user mode workqueue.
Definition kernel.h:4336
int k_work_submit_to_queue(struct k_work_q *queue, struct k_work *work)
Submit a work item to a queue.
static bool k_work_user_is_pending(struct k_work_user *work)
Check if a userspace work item is pending.
Definition kernel.h:4313
void(* k_work_handler_t)(struct k_work *work)
The signature for a work item handler function.
Definition kernel.h:3386
int k_work_schedule(struct k_work_delayable *dwork, k_timeout_t delay)
Submit an idle work item to the system work queue after a delay.
static bool k_work_delayable_is_pending(const struct k_work_delayable *dwork)
Test whether a delayed work item is currently pending.
Definition kernel.h:4191
bool k_work_cancel_delayable_sync(struct k_work_delayable *dwork, struct k_work_sync *sync)
Cancel delayable work and wait.
int k_work_cancel_delayable(struct k_work_delayable *dwork)
Cancel delayable work.
static void k_work_user_init(struct k_work_user *work, k_work_user_handler_t handler)
Initialize a userspace work item.
Definition kernel.h:4291
int k_work_queue_unplug(struct k_work_q *queue)
Release a work queue to accept new submissions.
int k_work_reschedule(struct k_work_delayable *dwork, k_timeout_t delay)
Reschedule a work item to the system work queue after a delay.
void(* k_work_user_handler_t)(struct k_work_user *work)
Work item handler function type for user work queues.
Definition kernel.h:4232
bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync)
Cancel a work item and wait for it to complete.
static k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
Access the user mode thread that animates a work queue.
Definition kernel.h:4391
int k_work_busy_get(const struct k_work *work)
Busy state flags from the work item.
static struct k_work_delayable * k_work_delayable_from_work(struct k_work *work)
Get the parent delayable work structure from a work pointer.
Definition kernel.h:4186
static k_ticks_t k_work_delayable_remaining_get(const struct k_work_delayable *dwork)
Get the number of ticks until a scheduled delayable work will be submitted.
Definition kernel.h:4203
bool k_work_flush(struct k_work *work, struct k_work_sync *sync)
Wait for last-submitted instance to complete.
int k_work_reschedule_for_queue(struct k_work_q *queue, struct k_work_delayable *dwork, k_timeout_t delay)
Reschedule a work item to a queue after a delay.
int k_work_submit(struct k_work *work)
Submit a work item to the system queue.
bool k_work_flush_delayable(struct k_work_delayable *dwork, struct k_work_sync *sync)
Flush delayable work.
int k_work_poll_submit(struct k_work_poll *work, struct k_poll_event *events, int num_events, k_timeout_t timeout)
Submit a triggered work item to the system workqueue.
void k_work_queue_init(struct k_work_q *queue)
Initialize a work queue structure.
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)
Initialize a work queue.
void k_work_init(struct k_work *work, k_work_handler_t handler)
Initialize a (non-delayable) work structure.
@ K_WORK_CANCELING
Flag indicating a work item that is being canceled.
Definition kernel.h:3981
@ K_WORK_QUEUED
Flag indicating a work item that has been submitted to a queue but has not started running.
Definition kernel.h:3988
@ K_WORK_DELAYED
Flag indicating a delayed work item that is scheduled for submission to a queue.
Definition kernel.h:3995
@ K_WORK_RUNNING
Flag indicating a work item that is running under a work queue thread.
Definition kernel.h:3975
@ K_WORK_FLUSHING
Flag indicating a synced work item that is being flushed.
Definition kernel.h:4001
void k_sys_runtime_stats_disable(void)
Disable gathering of system runtime statistics.
int k_thread_runtime_stats_enable(k_tid_t thread)
Enable gathering of runtime statistics for specified thread.
void k_sys_runtime_stats_enable(void)
Enable gathering of system runtime statistics.
int k_thread_runtime_stats_get(k_tid_t thread, k_thread_runtime_stats_t *stats)
Get the runtime statistics of a thread.
execution_context_types
Definition kernel.h:90
@ K_ISR
Definition kernel.h:91
@ K_COOP_THREAD
Definition kernel.h:92
@ K_PREEMPT_THREAD
Definition kernel.h:93
int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats)
Get the runtime statistics of all threads.
int k_thread_runtime_stats_disable(k_tid_t thread)
Disable gathering of runtime statistics for specified thread.
int k_thread_runtime_stats_cpu_get(int cpu, k_thread_runtime_stats_t *stats)
Get the runtime statistics of all threads on specified cpu.
Header files included by kernel.h.
void(* k_thread_timeslice_fn_t)(struct k_thread *thread, void *data)
Definition kernel_structs.h:322
Memory Statistics.
flags
Definition parser.h:96
state
Definition parser_state.h:29
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__INTPTR_TYPE__ intptr_t
Definition stdint.h:104
__INT32_TYPE__ int32_t
Definition stdint.h:74
__UINT64_TYPE__ uint64_t
Definition stdint.h:91
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINTPTR_TYPE__ uintptr_t
Definition stdint.h:105
__INT64_TYPE__ int64_t
Definition stdint.h:75
Structure to store initialization entry information.
Definition init.h:103
Definition kernel.h:3136
_wait_q_t wait_q
Definition kernel.h:3137
Event Structure.
Definition kernel.h:2327
struct k_spinlock lock
Definition kernel.h:2330
uint32_t events
Definition kernel.h:2329
_wait_q_t wait_q
Definition kernel.h:2328
Definition kernel.h:2494
futex structure
Definition kernel.h:2248
atomic_t val
Definition kernel.h:2249
Definition kernel.h:5445
struct k_spinlock lock
Definition kernel.h:5448
struct sys_heap heap
Definition kernel.h:5446
_wait_q_t wait_q
Definition kernel.h:5447
Definition kernel.h:2735
Mailbox Message Structure.
Definition kernel.h:4842
k_tid_t tx_target_thread
target thread id
Definition kernel.h:4852
void * tx_data
sender's message data buffer
Definition kernel.h:4848
k_tid_t rx_source_thread
source thread id
Definition kernel.h:4850
uint32_t info
application-defined information value
Definition kernel.h:4846
size_t size
size of message (in bytes)
Definition kernel.h:4844
Mailbox Structure.
Definition kernel.h:4864
_wait_q_t tx_msg_queue
Transmit messages queue.
Definition kernel.h:4866
struct k_spinlock lock
Definition kernel.h:4869
_wait_q_t rx_msg_queue
Receive message queue.
Definition kernel.h:4868
Memory Domain.
Definition mem_domain.h:80
Memory Partition.
Definition mem_domain.h:55
Message Queue Attributes.
Definition kernel.h:4610
uint32_t used_msgs
Used messages.
Definition kernel.h:4616
size_t msg_size
Message Size.
Definition kernel.h:4612
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4614
Message Queue Structure.
Definition kernel.h:4551
size_t msg_size
Message size.
Definition kernel.h:4557
char * read_ptr
Read pointer.
Definition kernel.h:4565
uint32_t used_msgs
Number of used messages.
Definition kernel.h:4569
char * buffer_end
End of message buffer.
Definition kernel.h:4563
struct k_spinlock lock
Lock.
Definition kernel.h:4555
char * write_ptr
Write pointer.
Definition kernel.h:4567
char * buffer_start
Start of message buffer.
Definition kernel.h:4561
uint8_t flags
Message queue.
Definition kernel.h:4574
_wait_q_t wait_q
Message queue wait queue.
Definition kernel.h:4553
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4559
Mutex Structure.
Definition kernel.h:3024
uint32_t lock_count
Current lock count.
Definition kernel.h:3031
_wait_q_t wait_q
Mutex wait queue.
Definition kernel.h:3026
int owner_orig_prio
Original thread priority.
Definition kernel.h:3034
struct k_thread * owner
Mutex owner.
Definition kernel.h:3028
Object core structure.
Definition obj_core.h:121
Pipe Structure.
Definition kernel.h:4995
uint8_t flags
Wait queue.
Definition kernel.h:5010
struct k_pipe::@318 wait_q
_wait_q_t readers
Reader wait queue.
Definition kernel.h:5004
size_t write_index
Where in buffer to write.
Definition kernel.h:5000
size_t bytes_used
Number of bytes used in buffer.
Definition kernel.h:4998
struct k_spinlock lock
Synchronization lock.
Definition kernel.h:5001
_wait_q_t writers
Writer wait queue.
Definition kernel.h:5005
size_t size
Buffer size.
Definition kernel.h:4997
unsigned char * buffer
Pipe buffer: may be NULL.
Definition kernel.h:4996
size_t read_index
Where in buffer to read from.
Definition kernel.h:4999
Poll Event.
Definition kernel.h:5865
struct k_poll_signal * signal
Definition kernel.h:5893
uint32_t tag
optional user-specified tag, opaque, untouched by the API
Definition kernel.h:5873
struct k_fifo * fifo
Definition kernel.h:5895
struct k_msgq * msgq
Definition kernel.h:5897
struct k_queue * queue
Definition kernel.h:5896
uint32_t unused
unused bits in 32-bit word
Definition kernel.h:5885
uint32_t type
bitfield of event types (bitwise-ORed K_POLL_TYPE_xxx values)
Definition kernel.h:5876
struct k_sem * sem
Definition kernel.h:5894
uint32_t state
bitfield of event states (bitwise-ORed K_POLL_STATE_xxx values)
Definition kernel.h:5879
uint32_t mode
mode of operation, from enum k_poll_modes
Definition kernel.h:5882
struct z_poller * poller
PRIVATE - DO NOT TOUCH.
Definition kernel.h:5870
void * obj
Definition kernel.h:5892
Definition kernel.h:5841
sys_dlist_t poll_events
PRIVATE - DO NOT TOUCH.
Definition kernel.h:5843
int result
custom result value passed to k_poll_signal_raise() if needed
Definition kernel.h:5852
unsigned int signaled
1 if the event has been signaled, 0 otherwise.
Definition kernel.h:5849
Definition kernel.h:1956
struct k_spinlock lock
Definition kernel.h:1958
_wait_q_t wait_q
Definition kernel.h:1959
sys_sflist_t data_q
Definition kernel.h:1957
Kernel Spin Lock.
Definition spinlock.h:45
Definition thread.h:207
Thread Structure.
Definition thread.h:259
struct _thread_base base
Definition thread.h:261
struct k_heap * resource_pool
resource pool
Definition thread.h:349
struct __thread_entry entry
thread entry and parameters description
Definition thread.h:288
Kernel timeout type.
Definition sys_clock.h:65
A structure used to submit work after a delay.
Definition kernel.h:4033
struct _timeout timeout
Definition kernel.h:4038
struct k_work_q * queue
Definition kernel.h:4041
struct k_work work
Definition kernel.h:4035
A structure used to hold work until it can be processed.
Definition kernel.h:4157
sys_slist_t pending
Definition kernel.h:4166
_wait_q_t drainq
Definition kernel.h:4172
_wait_q_t notifyq
Definition kernel.h:4169
uint32_t flags
Definition kernel.h:4175
struct k_thread thread
Definition kernel.h:4159
A structure holding optional configuration items for a work queue.
Definition kernel.h:4129
const char * name
The name to be given to the work queue thread.
Definition kernel.h:4134
bool essential
Control whether the work queue thread should be marked as essential thread.
Definition kernel.h:4153
bool no_yield
Control whether the work queue thread should yield between items.
Definition kernel.h:4148
A structure holding internal state for a pending synchronous operation on a work item or queue.
Definition kernel.h:4116
struct z_work_canceller canceller
Definition kernel.h:4119
struct z_work_flusher flusher
Definition kernel.h:4118
A structure used to submit work.
Definition kernel.h:4005
k_work_handler_t handler
Definition kernel.h:4014
uint32_t flags
Definition kernel.h:4025
struct k_work_q * queue
Definition kernel.h:4017
sys_snode_t node
Definition kernel.h:4011
Definition sys_heap.h:57
Definition mem_stats.h:24
Macros to abstract toolchain specific capabilities.