Zephyr API Documentation  3.7.0-rc1
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
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
91 K_ISR = 0,
94};
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
153 k_thread_user_cb_t user_cb, void *user_data);
154
163#endif /* !_ASMLANGUAGE */
164
165
166/*
167 * Thread user options. May be needed by assembly code. Common part uses low
168 * bits, arch-specific use high bits.
169 */
170
174#define K_ESSENTIAL (BIT(0))
175
185#define K_FP_IDX 1
186#define K_FP_REGS (BIT(K_FP_IDX))
187
194#define K_USER (BIT(2))
195
204#define K_INHERIT_PERMS (BIT(3))
205
215#define K_CALLBACK_STATE (BIT(4))
216
226#define K_DSP_IDX 6
227#define K_DSP_REGS (BIT(K_DSP_IDX))
228
237#define K_AGU_IDX 7
238#define K_AGU_REGS (BIT(K_AGU_IDX))
239
249#define K_SSE_REGS (BIT(7))
250
251/* end - thread options */
252
253#if !defined(_ASMLANGUAGE)
268__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);
269
283
332__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
333 k_thread_stack_t *stack,
334 size_t stack_size,
336 void *p1, void *p2, void *p3,
337 int prio, uint32_t options, k_timeout_t delay);
338
361 void *p1, void *p2,
362 void *p3);
363
377#define k_thread_access_grant(thread, ...) \
378 FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)
379
394static inline void k_thread_heap_assign(struct k_thread *thread,
395 struct k_heap *heap)
396{
397 thread->resource_pool = heap;
398}
399
400#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
421__syscall int k_thread_stack_space_get(const struct k_thread *thread,
422 size_t *unused_ptr);
423#endif
424
425#if (K_HEAP_MEM_POOL_SIZE > 0)
438void k_thread_system_pool_assign(struct k_thread *thread);
439#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */
440
460__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);
461
476__syscall int32_t k_sleep(k_timeout_t timeout);
477
489static inline int32_t k_msleep(int32_t ms)
490{
491 return k_sleep(Z_TIMEOUT_MS(ms));
492}
493
511
528__syscall void k_busy_wait(uint32_t usec_to_wait);
529
541bool k_can_yield(void);
542
550__syscall void k_yield(void);
551
561__syscall void k_wakeup(k_tid_t thread);
562
576__attribute_const__
578
585__attribute_const__
586static inline k_tid_t k_current_get(void)
587{
588#ifdef CONFIG_CURRENT_THREAD_USE_TLS
589
590 /* Thread-local cache of current thread ID, set in z_thread_entry() */
591 extern __thread k_tid_t z_tls_current;
592
593 return z_tls_current;
594#else
596#endif
597}
598
618__syscall void k_thread_abort(k_tid_t thread);
619
620
630__syscall void k_thread_start(k_tid_t thread);
631
632k_ticks_t z_timeout_expires(const struct _timeout *timeout);
633k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
634
635#ifdef CONFIG_SYS_CLOCK_EXISTS
636
644__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
645
646static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
647 const struct k_thread *thread)
648{
649 return z_timeout_expires(&thread->base.timeout);
650}
651
660
661static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
662 const struct k_thread *thread)
663{
664 return z_timeout_remaining(&thread->base.timeout);
665}
666
667#endif /* CONFIG_SYS_CLOCK_EXISTS */
668
673struct _static_thread_data {
674 struct k_thread *init_thread;
675 k_thread_stack_t *init_stack;
676 unsigned int init_stack_size;
678 void *init_p1;
679 void *init_p2;
680 void *init_p3;
681 int init_prio;
682 uint32_t init_options;
683 const char *init_name;
684#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
685 int32_t init_delay_ms;
686#else
687 k_timeout_t init_delay;
688#endif
689};
690
691#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
692#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
693#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
694#else
695#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS(ms)
696#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
697#endif
698
699#define Z_THREAD_INITIALIZER(thread, stack, stack_size, \
700 entry, p1, p2, p3, \
701 prio, options, delay, tname) \
702 { \
703 .init_thread = (thread), \
704 .init_stack = (stack), \
705 .init_stack_size = (stack_size), \
706 .init_entry = (k_thread_entry_t)entry, \
707 .init_p1 = (void *)p1, \
708 .init_p2 = (void *)p2, \
709 .init_p3 = (void *)p3, \
710 .init_prio = (prio), \
711 .init_options = (options), \
712 .init_name = STRINGIFY(tname), \
713 Z_THREAD_INIT_DELAY_INITIALIZER(delay) \
714 }
715
716/*
717 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
718 * information on arguments.
719 */
720#define Z_THREAD_COMMON_DEFINE(name, stack_size, \
721 entry, p1, p2, p3, \
722 prio, options, delay) \
723 struct k_thread _k_thread_obj_##name; \
724 STRUCT_SECTION_ITERABLE(_static_thread_data, \
725 _k_thread_data_##name) = \
726 Z_THREAD_INITIALIZER(&_k_thread_obj_##name, \
727 _k_thread_stack_##name, stack_size,\
728 entry, p1, p2, p3, prio, options, \
729 delay, name); \
730 const k_tid_t name = (k_tid_t)&_k_thread_obj_##name
731
767#define K_THREAD_DEFINE(name, stack_size, \
768 entry, p1, p2, p3, \
769 prio, options, delay) \
770 K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
771 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
772 prio, options, delay)
773
804#define K_KERNEL_THREAD_DEFINE(name, stack_size, \
805 entry, p1, p2, p3, \
806 prio, options, delay) \
807 K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
808 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
809 prio, options, delay)
810
820__syscall int k_thread_priority_get(k_tid_t thread);
821
847__syscall void k_thread_priority_set(k_tid_t thread, int prio);
848
849
850#ifdef CONFIG_SCHED_DEADLINE
883__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);
884#endif
885
886#ifdef CONFIG_SCHED_CPU_MASK
900
914
928
942
953int k_thread_cpu_pin(k_tid_t thread, int cpu);
954#endif
955
976__syscall void k_thread_suspend(k_tid_t thread);
977
988__syscall void k_thread_resume(k_tid_t thread);
989
1016void k_sched_time_slice_set(int32_t slice, int prio);
1017
1056void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
1057 k_thread_timeslice_fn_t expired, void *data);
1058
1077bool k_is_in_isr(void);
1078
1095__syscall int k_is_preempt_thread(void);
1096
1108static inline bool k_is_pre_kernel(void)
1109{
1110 extern bool z_sys_post_kernel; /* in init.c */
1111
1112 return !z_sys_post_kernel;
1113}
1114
1149void k_sched_lock(void);
1150
1159
1172__syscall void k_thread_custom_data_set(void *value);
1173
1181__syscall void *k_thread_custom_data_get(void);
1182
1196__syscall int k_thread_name_set(k_tid_t thread, const char *str);
1197
1206const char *k_thread_name_get(k_tid_t thread);
1207
1219__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
1220 size_t size);
1221
1234const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);
1235
1253#define K_NO_WAIT Z_TIMEOUT_NO_WAIT
1254
1267#define K_NSEC(t) Z_TIMEOUT_NS(t)
1268
1281#define K_USEC(t) Z_TIMEOUT_US(t)
1282
1293#define K_CYC(t) Z_TIMEOUT_CYC(t)
1294
1305#define K_TICKS(t) Z_TIMEOUT_TICKS(t)
1306
1317#define K_MSEC(ms) Z_TIMEOUT_MS(ms)
1318
1329#define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
1330
1341#define K_MINUTES(m) K_SECONDS((m) * 60)
1342
1353#define K_HOURS(h) K_MINUTES((h) * 60)
1354
1363#define K_FOREVER Z_FOREVER
1364
1365#ifdef CONFIG_TIMEOUT_64BIT
1366
1378#define K_TIMEOUT_ABS_TICKS(t) \
1379 Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)MAX(t, 0)))
1380
1392#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))
1393
1406#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))
1407
1420#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))
1421
1434#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
1435
1436#endif
1437
1446struct k_timer {
1447 /*
1448 * _timeout structure must be first here if we want to use
1449 * dynamic timer allocation. timeout.node is used in the double-linked
1450 * list of free timers
1451 */
1452 struct _timeout timeout;
1453
1454 /* wait queue for the (single) thread waiting on this timer */
1455 _wait_q_t wait_q;
1456
1457 /* runs in ISR context */
1458 void (*expiry_fn)(struct k_timer *timer);
1459
1460 /* runs in the context of the thread that calls k_timer_stop() */
1461 void (*stop_fn)(struct k_timer *timer);
1462
1463 /* timer period */
1464 k_timeout_t period;
1465
1466 /* timer status */
1467 uint32_t status;
1468
1469 /* user-specific data, also used to support legacy features */
1470 void *user_data;
1471
1473
1474#ifdef CONFIG_OBJ_CORE_TIMER
1475 struct k_obj_core obj_core;
1476#endif
1477};
1478
1479#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
1480 { \
1481 .timeout = { \
1482 .node = {},\
1483 .fn = z_timer_expiration_handler, \
1484 .dticks = 0, \
1485 }, \
1486 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1487 .expiry_fn = expiry, \
1488 .stop_fn = stop, \
1489 .status = 0, \
1490 .user_data = 0, \
1491 }
1492
1513typedef void (*k_timer_expiry_t)(struct k_timer *timer);
1514
1529typedef void (*k_timer_stop_t)(struct k_timer *timer);
1530
1542#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
1543 STRUCT_SECTION_ITERABLE(k_timer, name) = \
1544 Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
1545
1555void k_timer_init(struct k_timer *timer,
1556 k_timer_expiry_t expiry_fn,
1557 k_timer_stop_t stop_fn);
1558
1573__syscall void k_timer_start(struct k_timer *timer,
1574 k_timeout_t duration, k_timeout_t period);
1575
1592__syscall void k_timer_stop(struct k_timer *timer);
1593
1606__syscall uint32_t k_timer_status_get(struct k_timer *timer);
1607
1625__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
1626
1627#ifdef CONFIG_SYS_CLOCK_EXISTS
1628
1639__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
1640
1641static inline k_ticks_t z_impl_k_timer_expires_ticks(
1642 const struct k_timer *timer)
1643{
1644 return z_timeout_expires(&timer->timeout);
1645}
1646
1654__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
1655
1656static inline k_ticks_t z_impl_k_timer_remaining_ticks(
1657 const struct k_timer *timer)
1658{
1659 return z_timeout_remaining(&timer->timeout);
1660}
1661
1672static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
1673{
1675}
1676
1677#endif /* CONFIG_SYS_CLOCK_EXISTS */
1678
1691__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);
1692
1696static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
1697 void *user_data)
1698{
1699 timer->user_data = user_data;
1700}
1701
1709__syscall void *k_timer_user_data_get(const struct k_timer *timer);
1710
1711static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
1712{
1713 return timer->user_data;
1714}
1715
1733__syscall int64_t k_uptime_ticks(void);
1734
1748static inline int64_t k_uptime_get(void)
1749{
1751}
1752
1772static inline uint32_t k_uptime_get_32(void)
1773{
1774 return (uint32_t)k_uptime_get();
1775}
1776
1785static inline uint32_t k_uptime_seconds(void)
1786{
1788}
1789
1801static inline int64_t k_uptime_delta(int64_t *reftime)
1802{
1803 int64_t uptime, delta;
1804
1805 uptime = k_uptime_get();
1806 delta = uptime - *reftime;
1807 *reftime = uptime;
1808
1809 return delta;
1810}
1811
1820static inline uint32_t k_cycle_get_32(void)
1821{
1822 return arch_k_cycle_get_32();
1823}
1824
1835static inline uint64_t k_cycle_get_64(void)
1836{
1837 if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
1838 __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
1839 "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
1840 return 0;
1841 }
1842
1843 return arch_k_cycle_get_64();
1844}
1845
1850struct k_queue {
1853 _wait_q_t wait_q;
1854
1855 Z_DECL_POLL_EVENT
1856
1858};
1859
1864#define Z_QUEUE_INITIALIZER(obj) \
1865 { \
1866 .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
1867 .lock = { }, \
1868 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1869 Z_POLL_EVENT_OBJ_INIT(obj) \
1870 }
1871
1889__syscall void k_queue_init(struct k_queue *queue);
1890
1904__syscall void k_queue_cancel_wait(struct k_queue *queue);
1905
1918void k_queue_append(struct k_queue *queue, void *data);
1919
1936__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);
1937
1950void k_queue_prepend(struct k_queue *queue, void *data);
1951
1968__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);
1969
1983void k_queue_insert(struct k_queue *queue, void *prev, void *data);
1984
2003int k_queue_append_list(struct k_queue *queue, void *head, void *tail);
2004
2020int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);
2021
2039__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);
2040
2057bool k_queue_remove(struct k_queue *queue, void *data);
2058
2073bool k_queue_unique_append(struct k_queue *queue, void *data);
2074
2088__syscall int k_queue_is_empty(struct k_queue *queue);
2089
2090static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
2091{
2092 return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
2093}
2094
2104__syscall void *k_queue_peek_head(struct k_queue *queue);
2105
2115__syscall void *k_queue_peek_tail(struct k_queue *queue);
2116
2126#define K_QUEUE_DEFINE(name) \
2127 STRUCT_SECTION_ITERABLE(k_queue, name) = \
2128 Z_QUEUE_INITIALIZER(name)
2129
2132#ifdef CONFIG_USERSPACE
2142struct k_futex {
2144};
2145
2153struct z_futex_data {
2154 _wait_q_t wait_q;
2155 struct k_spinlock lock;
2156};
2157
2158#define Z_FUTEX_DATA_INITIALIZER(obj) \
2159 { \
2160 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q) \
2161 }
2162
2188__syscall int k_futex_wait(struct k_futex *futex, int expected,
2189 k_timeout_t timeout);
2190
2205__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);
2206
2208#endif
2209
2221struct k_event {
2222 _wait_q_t wait_q;
2225
2227
2228#ifdef CONFIG_OBJ_CORE_EVENT
2229 struct k_obj_core obj_core;
2230#endif
2231
2232};
2233
2234#define Z_EVENT_INITIALIZER(obj) \
2235 { \
2236 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2237 .events = 0 \
2238 }
2239
2247__syscall void k_event_init(struct k_event *event);
2248
2264__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);
2265
2281__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);
2282
2297__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
2298 uint32_t events_mask);
2299
2310__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);
2311
2333__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
2334 bool reset, k_timeout_t timeout);
2335
2357__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
2358 bool reset, k_timeout_t timeout);
2359
2368static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
2369{
2370 return k_event_wait(event, events_mask, false, K_NO_WAIT);
2371}
2372
2382#define K_EVENT_DEFINE(name) \
2383 STRUCT_SECTION_ITERABLE(k_event, name) = \
2384 Z_EVENT_INITIALIZER(name);
2385
2388struct k_fifo {
2389 struct k_queue _queue;
2390#ifdef CONFIG_OBJ_CORE_FIFO
2391 struct k_obj_core obj_core;
2392#endif
2393};
2394
2398#define Z_FIFO_INITIALIZER(obj) \
2399 { \
2400 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2401 }
2402
2420#define k_fifo_init(fifo) \
2421 ({ \
2422 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
2423 k_queue_init(&(fifo)->_queue); \
2424 K_OBJ_CORE_INIT(K_OBJ_CORE(fifo), _obj_type_fifo); \
2425 K_OBJ_CORE_LINK(K_OBJ_CORE(fifo)); \
2426 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo); \
2427 })
2428
2440#define k_fifo_cancel_wait(fifo) \
2441 ({ \
2442 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
2443 k_queue_cancel_wait(&(fifo)->_queue); \
2444 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
2445 })
2446
2459#define k_fifo_put(fifo, data) \
2460 ({ \
2461 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, data); \
2462 k_queue_append(&(fifo)->_queue, data); \
2463 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, data); \
2464 })
2465
2482#define k_fifo_alloc_put(fifo, data) \
2483 ({ \
2484 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, data); \
2485 int fap_ret = k_queue_alloc_append(&(fifo)->_queue, data); \
2486 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, data, fap_ret); \
2487 fap_ret; \
2488 })
2489
2504#define k_fifo_put_list(fifo, head, tail) \
2505 ({ \
2506 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
2507 k_queue_append_list(&(fifo)->_queue, head, tail); \
2508 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
2509 })
2510
2524#define k_fifo_put_slist(fifo, list) \
2525 ({ \
2526 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
2527 k_queue_merge_slist(&(fifo)->_queue, list); \
2528 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
2529 })
2530
2548#define k_fifo_get(fifo, timeout) \
2549 ({ \
2550 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
2551 void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
2552 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
2553 fg_ret; \
2554 })
2555
2569#define k_fifo_is_empty(fifo) \
2570 k_queue_is_empty(&(fifo)->_queue)
2571
2585#define k_fifo_peek_head(fifo) \
2586 ({ \
2587 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
2588 void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
2589 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
2590 fph_ret; \
2591 })
2592
2604#define k_fifo_peek_tail(fifo) \
2605 ({ \
2606 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
2607 void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
2608 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
2609 fpt_ret; \
2610 })
2611
2621#define K_FIFO_DEFINE(name) \
2622 STRUCT_SECTION_ITERABLE(k_fifo, name) = \
2623 Z_FIFO_INITIALIZER(name)
2624
2627struct k_lifo {
2628 struct k_queue _queue;
2629#ifdef CONFIG_OBJ_CORE_LIFO
2630 struct k_obj_core obj_core;
2631#endif
2632};
2633
2638#define Z_LIFO_INITIALIZER(obj) \
2639 { \
2640 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2641 }
2642
2660#define k_lifo_init(lifo) \
2661 ({ \
2662 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
2663 k_queue_init(&(lifo)->_queue); \
2664 K_OBJ_CORE_INIT(K_OBJ_CORE(lifo), _obj_type_lifo); \
2665 K_OBJ_CORE_LINK(K_OBJ_CORE(lifo)); \
2666 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo); \
2667 })
2668
2681#define k_lifo_put(lifo, data) \
2682 ({ \
2683 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, data); \
2684 k_queue_prepend(&(lifo)->_queue, data); \
2685 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, data); \
2686 })
2687
2704#define k_lifo_alloc_put(lifo, data) \
2705 ({ \
2706 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, data); \
2707 int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, data); \
2708 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, data, lap_ret); \
2709 lap_ret; \
2710 })
2711
2729#define k_lifo_get(lifo, timeout) \
2730 ({ \
2731 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
2732 void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
2733 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
2734 lg_ret; \
2735 })
2736
2746#define K_LIFO_DEFINE(name) \
2747 STRUCT_SECTION_ITERABLE(k_lifo, name) = \
2748 Z_LIFO_INITIALIZER(name)
2749
2755#define K_STACK_FLAG_ALLOC ((uint8_t)1) /* Buffer was allocated */
2756
2757typedef uintptr_t stack_data_t;
2758
2759struct k_stack {
2760 _wait_q_t wait_q;
2761 struct k_spinlock lock;
2762 stack_data_t *base, *next, *top;
2763
2764 uint8_t flags;
2765
2767
2768#ifdef CONFIG_OBJ_CORE_STACK
2769 struct k_obj_core obj_core;
2770#endif
2771};
2772
2773#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
2774 { \
2775 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
2776 .base = (stack_buffer), \
2777 .next = (stack_buffer), \
2778 .top = (stack_buffer) + (stack_num_entries), \
2779 }
2780
2800void k_stack_init(struct k_stack *stack,
2801 stack_data_t *buffer, uint32_t num_entries);
2802
2803
2818__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
2819 uint32_t num_entries);
2820
2832int k_stack_cleanup(struct k_stack *stack);
2833
2847__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);
2848
2869__syscall int k_stack_pop(struct k_stack *stack, stack_data_t *data,
2870 k_timeout_t timeout);
2871
2882#define K_STACK_DEFINE(name, stack_num_entries) \
2883 stack_data_t __noinit \
2884 _k_stack_buf_##name[stack_num_entries]; \
2885 STRUCT_SECTION_ITERABLE(k_stack, name) = \
2886 Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
2887 stack_num_entries)
2888
2895struct k_work;
2896struct k_work_q;
2897struct k_work_queue_config;
2898extern struct k_work_q k_sys_work_q;
2899
2914struct k_mutex {
2916 _wait_q_t wait_q;
2919
2922
2925
2927
2928#ifdef CONFIG_OBJ_CORE_MUTEX
2929 struct k_obj_core obj_core;
2930#endif
2931};
2932
2936#define Z_MUTEX_INITIALIZER(obj) \
2937 { \
2938 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
2939 .owner = NULL, \
2940 .lock_count = 0, \
2941 .owner_orig_prio = K_LOWEST_APPLICATION_THREAD_PRIO, \
2942 }
2943
2957#define K_MUTEX_DEFINE(name) \
2958 STRUCT_SECTION_ITERABLE(k_mutex, name) = \
2959 Z_MUTEX_INITIALIZER(name)
2960
2973__syscall int k_mutex_init(struct k_mutex *mutex);
2974
2975
2997__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);
2998
3019__syscall int k_mutex_unlock(struct k_mutex *mutex);
3020
3027 _wait_q_t wait_q;
3028
3029#ifdef CONFIG_OBJ_CORE_CONDVAR
3030 struct k_obj_core obj_core;
3031#endif
3032};
3033
3034#define Z_CONDVAR_INITIALIZER(obj) \
3035 { \
3036 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
3037 }
3038
3051__syscall int k_condvar_init(struct k_condvar *condvar);
3052
3059__syscall int k_condvar_signal(struct k_condvar *condvar);
3060
3068__syscall int k_condvar_broadcast(struct k_condvar *condvar);
3069
3087__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
3088 k_timeout_t timeout);
3089
3100#define K_CONDVAR_DEFINE(name) \
3101 STRUCT_SECTION_ITERABLE(k_condvar, name) = \
3102 Z_CONDVAR_INITIALIZER(name)
3111struct k_sem {
3112 _wait_q_t wait_q;
3113 unsigned int count;
3114 unsigned int limit;
3115
3116 Z_DECL_POLL_EVENT
3117
3119
3120#ifdef CONFIG_OBJ_CORE_SEM
3121 struct k_obj_core obj_core;
3122#endif
3123};
3124
3125#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
3126 { \
3127 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3128 .count = (initial_count), \
3129 .limit = (count_limit), \
3130 Z_POLL_EVENT_OBJ_INIT(obj) \
3131 }
3132
3151#define K_SEM_MAX_LIMIT UINT_MAX
3152
3168__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
3169 unsigned int limit);
3170
3189__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);
3190
3201__syscall void k_sem_give(struct k_sem *sem);
3202
3212__syscall void k_sem_reset(struct k_sem *sem);
3213
3223__syscall unsigned int k_sem_count_get(struct k_sem *sem);
3224
3228static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
3229{
3230 return sem->count;
3231}
3232
3244#define K_SEM_DEFINE(name, initial_count, count_limit) \
3245 STRUCT_SECTION_ITERABLE(k_sem, name) = \
3246 Z_SEM_INITIALIZER(name, initial_count, count_limit); \
3247 BUILD_ASSERT(((count_limit) != 0) && \
3248 ((initial_count) <= (count_limit)) && \
3249 ((count_limit) <= K_SEM_MAX_LIMIT));
3250
3257struct k_work_delayable;
3258struct k_work_sync;
3259
3276typedef void (*k_work_handler_t)(struct k_work *work);
3277
3291void k_work_init(struct k_work *work,
3293
3308int k_work_busy_get(const struct k_work *work);
3309
3323static inline bool k_work_is_pending(const struct k_work *work);
3324
3346 struct k_work *work);
3347
3356int k_work_submit(struct k_work *work);
3357
3382bool k_work_flush(struct k_work *work,
3383 struct k_work_sync *sync);
3384
3404int k_work_cancel(struct k_work *work);
3405
3436bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);
3437
3448
3469 k_thread_stack_t *stack, size_t stack_size,
3470 int prio, const struct k_work_queue_config *cfg);
3471
3481static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);
3482
3506int k_work_queue_drain(struct k_work_q *queue, bool plug);
3507
3522
3538
3550static inline struct k_work_delayable *
3552
3567
3582static inline bool k_work_delayable_is_pending(
3583 const struct k_work_delayable *dwork);
3584
3599 const struct k_work_delayable *dwork);
3600
3615 const struct k_work_delayable *dwork);
3616
3645 struct k_work_delayable *dwork,
3646 k_timeout_t delay);
3647
3662 k_timeout_t delay);
3663
3700 struct k_work_delayable *dwork,
3701 k_timeout_t delay);
3702
3716 k_timeout_t delay);
3717
3743 struct k_work_sync *sync);
3744
3766
3796 struct k_work_sync *sync);
3797
3798enum {
3803 /* The atomic API is used for all work and queue flags fields to
3804 * enforce sequential consistency in SMP environments.
3805 */
3806
3807 /* Bits that represent the work item states. At least nine of the
3808 * combinations are distinct valid stable states.
3809 */
3810 K_WORK_RUNNING_BIT = 0,
3811 K_WORK_CANCELING_BIT = 1,
3812 K_WORK_QUEUED_BIT = 2,
3813 K_WORK_DELAYED_BIT = 3,
3814 K_WORK_FLUSHING_BIT = 4,
3815
3816 K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
3817 | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
3818
3819 /* Static work flags */
3820 K_WORK_DELAYABLE_BIT = 8,
3821 K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
3822
3823 /* Dynamic work queue flags */
3824 K_WORK_QUEUE_STARTED_BIT = 0,
3825 K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
3826 K_WORK_QUEUE_BUSY_BIT = 1,
3827 K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
3828 K_WORK_QUEUE_DRAIN_BIT = 2,
3829 K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
3830 K_WORK_QUEUE_PLUGGED_BIT = 3,
3831 K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
3832
3833 /* Static work queue flags */
3834 K_WORK_QUEUE_NO_YIELD_BIT = 8,
3835 K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
3836
3840 /* Transient work flags */
3841
3847 K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),
3848
3853 K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),
3854
3860 K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),
3861
3867 K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),
3868
3873 K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
3874};
3875
3877struct k_work {
3878 /* All fields are protected by the work module spinlock. No fields
3879 * are to be accessed except through kernel API.
3880 */
3881
3882 /* Node to link into k_work_q pending list. */
3884
3885 /* The function to be invoked by the work queue thread. */
3887
3888 /* The queue on which the work item was last submitted. */
3890
3891 /* State of the work item.
3892 *
3893 * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
3894 *
3895 * It can be RUNNING and CANCELING simultaneously.
3896 */
3898};
3899
3900#define Z_WORK_INITIALIZER(work_handler) { \
3901 .handler = (work_handler), \
3902}
3903
3906 /* The work item. */
3907 struct k_work work;
3908
3909 /* Timeout used to submit work after a delay. */
3910 struct _timeout timeout;
3911
3912 /* The queue to which the work should be submitted. */
3914};
3915
3916#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
3917 .work = { \
3918 .handler = (work_handler), \
3919 .flags = K_WORK_DELAYABLE, \
3920 }, \
3921}
3922
3939#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
3940 struct k_work_delayable work \
3941 = Z_WORK_DELAYABLE_INITIALIZER(work_handler)
3942
3947/* Record used to wait for work to flush.
3948 *
3949 * The work item is inserted into the queue that will process (or is
3950 * processing) the item, and will be processed as soon as the item
3951 * completes. When the flusher is processed the semaphore will be
3952 * signaled, releasing the thread waiting for the flush.
3953 */
3954struct z_work_flusher {
3955 struct k_work work;
3956 struct k_sem sem;
3957};
3958
3959/* Record used to wait for work to complete a cancellation.
3960 *
3961 * The work item is inserted into a global queue of pending cancels.
3962 * When a cancelling work item goes idle any matching waiters are
3963 * removed from pending_cancels and are woken.
3964 */
3965struct z_work_canceller {
3966 sys_snode_t node;
3967 struct k_work *work;
3968 struct k_sem sem;
3969};
3970
3989 union {
3990 struct z_work_flusher flusher;
3991 struct z_work_canceller canceller;
3992 };
3993};
3994
4006 const char *name;
4007
4021
4026};
4027
4029struct k_work_q {
4030 /* The thread that animates the work. */
4032
4033 /* All the following fields must be accessed only while the
4034 * work module spinlock is held.
4035 */
4036
4037 /* List of k_work items to be worked. */
4039
4040 /* Wait queue for idle work thread. */
4041 _wait_q_t notifyq;
4042
4043 /* Wait queue for threads waiting for the queue to drain. */
4044 _wait_q_t drainq;
4045
4046 /* Flags describing queue state. */
4048};
4049
4050/* Provide the implementation for inline functions declared above */
4051
4052static inline bool k_work_is_pending(const struct k_work *work)
4053{
4054 return k_work_busy_get(work) != 0;
4055}
4056
4057static inline struct k_work_delayable *
4059{
4060 return CONTAINER_OF(work, struct k_work_delayable, work);
4061}
4062
4064 const struct k_work_delayable *dwork)
4065{
4066 return k_work_delayable_busy_get(dwork) != 0;
4067}
4068
4070 const struct k_work_delayable *dwork)
4071{
4072 return z_timeout_expires(&dwork->timeout);
4073}
4074
4076 const struct k_work_delayable *dwork)
4077{
4078 return z_timeout_remaining(&dwork->timeout);
4079}
4080
4082{
4083 return &queue->thread;
4084}
4085
4088struct k_work_user;
4089
4104typedef void (*k_work_user_handler_t)(struct k_work_user *work);
4105
4110struct k_work_user_q {
4111 struct k_queue queue;
4112 struct k_thread thread;
4113};
4114
4115enum {
4116 K_WORK_USER_STATE_PENDING, /* Work item pending state */
4117};
4118
4119struct k_work_user {
4120 void *_reserved; /* Used by k_queue implementation. */
4121 k_work_user_handler_t handler;
4123};
4124
4129#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
4130#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
4131#else
4132#define Z_WORK_USER_INITIALIZER(work_handler) \
4133 { \
4134 ._reserved = NULL, \
4135 .handler = (work_handler), \
4136 .flags = 0 \
4137 }
4138#endif
4139
4151#define K_WORK_USER_DEFINE(work, work_handler) \
4152 struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)
4153
4163static inline void k_work_user_init(struct k_work_user *work,
4164 k_work_user_handler_t handler)
4165{
4166 *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
4167}
4168
4185static inline bool k_work_user_is_pending(struct k_work_user *work)
4186{
4187 return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
4188}
4189
4208static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
4209 struct k_work_user *work)
4210{
4211 int ret = -EBUSY;
4212
4213 if (!atomic_test_and_set_bit(&work->flags,
4214 K_WORK_USER_STATE_PENDING)) {
4215 ret = k_queue_alloc_append(&work_q->queue, work);
4216
4217 /* Couldn't insert into the queue. Clear the pending bit
4218 * so the work item can be submitted again
4219 */
4220 if (ret != 0) {
4221 atomic_clear_bit(&work->flags,
4222 K_WORK_USER_STATE_PENDING);
4223 }
4224 }
4225
4226 return ret;
4227}
4228
4248void k_work_user_queue_start(struct k_work_user_q *work_q,
4249 k_thread_stack_t *stack,
4250 size_t stack_size, int prio,
4251 const char *name);
4252
4263static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
4264{
4265 return &work_q->thread;
4266}
4267
4274struct k_work_poll {
4275 struct k_work work;
4276 struct k_work_q *workq;
4277 struct z_poller poller;
4278 struct k_poll_event *events;
4279 int num_events;
4280 k_work_handler_t real_handler;
4281 struct _timeout timeout;
4282 int poll_result;
4283};
4284
4305#define K_WORK_DEFINE(work, work_handler) \
4306 struct k_work work = Z_WORK_INITIALIZER(work_handler)
4307
4317void k_work_poll_init(struct k_work_poll *work,
4318 k_work_handler_t handler);
4319
4355 struct k_work_poll *work,
4356 struct k_poll_event *events,
4357 int num_events,
4358 k_timeout_t timeout);
4359
4391int k_work_poll_submit(struct k_work_poll *work,
4392 struct k_poll_event *events,
4393 int num_events,
4394 k_timeout_t timeout);
4395
4410int k_work_poll_cancel(struct k_work_poll *work);
4411
4423struct k_msgq {
4425 _wait_q_t wait_q;
4429 size_t msg_size;
4442
4443 Z_DECL_POLL_EVENT
4444
4447
4449
4450#ifdef CONFIG_OBJ_CORE_MSGQ
4451 struct k_obj_core obj_core;
4452#endif
4453};
4459#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
4460 { \
4461 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
4462 .msg_size = q_msg_size, \
4463 .max_msgs = q_max_msgs, \
4464 .buffer_start = q_buffer, \
4465 .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
4466 .read_ptr = q_buffer, \
4467 .write_ptr = q_buffer, \
4468 .used_msgs = 0, \
4469 Z_POLL_EVENT_OBJ_INIT(obj) \
4470 }
4471
4477#define K_MSGQ_FLAG_ALLOC BIT(0)
4478
4484 size_t msg_size;
4489};
4490
4491
4510#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align) \
4511 static char __noinit __aligned(q_align) \
4512 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
4513 STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
4514 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
4515 (q_msg_size), (q_max_msgs))
4516
4531void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
4532 uint32_t max_msgs);
4533
4553__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
4554 uint32_t max_msgs);
4555
4566int k_msgq_cleanup(struct k_msgq *msgq);
4567
4588__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);
4589
4610__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);
4611
4626__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);
4627
4644__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);
4645
4655__syscall void k_msgq_purge(struct k_msgq *msgq);
4656
4667__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);
4668
4677__syscall void k_msgq_get_attrs(struct k_msgq *msgq,
4678 struct k_msgq_attrs *attrs);
4679
4680
4681static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
4682{
4683 return msgq->max_msgs - msgq->used_msgs;
4684}
4685
4695__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
4696
4697static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
4698{
4699 return msgq->used_msgs;
4700}
4701
4716 size_t size;
4720 void *tx_data;
4726 k_tid_t _syncing_thread;
4727#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
4729 struct k_sem *_async_sem;
4730#endif
4731};
4736struct k_mbox {
4738 _wait_q_t tx_msg_queue;
4740 _wait_q_t rx_msg_queue;
4742
4744
4745#ifdef CONFIG_OBJ_CORE_MAILBOX
4746 struct k_obj_core obj_core;
4747#endif
4748};
4753#define Z_MBOX_INITIALIZER(obj) \
4754 { \
4755 .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
4756 .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
4757 }
4758
4772#define K_MBOX_DEFINE(name) \
4773 STRUCT_SECTION_ITERABLE(k_mbox, name) = \
4774 Z_MBOX_INITIALIZER(name) \
4775
4783void k_mbox_init(struct k_mbox *mbox);
4784
4804int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
4805 k_timeout_t timeout);
4806
4820void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
4821 struct k_sem *sem);
4822
4840int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
4841 void *buffer, k_timeout_t timeout);
4842
4856void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);
4857
4867struct k_pipe {
4868 unsigned char *buffer;
4869 size_t size;
4870 size_t bytes_used;
4871 size_t read_index;
4875 struct {
4876 _wait_q_t readers;
4877 _wait_q_t writers;
4880 Z_DECL_POLL_EVENT
4881
4885
4886#ifdef CONFIG_OBJ_CORE_PIPE
4887 struct k_obj_core obj_core;
4888#endif
4889};
4890
4894#define K_PIPE_FLAG_ALLOC BIT(0)
4896#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size) \
4897 { \
4898 .buffer = pipe_buffer, \
4899 .size = pipe_buffer_size, \
4900 .bytes_used = 0, \
4901 .read_index = 0, \
4902 .write_index = 0, \
4903 .lock = {}, \
4904 .wait_q = { \
4905 .readers = Z_WAIT_Q_INIT(&obj.wait_q.readers), \
4906 .writers = Z_WAIT_Q_INIT(&obj.wait_q.writers) \
4907 }, \
4908 Z_POLL_EVENT_OBJ_INIT(obj) \
4909 .flags = 0, \
4910 }
4911
4929#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align) \
4930 static unsigned char __noinit __aligned(pipe_align) \
4931 _k_pipe_buf_##name[pipe_buffer_size]; \
4932 STRUCT_SECTION_ITERABLE(k_pipe, name) = \
4933 Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
4934
4946void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size);
4947
4959int k_pipe_cleanup(struct k_pipe *pipe);
4960
4976__syscall int k_pipe_alloc_init(struct k_pipe *pipe, size_t size);
4977
4996__syscall int k_pipe_put(struct k_pipe *pipe, const void *data,
4997 size_t bytes_to_write, size_t *bytes_written,
4998 size_t min_xfer, k_timeout_t timeout);
4999
5019__syscall int k_pipe_get(struct k_pipe *pipe, void *data,
5020 size_t bytes_to_read, size_t *bytes_read,
5021 size_t min_xfer, k_timeout_t timeout);
5022
5031__syscall size_t k_pipe_read_avail(struct k_pipe *pipe);
5032
5041__syscall size_t k_pipe_write_avail(struct k_pipe *pipe);
5042
5053__syscall void k_pipe_flush(struct k_pipe *pipe);
5054
5066__syscall void k_pipe_buffer_flush(struct k_pipe *pipe);
5067
5074struct k_mem_slab_info {
5075 uint32_t num_blocks;
5076 size_t block_size;
5077 uint32_t num_used;
5078#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5079 uint32_t max_used;
5080#endif
5081};
5082
5083struct k_mem_slab {
5084 _wait_q_t wait_q;
5085 struct k_spinlock lock;
5086 char *buffer;
5087 char *free_list;
5088 struct k_mem_slab_info info;
5089
5091
5092#ifdef CONFIG_OBJ_CORE_MEM_SLAB
5093 struct k_obj_core obj_core;
5094#endif
5095};
5096
5097#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
5098 _slab_num_blocks) \
5099 { \
5100 .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q), \
5101 .lock = {}, \
5102 .buffer = _slab_buffer, \
5103 .free_list = NULL, \
5104 .info = {_slab_num_blocks, _slab_block_size, 0} \
5105 }
5106
5107
5141#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align) \
5142 char __noinit_named(k_mem_slab_buf_##name) \
5143 __aligned(WB_UP(slab_align)) \
5144 _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5145 STRUCT_SECTION_ITERABLE(k_mem_slab, name) = \
5146 Z_MEM_SLAB_INITIALIZER(name, _k_mem_slab_buf_##name, \
5147 WB_UP(slab_block_size), slab_num_blocks)
5148
5163#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align) \
5164 static char __noinit_named(k_mem_slab_buf_##name) \
5165 __aligned(WB_UP(slab_align)) \
5166 _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5167 static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = \
5168 Z_MEM_SLAB_INITIALIZER(name, _k_mem_slab_buf_##name, \
5169 WB_UP(slab_block_size), slab_num_blocks)
5170
5192int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
5193 size_t block_size, uint32_t num_blocks);
5194
5217int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
5218 k_timeout_t timeout);
5219
5229void k_mem_slab_free(struct k_mem_slab *slab, void *mem);
5230
5241static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
5242{
5243 return slab->info.num_used;
5244}
5245
5256static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
5257{
5258#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5259 return slab->info.max_used;
5260#else
5261 ARG_UNUSED(slab);
5262 return 0;
5263#endif
5264}
5265
5276static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
5277{
5278 return slab->info.num_blocks - slab->info.num_used;
5279}
5280
5293int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);
5294
5306int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);
5307
5315/* kernel synchronized heap struct */
5316
5317struct k_heap {
5319 _wait_q_t wait_q;
5321};
5322
5336void k_heap_init(struct k_heap *h, void *mem,
5337 size_t bytes) __attribute_nonnull(1);
5338
5359void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
5360 k_timeout_t timeout) __attribute_nonnull(1);
5361
5383void *k_heap_alloc(struct k_heap *h, size_t bytes,
5384 k_timeout_t timeout) __attribute_nonnull(1);
5385
5409void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
5410 __attribute_nonnull(1);
5411
5422void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
5423
5424/* Hand-calculated minimum heap sizes needed to return a successful
5425 * 1-byte allocation. See details in lib/os/heap.[ch]
5426 */
5427#define Z_HEAP_MIN_SIZE ((sizeof(void *) > 4) ? 56 : 44)
5428
5445#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section) \
5446 char in_section \
5447 __aligned(8) /* CHUNK_UNIT */ \
5448 kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)]; \
5449 STRUCT_SECTION_ITERABLE(k_heap, name) = { \
5450 .heap = { \
5451 .init_mem = kheap_##name, \
5452 .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
5453 }, \
5454 }
5455
5470#define K_HEAP_DEFINE(name, bytes) \
5471 Z_HEAP_DEFINE_IN_SECT(name, bytes, \
5472 __noinit_named(kheap_buf_##name))
5473
5488#define K_HEAP_DEFINE_NOCACHE(name, bytes) \
5489 Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)
5490
5519void *k_aligned_alloc(size_t align, size_t size);
5520
5532void *k_malloc(size_t size);
5533
5544void k_free(void *ptr);
5545
5557void *k_calloc(size_t nmemb, size_t size);
5558
5576void *k_realloc(void *ptr, size_t size);
5577
5580/* polling API - PRIVATE */
5581
5582#ifdef CONFIG_POLL
5583#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
5584#else
5585#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
5586#endif
5587
5588/* private - types bit positions */
5589enum _poll_types_bits {
5590 /* can be used to ignore an event */
5591 _POLL_TYPE_IGNORE,
5592
5593 /* to be signaled by k_poll_signal_raise() */
5594 _POLL_TYPE_SIGNAL,
5595
5596 /* semaphore availability */
5597 _POLL_TYPE_SEM_AVAILABLE,
5598
5599 /* queue/FIFO/LIFO data availability */
5600 _POLL_TYPE_DATA_AVAILABLE,
5601
5602 /* msgq data availability */
5603 _POLL_TYPE_MSGQ_DATA_AVAILABLE,
5604
5605 /* pipe data availability */
5606 _POLL_TYPE_PIPE_DATA_AVAILABLE,
5607
5608 _POLL_NUM_TYPES
5609};
5610
5611#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
5612
5613/* private - states bit positions */
5614enum _poll_states_bits {
5615 /* default state when creating event */
5616 _POLL_STATE_NOT_READY,
5617
5618 /* signaled by k_poll_signal_raise() */
5619 _POLL_STATE_SIGNALED,
5620
5621 /* semaphore is available */
5622 _POLL_STATE_SEM_AVAILABLE,
5623
5624 /* data is available to read on queue/FIFO/LIFO */
5625 _POLL_STATE_DATA_AVAILABLE,
5626
5627 /* queue/FIFO/LIFO wait was cancelled */
5628 _POLL_STATE_CANCELLED,
5629
5630 /* data is available to read on a message queue */
5631 _POLL_STATE_MSGQ_DATA_AVAILABLE,
5632
5633 /* data is available to read from a pipe */
5634 _POLL_STATE_PIPE_DATA_AVAILABLE,
5635
5636 _POLL_NUM_STATES
5637};
5638
5639#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
5640
5641#define _POLL_EVENT_NUM_UNUSED_BITS \
5642 (32 - (0 \
5643 + 8 /* tag */ \
5644 + _POLL_NUM_TYPES \
5645 + _POLL_NUM_STATES \
5646 + 1 /* modes */ \
5647 ))
5648
5649/* end of polling API - PRIVATE */
5650
5651
5658/* Public polling API */
5659
5660/* public - values for k_poll_event.type bitfield */
5661#define K_POLL_TYPE_IGNORE 0
5662#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
5663#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
5664#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
5665#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
5666#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
5667#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
5668
5669/* public - polling modes */
5671 /* polling thread does not take ownership of objects when available */
5673
5676
5677/* public - values for k_poll_event.state bitfield */
5678#define K_POLL_STATE_NOT_READY 0
5679#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
5680#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
5681#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
5682#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
5683#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
5684#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
5685#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
5686
5687/* public - poll signal object */
5691
5696 unsigned int signaled;
5697
5700};
5701
5702#define K_POLL_SIGNAL_INITIALIZER(obj) \
5703 { \
5704 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
5705 .signaled = 0, \
5706 .result = 0, \
5707 }
5714 sys_dnode_t _node;
5715
5717 struct z_poller *poller;
5718
5721
5723 uint32_t type:_POLL_NUM_TYPES;
5724
5726 uint32_t state:_POLL_NUM_STATES;
5727
5730
5732 uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
5733
5735 union {
5736 /* The typed_* fields below are used by K_POLL_EVENT_*INITIALIZER() macros to ensure
5737 * type safety of polled objects.
5738 */
5739 void *obj, *typed_K_POLL_TYPE_IGNORE;
5740 struct k_poll_signal *signal, *typed_K_POLL_TYPE_SIGNAL;
5741 struct k_sem *sem, *typed_K_POLL_TYPE_SEM_AVAILABLE;
5742 struct k_fifo *fifo, *typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE;
5743 struct k_queue *queue, *typed_K_POLL_TYPE_DATA_AVAILABLE;
5744 struct k_msgq *msgq, *typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE;
5745#ifdef CONFIG_PIPES
5746 struct k_pipe *pipe, *typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE;
5747#endif
5748 };
5749};
5750
5751#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
5752 { \
5753 .poller = NULL, \
5754 .type = _event_type, \
5755 .state = K_POLL_STATE_NOT_READY, \
5756 .mode = _event_mode, \
5757 .unused = 0, \
5758 { \
5759 .typed_##_event_type = _event_obj, \
5760 }, \
5761 }
5762
5763#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
5764 event_tag) \
5765 { \
5766 .tag = event_tag, \
5767 .type = _event_type, \
5768 .state = K_POLL_STATE_NOT_READY, \
5769 .mode = _event_mode, \
5770 .unused = 0, \
5771 { \
5772 .typed_##_event_type = _event_obj, \
5773 }, \
5774 }
5775
5791void k_poll_event_init(struct k_poll_event *event, uint32_t type,
5792 int mode, void *obj);
5793
5837__syscall int k_poll(struct k_poll_event *events, int num_events,
5838 k_timeout_t timeout);
5839
5848__syscall void k_poll_signal_init(struct k_poll_signal *sig);
5849
5855__syscall void k_poll_signal_reset(struct k_poll_signal *sig);
5856
5867__syscall void k_poll_signal_check(struct k_poll_signal *sig,
5868 unsigned int *signaled, int *result);
5869
5894__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);
5895
5916static inline void k_cpu_idle(void)
5917{
5918 arch_cpu_idle();
5919}
5920
5935static inline void k_cpu_atomic_idle(unsigned int key)
5936{
5938}
5939
5948#ifdef ARCH_EXCEPT
5949/* This architecture has direct support for triggering a CPU exception */
5950#define z_except_reason(reason) ARCH_EXCEPT(reason)
5951#else
5952
5953#if !defined(CONFIG_ASSERT_NO_FILE_INFO)
5954#define __EXCEPT_LOC() __ASSERT_PRINT("@ %s:%d\n", __FILE__, __LINE__)
5955#else
5956#define __EXCEPT_LOC()
5957#endif
5958
5959/* NOTE: This is the implementation for arches that do not implement
5960 * ARCH_EXCEPT() to generate a real CPU exception.
5961 *
5962 * We won't have a real exception frame to determine the PC value when
5963 * the oops occurred, so print file and line number before we jump into
5964 * the fatal error handler.
5965 */
5966#define z_except_reason(reason) do { \
5967 __EXCEPT_LOC(); \
5968 z_fatal_error(reason, NULL); \
5969 } while (false)
5970
5971#endif /* _ARCH__EXCEPT */
5987#define k_oops() z_except_reason(K_ERR_KERNEL_OOPS)
5988
5997#define k_panic() z_except_reason(K_ERR_KERNEL_PANIC)
5998
6003/*
6004 * private APIs that are utilized by one or more public APIs
6005 */
6006
6010void z_timer_expiration_handler(struct _timeout *timeout);
6015#ifdef CONFIG_PRINTK
6023__syscall void k_str_out(char *c, size_t n);
6024#endif
6025
6052__syscall int k_float_disable(struct k_thread *thread);
6053
6092__syscall int k_float_enable(struct k_thread *thread, unsigned int options);
6093
6107
6115
6126
6137
6146
6155
6156#ifdef __cplusplus
6157}
6158#endif
6159
6160#include <zephyr/tracing/tracing.h>
6161#include <zephyr/syscalls/kernel.h>
6162
6163#endif /* !_ASMLANGUAGE */
6164
6165#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
struct z_thread_stack_element k_thread_stack_t
Typedef of struct z_thread_stack_element.
Definition: arch_interface.h:46
void(* k_thread_entry_t)(void *p1, void *p2, void *p3)
Thread entry point function type.
Definition: arch_interface.h:48
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 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.
Definition: atomic.h:170
static uint32_t k_cycle_get_32(void)
Read the hardware clock.
Definition: kernel.h:1820
#define K_NO_WAIT
Generate null timeout delay.
Definition: kernel.h:1253
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:1772
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:1801
static uint32_t k_uptime_seconds(void)
Get system uptime in seconds.
Definition: kernel.h:1785
static uint64_t k_cycle_get_64(void)
Read the 64-bit hardware clock.
Definition: kernel.h:1835
static int64_t k_uptime_get(void)
Get system uptime.
Definition: kernel.h:1748
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:5916
static void k_cpu_atomic_idle(unsigned int key)
Make the CPU idle in an atomic fashion.
Definition: kernel.h:5935
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:2368
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_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:1108
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:5241
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:5256
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:5276
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:5670
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:5672
@ K_POLL_NUM_MODES
Definition: kernel.h:5674
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:360
#define IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition: util_macro.h:124
#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:268
#define EBUSY
Mount device busy.
Definition: errno.h:55
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:394
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:489
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:586
int k_thread_cpu_mask_clear(k_tid_t thread)
Sets all CPU enable masks to zero.
void k_sched_time_slice_set(int32_t slice, int prio)
Set time-slicing period and scope.
void k_thread_start(k_tid_t thread)
Start an inactive thread.
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.
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_thread_deadline_set(k_tid_t thread, int deadline)
Set deadline expiration time for scheduler.
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.
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_stop_t)(struct k_timer *timer)
Timer stop function type.
Definition: kernel.h:1529
void * k_timer_user_data_get(const struct k_timer *timer)
Retrieve the user-specific data from a timer.
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_expiry_t)(struct k_timer *timer)
Timer expiry function type.
Definition: kernel.h:1513
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:1672
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:4081
static bool k_work_is_pending(const struct k_work *work)
Test whether a work item is currently pending.
Definition: kernel.h:4052
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:4069
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.
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:4208
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:4185
void(* k_work_handler_t)(struct k_work *work)
The signature for a work item handler function.
Definition: kernel.h:3276
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:4063
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:4163
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.
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:4263
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:4058
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:4075
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.
void(* k_work_user_handler_t)(struct k_work_user *work)
Work item handler function type for user work queues.
Definition: kernel.h:4104
@ K_WORK_CANCELING
Flag indicating a work item that is being canceled.
Definition: kernel.h:3853
@ K_WORK_QUEUED
Flag indicating a work item that has been submitted to a queue but has not started running.
Definition: kernel.h:3860
@ K_WORK_DELAYED
Flag indicating a delayed work item that is scheduled for submission to a queue.
Definition: kernel.h:3867
@ K_WORK_RUNNING
Flag indicating a work item that is running under a work queue thread.
Definition: kernel.h:3847
@ K_WORK_FLUSHING
Flag indicating a synced work item that is being flushed.
Definition: kernel.h:3873
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.
Header files included by kernel.h.
void(* k_thread_timeslice_fn_t)(struct k_thread *thread, void *data)
Definition: kernel_structs.h:307
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:3026
_wait_q_t wait_q
Definition: kernel.h:3027
Event Structure.
Definition: kernel.h:2221
struct k_spinlock lock
Definition: kernel.h:2224
uint32_t events
Definition: kernel.h:2223
_wait_q_t wait_q
Definition: kernel.h:2222
Definition: kernel.h:2388
futex structure
Definition: kernel.h:2142
atomic_t val
Definition: kernel.h:2143
Definition: kernel.h:5317
struct k_spinlock lock
Definition: kernel.h:5320
struct sys_heap heap
Definition: kernel.h:5318
_wait_q_t wait_q
Definition: kernel.h:5319
Definition: kernel.h:2627
Mailbox Message Structure.
Definition: kernel.h:4714
k_tid_t tx_target_thread
target thread id
Definition: kernel.h:4724
void * tx_data
sender's message data buffer
Definition: kernel.h:4720
k_tid_t rx_source_thread
source thread id
Definition: kernel.h:4722
uint32_t info
application-defined information value
Definition: kernel.h:4718
size_t size
size of message (in bytes)
Definition: kernel.h:4716
Mailbox Structure.
Definition: kernel.h:4736
_wait_q_t tx_msg_queue
Transmit messages queue.
Definition: kernel.h:4738
struct k_spinlock lock
Definition: kernel.h:4741
_wait_q_t rx_msg_queue
Receive message queue.
Definition: kernel.h:4740
Memory Domain.
Definition: mem_domain.h:80
Memory Partition.
Definition: mem_domain.h:55
Message Queue Attributes.
Definition: kernel.h:4482
uint32_t used_msgs
Used messages.
Definition: kernel.h:4488
size_t msg_size
Message Size.
Definition: kernel.h:4484
uint32_t max_msgs
Maximal number of messages.
Definition: kernel.h:4486
Message Queue Structure.
Definition: kernel.h:4423
size_t msg_size
Message size.
Definition: kernel.h:4429
char * read_ptr
Read pointer.
Definition: kernel.h:4437
uint32_t used_msgs
Number of used messages.
Definition: kernel.h:4441
char * buffer_end
End of message buffer.
Definition: kernel.h:4435
struct k_spinlock lock
Lock.
Definition: kernel.h:4427
char * write_ptr
Write pointer.
Definition: kernel.h:4439
char * buffer_start
Start of message buffer.
Definition: kernel.h:4433
uint8_t flags
Message queue.
Definition: kernel.h:4446
_wait_q_t wait_q
Message queue wait queue.
Definition: kernel.h:4425
uint32_t max_msgs
Maximal number of messages.
Definition: kernel.h:4431
Mutex Structure.
Definition: kernel.h:2914
uint32_t lock_count
Current lock count.
Definition: kernel.h:2921
_wait_q_t wait_q
Mutex wait queue.
Definition: kernel.h:2916
int owner_orig_prio
Original thread priority.
Definition: kernel.h:2924
struct k_thread * owner
Mutex owner.
Definition: kernel.h:2918
Object core structure.
Definition: obj_core.h:121
Pipe Structure.
Definition: kernel.h:4867
uint8_t flags
Wait queue.
Definition: kernel.h:4882
_wait_q_t readers
Reader wait queue.
Definition: kernel.h:4876
size_t write_index
Where in buffer to write.
Definition: kernel.h:4872
size_t bytes_used
Number of bytes used in buffer.
Definition: kernel.h:4870
struct k_spinlock lock
Synchronization lock.
Definition: kernel.h:4873
_wait_q_t writers
Writer wait queue.
Definition: kernel.h:4877
size_t size
Buffer size.
Definition: kernel.h:4869
unsigned char * buffer
Pipe buffer: may be NULL.
Definition: kernel.h:4868
struct k_pipe::@253 wait_q
size_t read_index
Where in buffer to read from.
Definition: kernel.h:4871
Poll Event.
Definition: kernel.h:5712
struct k_poll_signal * signal
Definition: kernel.h:5740
uint32_t tag
optional user-specified tag, opaque, untouched by the API
Definition: kernel.h:5720
struct k_fifo * fifo
Definition: kernel.h:5742
struct k_msgq * msgq
Definition: kernel.h:5744
struct k_queue * queue
Definition: kernel.h:5743
uint32_t unused
unused bits in 32-bit word
Definition: kernel.h:5732
uint32_t type
bitfield of event types (bitwise-ORed K_POLL_TYPE_xxx values)
Definition: kernel.h:5723
struct k_sem * sem
Definition: kernel.h:5741
uint32_t state
bitfield of event states (bitwise-ORed K_POLL_STATE_xxx values)
Definition: kernel.h:5726
uint32_t mode
mode of operation, from enum k_poll_modes
Definition: kernel.h:5729
struct z_poller * poller
PRIVATE - DO NOT TOUCH.
Definition: kernel.h:5717
void * obj
Definition: kernel.h:5739
Definition: kernel.h:5688
sys_dlist_t poll_events
PRIVATE - DO NOT TOUCH.
Definition: kernel.h:5690
int result
custom result value passed to k_poll_signal_raise() if needed
Definition: kernel.h:5699
unsigned int signaled
1 if the event has been signaled, 0 otherwise.
Definition: kernel.h:5696
Definition: kernel.h:1850
struct k_spinlock lock
Definition: kernel.h:1852
_wait_q_t wait_q
Definition: kernel.h:1853
sys_sflist_t data_q
Definition: kernel.h:1851
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:3905
struct _timeout timeout
Definition: kernel.h:3910
struct k_work_q * queue
Definition: kernel.h:3913
struct k_work work
Definition: kernel.h:3907
A structure used to hold work until it can be processed.
Definition: kernel.h:4029
sys_slist_t pending
Definition: kernel.h:4038
_wait_q_t drainq
Definition: kernel.h:4044
_wait_q_t notifyq
Definition: kernel.h:4041
uint32_t flags
Definition: kernel.h:4047
struct k_thread thread
Definition: kernel.h:4031
A structure holding optional configuration items for a work queue.
Definition: kernel.h:4001
const char * name
The name to be given to the work queue thread.
Definition: kernel.h:4006
bool essential
Control whether the work queue thread should be marked as essential thread.
Definition: kernel.h:4025
bool no_yield
Control whether the work queue thread should yield between items.
Definition: kernel.h:4020
A structure holding internal state for a pending synchronous operation on a work item or queue.
Definition: kernel.h:3988
struct z_work_canceller canceller
Definition: kernel.h:3991
struct z_work_flusher flusher
Definition: kernel.h:3990
A structure used to submit work.
Definition: kernel.h:3877
k_work_handler_t handler
Definition: kernel.h:3886
uint32_t flags
Definition: kernel.h:3897
struct k_work_q * queue
Definition: kernel.h:3889
sys_snode_t node
Definition: kernel.h:3883
Definition: sys_heap.h:56
Definition: mem_stats.h:24
Macros to abstract toolchain specific capabilities.