Zephyr API Documentation 4.2.99
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
12
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>
26
27#ifdef __cplusplus
28extern "C" {
29#endif
30
31/*
32 * Zephyr currently assumes the size of a couple standard types to simplify
33 * print string formats. Let's make sure this doesn't change without notice.
34 */
35BUILD_ASSERT(sizeof(int32_t) == sizeof(int));
36BUILD_ASSERT(sizeof(int64_t) == sizeof(long long));
37BUILD_ASSERT(sizeof(intptr_t) == sizeof(long));
38
47
48#define K_ANY NULL
49
50#if (CONFIG_NUM_COOP_PRIORITIES + CONFIG_NUM_PREEMPT_PRIORITIES) == 0
51#error Zero available thread priorities defined!
52#endif
53
54#define K_PRIO_COOP(x) (-(CONFIG_NUM_COOP_PRIORITIES - (x)))
55#define K_PRIO_PREEMPT(x) (x)
56
57#define K_HIGHEST_THREAD_PRIO (-CONFIG_NUM_COOP_PRIORITIES)
58#define K_LOWEST_THREAD_PRIO CONFIG_NUM_PREEMPT_PRIORITIES
59#define K_IDLE_PRIO K_LOWEST_THREAD_PRIO
60#define K_HIGHEST_APPLICATION_THREAD_PRIO (K_HIGHEST_THREAD_PRIO)
61#define K_LOWEST_APPLICATION_THREAD_PRIO (K_LOWEST_THREAD_PRIO - 1)
62
63#ifdef CONFIG_POLL
64#define Z_POLL_EVENT_OBJ_INIT(obj) \
65 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events),
66#define Z_DECL_POLL_EVENT sys_dlist_t poll_events;
67#else
68#define Z_POLL_EVENT_OBJ_INIT(obj)
69#define Z_DECL_POLL_EVENT
70#endif
71
72struct k_thread;
73struct k_mutex;
74struct k_sem;
75struct k_msgq;
76struct k_mbox;
77struct k_pipe;
78struct k_queue;
79struct k_fifo;
80struct k_lifo;
81struct k_stack;
82struct k_mem_slab;
83struct k_timer;
84struct k_poll_event;
85struct k_poll_signal;
86struct k_mem_domain;
87struct k_mem_partition;
88struct k_futex;
89struct k_event;
90
96
97/* private, used by k_poll and k_work_poll */
98struct k_work_poll;
99typedef int (*_poller_cb_t)(struct k_poll_event *event, uint32_t state);
100
105
106typedef void (*k_thread_user_cb_t)(const struct k_thread *thread,
107 void *user_data);
108
124void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data);
125
144#ifdef CONFIG_SMP
145void k_thread_foreach_filter_by_cpu(unsigned int cpu,
146 k_thread_user_cb_t user_cb, void *user_data);
147#else
148static inline
149void k_thread_foreach_filter_by_cpu(unsigned int cpu,
150 k_thread_user_cb_t user_cb, void *user_data)
151{
152 __ASSERT(cpu == 0, "cpu filter out of bounds");
153 ARG_UNUSED(cpu);
154 k_thread_foreach(user_cb, user_data);
155}
156#endif
157
186 k_thread_user_cb_t user_cb, void *user_data);
187
219#ifdef CONFIG_SMP
221 k_thread_user_cb_t user_cb, void *user_data);
222#else
223static inline
224void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
225 k_thread_user_cb_t user_cb, void *user_data)
226{
227 __ASSERT(cpu == 0, "cpu filter out of bounds");
228 ARG_UNUSED(cpu);
229 k_thread_foreach_unlocked(user_cb, user_data);
230}
231#endif
232
234
240
241#endif /* !_ASMLANGUAGE */
242
243
244/*
245 * Thread user options. May be needed by assembly code. Common part uses low
246 * bits, arch-specific use high bits.
247 */
248
252#define K_ESSENTIAL (BIT(0))
253
254#define K_FP_IDX 1
264#define K_FP_REGS (BIT(K_FP_IDX))
265
272#define K_USER (BIT(2))
273
282#define K_INHERIT_PERMS (BIT(3))
283
293#define K_CALLBACK_STATE (BIT(4))
294
304#define K_DSP_IDX 6
305#define K_DSP_REGS (BIT(K_DSP_IDX))
306
315#define K_AGU_IDX 7
316#define K_AGU_REGS (BIT(K_AGU_IDX))
317
327#define K_SSE_REGS (BIT(7))
328
329/* end - thread options */
330
331#if !defined(_ASMLANGUAGE)
356__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);
357
371
423__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
424 k_thread_stack_t *stack,
425 size_t stack_size,
427 void *p1, void *p2, void *p3,
428 int prio, uint32_t options, k_timeout_t delay);
429
452 void *p1, void *p2,
453 void *p3);
454
468#define k_thread_access_grant(thread, ...) \
469 FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)
470
485static inline void k_thread_heap_assign(struct k_thread *thread,
486 struct k_heap *heap)
487{
488 thread->resource_pool = heap;
489}
490
491#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
512__syscall int k_thread_stack_space_get(const struct k_thread *thread,
513 size_t *unused_ptr);
514#endif
515
516#if (K_HEAP_MEM_POOL_SIZE > 0)
529void k_thread_system_pool_assign(struct k_thread *thread);
530#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */
531
551__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);
552
566__syscall int32_t k_sleep(k_timeout_t timeout);
567
579static inline int32_t k_msleep(int32_t ms)
580{
581 return k_sleep(Z_TIMEOUT_MS(ms));
582}
583
601
618__syscall void k_busy_wait(uint32_t usec_to_wait);
619
631bool k_can_yield(void);
632
640__syscall void k_yield(void);
641
651__syscall void k_wakeup(k_tid_t thread);
652
666__attribute_const__
668
675__attribute_const__
676static inline k_tid_t k_current_get(void)
677{
678#ifdef CONFIG_CURRENT_THREAD_USE_TLS
679
680 /* Thread-local cache of current thread ID, set in z_thread_entry() */
681 extern Z_THREAD_LOCAL k_tid_t z_tls_current;
682
683 return z_tls_current;
684#else
686#endif
687}
688
708__syscall void k_thread_abort(k_tid_t thread);
709
710k_ticks_t z_timeout_expires(const struct _timeout *timeout);
711k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
712
713#ifdef CONFIG_SYS_CLOCK_EXISTS
714
722__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
723
724static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
725 const struct k_thread *thread)
726{
727 return z_timeout_expires(&thread->base.timeout);
728}
729
738
739static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
740 const struct k_thread *thread)
741{
742 return z_timeout_remaining(&thread->base.timeout);
743}
744
745#endif /* CONFIG_SYS_CLOCK_EXISTS */
746
750
751struct _static_thread_data {
752 struct k_thread *init_thread;
753 k_thread_stack_t *init_stack;
754 unsigned int init_stack_size;
755 k_thread_entry_t init_entry;
756 void *init_p1;
757 void *init_p2;
758 void *init_p3;
759 int init_prio;
760 uint32_t init_options;
761 const char *init_name;
762#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
763 int32_t init_delay_ms;
764#else
765 k_timeout_t init_delay;
766#endif
767};
768
769#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
770#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
771#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
772#else
773#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS_INIT(ms)
774#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
775#endif
776
777#define Z_THREAD_INITIALIZER(thread, stack, stack_size, \
778 entry, p1, p2, p3, \
779 prio, options, delay, tname) \
780 { \
781 .init_thread = (thread), \
782 .init_stack = (stack), \
783 .init_stack_size = (stack_size), \
784 .init_entry = (k_thread_entry_t)entry, \
785 .init_p1 = (void *)p1, \
786 .init_p2 = (void *)p2, \
787 .init_p3 = (void *)p3, \
788 .init_prio = (prio), \
789 .init_options = (options), \
790 .init_name = STRINGIFY(tname), \
791 Z_THREAD_INIT_DELAY_INITIALIZER(delay) \
792 }
793
794/*
795 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
796 * information on arguments.
797 */
798#define Z_THREAD_COMMON_DEFINE(name, stack_size, \
799 entry, p1, p2, p3, \
800 prio, options, delay) \
801 struct k_thread _k_thread_obj_##name; \
802 STRUCT_SECTION_ITERABLE(_static_thread_data, \
803 _k_thread_data_##name) = \
804 Z_THREAD_INITIALIZER(&_k_thread_obj_##name, \
805 _k_thread_stack_##name, stack_size,\
806 entry, p1, p2, p3, prio, options, \
807 delay, name); \
808 __maybe_unused const k_tid_t name = (k_tid_t)&_k_thread_obj_##name
809
813
845#define K_THREAD_DEFINE(name, stack_size, \
846 entry, p1, p2, p3, \
847 prio, options, delay) \
848 K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
849 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
850 prio, options, delay)
851
882#define K_KERNEL_THREAD_DEFINE(name, stack_size, \
883 entry, p1, p2, p3, \
884 prio, options, delay) \
885 K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
886 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
887 prio, options, delay)
888
898__syscall int k_thread_priority_get(k_tid_t thread);
899
925__syscall void k_thread_priority_set(k_tid_t thread, int prio);
926
927
928#ifdef CONFIG_SCHED_DEADLINE
961__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);
962
1004__syscall void k_thread_absolute_deadline_set(k_tid_t thread, int deadline);
1005#endif
1006
1025__syscall void k_reschedule(void);
1026
1027#ifdef CONFIG_SCHED_CPU_MASK
1041
1055
1069
1083
1094int k_thread_cpu_pin(k_tid_t thread, int cpu);
1095#endif
1096
1118__syscall void k_thread_suspend(k_tid_t thread);
1119
1131__syscall void k_thread_resume(k_tid_t thread);
1132
1146static inline void k_thread_start(k_tid_t thread)
1147{
1148 k_wakeup(thread);
1149}
1150
1177void k_sched_time_slice_set(int32_t slice, int prio);
1178
1217void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
1218 k_thread_timeslice_fn_t expired, void *data);
1219
1221
1226
1238bool k_is_in_isr(void);
1239
1256__syscall int k_is_preempt_thread(void);
1257
1269static inline bool k_is_pre_kernel(void)
1270{
1271 extern bool z_sys_post_kernel; /* in init.c */
1272
1273 return !z_sys_post_kernel;
1274}
1275
1279
1284
1310void k_sched_lock(void);
1311
1320
1333__syscall void k_thread_custom_data_set(void *value);
1334
1342__syscall void *k_thread_custom_data_get(void);
1343
1357__syscall int k_thread_name_set(k_tid_t thread, const char *str);
1358
1367const char *k_thread_name_get(k_tid_t thread);
1368
1380__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
1381 size_t size);
1382
1395const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);
1396
1400
1405
1414#define K_NO_WAIT Z_TIMEOUT_NO_WAIT
1415
1428#define K_NSEC(t) Z_TIMEOUT_NS(t)
1429
1442#define K_USEC(t) Z_TIMEOUT_US(t)
1443
1454#define K_CYC(t) Z_TIMEOUT_CYC(t)
1455
1466#define K_TICKS(t) Z_TIMEOUT_TICKS(t)
1467
1478#define K_MSEC(ms) Z_TIMEOUT_MS(ms)
1479
1490#define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
1491
1502#define K_MINUTES(m) K_SECONDS((m) * 60)
1503
1514#define K_HOURS(h) K_MINUTES((h) * 60)
1515
1524#define K_FOREVER Z_FOREVER
1525
1526#ifdef CONFIG_TIMEOUT_64BIT
1527
1539#define K_TIMEOUT_ABS_TICKS(t) \
1540 Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)CLAMP(t, 0, (INT64_MAX - 1))))
1541
1553#define K_TIMEOUT_ABS_SEC(t) K_TIMEOUT_ABS_TICKS(k_sec_to_ticks_ceil64(t))
1554
1566#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))
1567
1580#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))
1581
1594#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))
1595
1608#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
1609
1610#endif
1611
1615
1622struct k_timer {
1626
1627 /*
1628 * _timeout structure must be first here if we want to use
1629 * dynamic timer allocation. timeout.node is used in the double-linked
1630 * list of free timers
1631 */
1632 struct _timeout timeout;
1633
1634 /* wait queue for the (single) thread waiting on this timer */
1635 _wait_q_t wait_q;
1636
1637 /* runs in ISR context */
1638 void (*expiry_fn)(struct k_timer *timer);
1639
1640 /* runs in the context of the thread that calls k_timer_stop() */
1641 void (*stop_fn)(struct k_timer *timer);
1642
1643 /* timer period */
1644 k_timeout_t period;
1645
1646 /* timer status */
1647 uint32_t status;
1648
1649 /* user-specific data, also used to support legacy features */
1650 void *user_data;
1651
1653
1654#ifdef CONFIG_OBJ_CORE_TIMER
1655 struct k_obj_core obj_core;
1656#endif
1660};
1661
1665#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
1666 { \
1667 .timeout = { \
1668 .node = {},\
1669 .fn = z_timer_expiration_handler, \
1670 .dticks = 0, \
1671 }, \
1672 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1673 .expiry_fn = expiry, \
1674 .stop_fn = stop, \
1675 .period = {}, \
1676 .status = 0, \
1677 .user_data = 0, \
1678 }
1679
1683
1689
1700typedef void (*k_timer_expiry_t)(struct k_timer *timer);
1701
1716typedef void (*k_timer_stop_t)(struct k_timer *timer);
1717
1729#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
1730 STRUCT_SECTION_ITERABLE(k_timer, name) = \
1731 Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
1732
1742void k_timer_init(struct k_timer *timer,
1743 k_timer_expiry_t expiry_fn,
1744 k_timer_stop_t stop_fn);
1745
1763__syscall void k_timer_start(struct k_timer *timer,
1764 k_timeout_t duration, k_timeout_t period);
1765
1782__syscall void k_timer_stop(struct k_timer *timer);
1783
1796__syscall uint32_t k_timer_status_get(struct k_timer *timer);
1797
1815__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
1816
1817#ifdef CONFIG_SYS_CLOCK_EXISTS
1818
1829__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
1830
1831static inline k_ticks_t z_impl_k_timer_expires_ticks(
1832 const struct k_timer *timer)
1833{
1834 return z_timeout_expires(&timer->timeout);
1835}
1836
1847__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
1848
1849static inline k_ticks_t z_impl_k_timer_remaining_ticks(
1850 const struct k_timer *timer)
1851{
1852 return z_timeout_remaining(&timer->timeout);
1853}
1854
1865static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
1866{
1868}
1869
1870#endif /* CONFIG_SYS_CLOCK_EXISTS */
1871
1884__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);
1885
1889static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
1890 void *user_data)
1891{
1892 timer->user_data = user_data;
1893}
1894
1902__syscall void *k_timer_user_data_get(const struct k_timer *timer);
1903
1904static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
1905{
1906 return timer->user_data;
1907}
1908
1910
1916
1926__syscall int64_t k_uptime_ticks(void);
1927
1941static inline int64_t k_uptime_get(void)
1942{
1944}
1945
1965static inline uint32_t k_uptime_get_32(void)
1966{
1967 return (uint32_t)k_uptime_get();
1968}
1969
1978static inline uint32_t k_uptime_seconds(void)
1979{
1981}
1982
1994static inline int64_t k_uptime_delta(int64_t *reftime)
1995{
1996 int64_t uptime, delta;
1997
1998 uptime = k_uptime_get();
1999 delta = uptime - *reftime;
2000 *reftime = uptime;
2001
2002 return delta;
2003}
2004
2013static inline uint32_t k_cycle_get_32(void)
2014{
2015 return arch_k_cycle_get_32();
2016}
2017
2028static inline uint64_t k_cycle_get_64(void)
2029{
2030 if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
2031 __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
2032 "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
2033 return 0;
2034 }
2035
2036 return arch_k_cycle_get_64();
2037}
2038
2042
2043struct k_queue {
2046 _wait_q_t wait_q;
2047
2048 Z_DECL_POLL_EVENT
2049
2051};
2052
2056
2057#define Z_QUEUE_INITIALIZER(obj) \
2058 { \
2059 .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
2060 .lock = { }, \
2061 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2062 Z_POLL_EVENT_OBJ_INIT(obj) \
2063 }
2064
2068
2074
2082__syscall void k_queue_init(struct k_queue *queue);
2083
2097__syscall void k_queue_cancel_wait(struct k_queue *queue);
2098
2111void k_queue_append(struct k_queue *queue, void *data);
2112
2129__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);
2130
2143void k_queue_prepend(struct k_queue *queue, void *data);
2144
2161__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);
2162
2176void k_queue_insert(struct k_queue *queue, void *prev, void *data);
2177
2196int k_queue_append_list(struct k_queue *queue, void *head, void *tail);
2197
2213int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);
2214
2232__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);
2233
2250bool k_queue_remove(struct k_queue *queue, void *data);
2251
2266bool k_queue_unique_append(struct k_queue *queue, void *data);
2267
2281__syscall int k_queue_is_empty(struct k_queue *queue);
2282
2283static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
2284{
2285 return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
2286}
2287
2297__syscall void *k_queue_peek_head(struct k_queue *queue);
2298
2308__syscall void *k_queue_peek_tail(struct k_queue *queue);
2309
2319#define K_QUEUE_DEFINE(name) \
2320 STRUCT_SECTION_ITERABLE(k_queue, name) = \
2321 Z_QUEUE_INITIALIZER(name)
2322
2324
2325#ifdef CONFIG_USERSPACE
2335struct k_futex {
2337};
2338
2346struct z_futex_data {
2347 _wait_q_t wait_q;
2348 struct k_spinlock lock;
2349};
2350
2351#define Z_FUTEX_DATA_INITIALIZER(obj) \
2352 { \
2353 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q) \
2354 }
2355
2361
2381__syscall int k_futex_wait(struct k_futex *futex, int expected,
2382 k_timeout_t timeout);
2383
2398__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);
2399
2401#endif
2402
2408
2413
2420
2421struct k_event {
2425 _wait_q_t wait_q;
2426 uint32_t events;
2427 struct k_spinlock lock;
2428
2430
2431#ifdef CONFIG_OBJ_CORE_EVENT
2432 struct k_obj_core obj_core;
2433#endif
2437
2438};
2439
2443
2444#define Z_EVENT_INITIALIZER(obj) \
2445 { \
2446 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2447 .events = 0, \
2448 .lock = {}, \
2449 }
2453
2461__syscall void k_event_init(struct k_event *event);
2462
2480__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);
2481
2499__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);
2500
2517__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
2518 uint32_t events_mask);
2519
2532__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);
2533
2558__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
2559 bool reset, k_timeout_t timeout);
2560
2585__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
2586 bool reset, k_timeout_t timeout);
2587
2607__syscall uint32_t k_event_wait_safe(struct k_event *event, uint32_t events,
2608 bool reset, k_timeout_t timeout);
2609
2629__syscall uint32_t k_event_wait_all_safe(struct k_event *event, uint32_t events,
2630 bool reset, k_timeout_t timeout);
2631
2632
2633
2644static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
2645{
2646 return k_event_wait(event, events_mask, false, K_NO_WAIT);
2647}
2648
2658#define K_EVENT_DEFINE(name) \
2659 STRUCT_SECTION_ITERABLE(k_event, name) = \
2660 Z_EVENT_INITIALIZER(name);
2661
2663
2664struct k_fifo {
2665 struct k_queue _queue;
2666#ifdef CONFIG_OBJ_CORE_FIFO
2667 struct k_obj_core obj_core;
2668#endif
2669};
2670
2674#define Z_FIFO_INITIALIZER(obj) \
2675 { \
2676 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2677 }
2678
2682
2688
2696#define k_fifo_init(fifo) \
2697 ({ \
2698 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
2699 k_queue_init(&(fifo)->_queue); \
2700 K_OBJ_CORE_INIT(K_OBJ_CORE(fifo), _obj_type_fifo); \
2701 K_OBJ_CORE_LINK(K_OBJ_CORE(fifo)); \
2702 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo); \
2703 })
2704
2716#define k_fifo_cancel_wait(fifo) \
2717 ({ \
2718 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
2719 k_queue_cancel_wait(&(fifo)->_queue); \
2720 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
2721 })
2722
2735#define k_fifo_put(fifo, data) \
2736 ({ \
2737 void *_data = data; \
2738 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, _data); \
2739 k_queue_append(&(fifo)->_queue, _data); \
2740 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, _data); \
2741 })
2742
2759#define k_fifo_alloc_put(fifo, data) \
2760 ({ \
2761 void *_data = data; \
2762 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, _data); \
2763 int fap_ret = k_queue_alloc_append(&(fifo)->_queue, _data); \
2764 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, _data, fap_ret); \
2765 fap_ret; \
2766 })
2767
2782#define k_fifo_put_list(fifo, head, tail) \
2783 ({ \
2784 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
2785 k_queue_append_list(&(fifo)->_queue, head, tail); \
2786 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
2787 })
2788
2802#define k_fifo_put_slist(fifo, list) \
2803 ({ \
2804 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
2805 k_queue_merge_slist(&(fifo)->_queue, list); \
2806 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
2807 })
2808
2826#define k_fifo_get(fifo, timeout) \
2827 ({ \
2828 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
2829 void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
2830 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
2831 fg_ret; \
2832 })
2833
2847#define k_fifo_is_empty(fifo) \
2848 k_queue_is_empty(&(fifo)->_queue)
2849
2863#define k_fifo_peek_head(fifo) \
2864 ({ \
2865 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
2866 void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
2867 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
2868 fph_ret; \
2869 })
2870
2882#define k_fifo_peek_tail(fifo) \
2883 ({ \
2884 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
2885 void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
2886 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
2887 fpt_ret; \
2888 })
2889
2899#define K_FIFO_DEFINE(name) \
2900 STRUCT_SECTION_ITERABLE(k_fifo, name) = \
2901 Z_FIFO_INITIALIZER(name)
2902
2904
2905struct k_lifo {
2906 struct k_queue _queue;
2907#ifdef CONFIG_OBJ_CORE_LIFO
2908 struct k_obj_core obj_core;
2909#endif
2910};
2911
2915
2916#define Z_LIFO_INITIALIZER(obj) \
2917 { \
2918 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2919 }
2920
2924
2930
2938#define k_lifo_init(lifo) \
2939 ({ \
2940 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
2941 k_queue_init(&(lifo)->_queue); \
2942 K_OBJ_CORE_INIT(K_OBJ_CORE(lifo), _obj_type_lifo); \
2943 K_OBJ_CORE_LINK(K_OBJ_CORE(lifo)); \
2944 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo); \
2945 })
2946
2959#define k_lifo_put(lifo, data) \
2960 ({ \
2961 void *_data = data; \
2962 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, _data); \
2963 k_queue_prepend(&(lifo)->_queue, _data); \
2964 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, _data); \
2965 })
2966
2983#define k_lifo_alloc_put(lifo, data) \
2984 ({ \
2985 void *_data = data; \
2986 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, _data); \
2987 int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, _data); \
2988 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, _data, lap_ret); \
2989 lap_ret; \
2990 })
2991
3009#define k_lifo_get(lifo, timeout) \
3010 ({ \
3011 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
3012 void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
3013 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
3014 lg_ret; \
3015 })
3016
3026#define K_LIFO_DEFINE(name) \
3027 STRUCT_SECTION_ITERABLE(k_lifo, name) = \
3028 Z_LIFO_INITIALIZER(name)
3029
3031
3035#define K_STACK_FLAG_ALLOC ((uint8_t)1) /* Buffer was allocated */
3036
3037typedef uintptr_t stack_data_t;
3038
3039struct k_stack {
3040 _wait_q_t wait_q;
3041 struct k_spinlock lock;
3042 stack_data_t *base, *next, *top;
3043
3044 uint8_t flags;
3045
3047
3048#ifdef CONFIG_OBJ_CORE_STACK
3049 struct k_obj_core obj_core;
3050#endif
3051};
3052
3053#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
3054 { \
3055 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3056 .base = (stack_buffer), \
3057 .next = (stack_buffer), \
3058 .top = (stack_buffer) + (stack_num_entries), \
3059 }
3060
3064
3070
3080void k_stack_init(struct k_stack *stack,
3081 stack_data_t *buffer, uint32_t num_entries);
3082
3083
3097
3098__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
3099 uint32_t num_entries);
3100
3112int k_stack_cleanup(struct k_stack *stack);
3113
3127__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);
3128
3149__syscall int k_stack_pop(struct k_stack *stack, stack_data_t *data,
3150 k_timeout_t timeout);
3151
3162#define K_STACK_DEFINE(name, stack_num_entries) \
3163 stack_data_t __noinit \
3164 _k_stack_buf_##name[stack_num_entries]; \
3165 STRUCT_SECTION_ITERABLE(k_stack, name) = \
3166 Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
3167 stack_num_entries)
3168
3170
3174
3175struct k_work;
3176struct k_work_q;
3177struct k_work_queue_config;
3178extern struct k_work_q k_sys_work_q;
3179
3183
3189
3194struct k_mutex {
3196 _wait_q_t wait_q;
3199
3202
3205
3207
3208#ifdef CONFIG_OBJ_CORE_MUTEX
3209 struct k_obj_core obj_core;
3210#endif
3211};
3212
3216#define Z_MUTEX_INITIALIZER(obj) \
3217 { \
3218 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3219 .owner = NULL, \
3220 .lock_count = 0, \
3221 .owner_orig_prio = K_LOWEST_APPLICATION_THREAD_PRIO, \
3222 }
3223
3227
3237#define K_MUTEX_DEFINE(name) \
3238 STRUCT_SECTION_ITERABLE(k_mutex, name) = \
3239 Z_MUTEX_INITIALIZER(name)
3240
3253__syscall int k_mutex_init(struct k_mutex *mutex);
3254
3255
3277__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);
3278
3299__syscall int k_mutex_unlock(struct k_mutex *mutex);
3300
3304
3305
3307 _wait_q_t wait_q;
3308
3309#ifdef CONFIG_OBJ_CORE_CONDVAR
3310 struct k_obj_core obj_core;
3311#endif
3312};
3313
3314#define Z_CONDVAR_INITIALIZER(obj) \
3315 { \
3316 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
3317 }
3318
3324
3331__syscall int k_condvar_init(struct k_condvar *condvar);
3332
3339__syscall int k_condvar_signal(struct k_condvar *condvar);
3340
3348__syscall int k_condvar_broadcast(struct k_condvar *condvar);
3349
3367__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
3368 k_timeout_t timeout);
3369
3380#define K_CONDVAR_DEFINE(name) \
3381 STRUCT_SECTION_ITERABLE(k_condvar, name) = \
3382 Z_CONDVAR_INITIALIZER(name)
3383
3386
3392
3399struct k_sem {
3403 _wait_q_t wait_q;
3404 unsigned int count;
3405 unsigned int limit;
3406
3407 Z_DECL_POLL_EVENT
3408
3410
3411#ifdef CONFIG_OBJ_CORE_SEM
3412 struct k_obj_core obj_core;
3413#endif
3415};
3416
3420
3421#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
3422 { \
3423 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3424 .count = (initial_count), \
3425 .limit = (count_limit), \
3426 Z_POLL_EVENT_OBJ_INIT(obj) \
3427 }
3428
3432
3441#define K_SEM_MAX_LIMIT UINT_MAX
3442
3458__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
3459 unsigned int limit);
3460
3479__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);
3480
3491__syscall void k_sem_give(struct k_sem *sem);
3492
3502__syscall void k_sem_reset(struct k_sem *sem);
3503
3513__syscall unsigned int k_sem_count_get(struct k_sem *sem);
3514
3518static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
3519{
3520 return sem->count;
3521}
3522
3534#define K_SEM_DEFINE(name, initial_count, count_limit) \
3535 STRUCT_SECTION_ITERABLE(k_sem, name) = \
3536 Z_SEM_INITIALIZER(name, initial_count, count_limit); \
3537 BUILD_ASSERT(((count_limit) != 0) && \
3538 (((initial_count) < (count_limit)) || ((initial_count) == (count_limit))) && \
3539 ((count_limit) <= K_SEM_MAX_LIMIT));
3540
3542
3543#if defined(CONFIG_SCHED_IPI_SUPPORTED) || defined(__DOXYGEN__)
3544struct k_ipi_work;
3545
3546
3547typedef void (*k_ipi_func_t)(struct k_ipi_work *work);
3548
3559 sys_dnode_t node[CONFIG_MP_MAX_NUM_CPUS]; /* Node in IPI work queue */
3560 k_ipi_func_t func; /* Function to execute on target CPU */
3561 struct k_event event; /* Event to signal when processed */
3562 uint32_t bitmask; /* Bitmask of targeted CPUs */
3564};
3565
3566
3574static inline void k_ipi_work_init(struct k_ipi_work *work)
3575{
3576 k_event_init(&work->event);
3577 for (unsigned int i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
3578 sys_dnode_init(&work->node[i]);
3579 }
3580 work->bitmask = 0;
3581}
3582
3601int k_ipi_work_add(struct k_ipi_work *work, uint32_t cpu_bitmask,
3602 k_ipi_func_t func);
3603
3626int k_ipi_work_wait(struct k_ipi_work *work, k_timeout_t timeout);
3627
3637
3638#endif /* CONFIG_SCHED_IPI_SUPPORTED */
3639
3643
3644struct k_work_delayable;
3645struct k_work_sync;
3646
3650
3656
3663typedef void (*k_work_handler_t)(struct k_work *work);
3664
3678void k_work_init(struct k_work *work,
3680
3695int k_work_busy_get(const struct k_work *work);
3696
3710static inline bool k_work_is_pending(const struct k_work *work);
3711
3733 struct k_work *work);
3734
3743int k_work_submit(struct k_work *work);
3744
3769bool k_work_flush(struct k_work *work,
3770 struct k_work_sync *sync);
3771
3791int k_work_cancel(struct k_work *work);
3792
3823bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);
3824
3835
3856 k_thread_stack_t *stack, size_t stack_size,
3857 int prio, const struct k_work_queue_config *cfg);
3858
3869void k_work_queue_run(struct k_work_q *queue, const struct k_work_queue_config *cfg);
3870
3880static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);
3881
3905int k_work_queue_drain(struct k_work_q *queue, bool plug);
3906
3921
3937
3953
3965static inline struct k_work_delayable *
3967
3982
3997static inline bool k_work_delayable_is_pending(
3998 const struct k_work_delayable *dwork);
3999
4014 const struct k_work_delayable *dwork);
4015
4030 const struct k_work_delayable *dwork);
4031
4060 struct k_work_delayable *dwork,
4061 k_timeout_t delay);
4062
4077 k_timeout_t delay);
4078
4115 struct k_work_delayable *dwork,
4116 k_timeout_t delay);
4117
4131 k_timeout_t delay);
4132
4158 struct k_work_sync *sync);
4159
4181
4211 struct k_work_sync *sync);
4212
4213enum {
4217
4218 /* The atomic API is used for all work and queue flags fields to
4219 * enforce sequential consistency in SMP environments.
4220 */
4221
4222 /* Bits that represent the work item states. At least nine of the
4223 * combinations are distinct valid stable states.
4224 */
4225 K_WORK_RUNNING_BIT = 0,
4226 K_WORK_CANCELING_BIT = 1,
4227 K_WORK_QUEUED_BIT = 2,
4228 K_WORK_DELAYED_BIT = 3,
4229 K_WORK_FLUSHING_BIT = 4,
4230
4231 K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
4232 | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
4233
4234 /* Static work flags */
4235 K_WORK_DELAYABLE_BIT = 8,
4236 K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
4237
4238 /* Dynamic work queue flags */
4239 K_WORK_QUEUE_STARTED_BIT = 0,
4240 K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
4241 K_WORK_QUEUE_BUSY_BIT = 1,
4242 K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
4243 K_WORK_QUEUE_DRAIN_BIT = 2,
4244 K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
4245 K_WORK_QUEUE_PLUGGED_BIT = 3,
4246 K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
4247 K_WORK_QUEUE_STOP_BIT = 4,
4248 K_WORK_QUEUE_STOP = BIT(K_WORK_QUEUE_STOP_BIT),
4249
4250 /* Static work queue flags */
4251 K_WORK_QUEUE_NO_YIELD_BIT = 8,
4252 K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
4253
4257 /* Transient work flags */
4258
4264 K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),
4265
4270 K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),
4271
4277 K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),
4278
4284 K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),
4285
4290 K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
4291};
4292
4294struct k_work {
4295 /* All fields are protected by the work module spinlock. No fields
4296 * are to be accessed except through kernel API.
4297 */
4298
4299 /* Node to link into k_work_q pending list. */
4301
4302 /* The function to be invoked by the work queue thread. */
4304
4305 /* The queue on which the work item was last submitted. */
4307
4308 /* State of the work item.
4309 *
4310 * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
4311 *
4312 * It can be RUNNING and CANCELING simultaneously.
4313 */
4315};
4316
4317#define Z_WORK_INITIALIZER(work_handler) { \
4318 .handler = (work_handler), \
4319}
4320
4323 /* The work item. */
4324 struct k_work work;
4325
4326 /* Timeout used to submit work after a delay. */
4327 struct _timeout timeout;
4328
4329 /* The queue to which the work should be submitted. */
4331};
4332
4333#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
4334 .work = { \
4335 .handler = (work_handler), \
4336 .flags = K_WORK_DELAYABLE, \
4337 }, \
4338}
4339
4356#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
4357 struct k_work_delayable work \
4358 = Z_WORK_DELAYABLE_INITIALIZER(work_handler)
4359
4363
4364/* Record used to wait for work to flush.
4365 *
4366 * The work item is inserted into the queue that will process (or is
4367 * processing) the item, and will be processed as soon as the item
4368 * completes. When the flusher is processed the semaphore will be
4369 * signaled, releasing the thread waiting for the flush.
4370 */
4371struct z_work_flusher {
4372 struct k_work work;
4373 struct k_sem sem;
4374};
4375
4376/* Record used to wait for work to complete a cancellation.
4377 *
4378 * The work item is inserted into a global queue of pending cancels.
4379 * When a cancelling work item goes idle any matching waiters are
4380 * removed from pending_cancels and are woken.
4381 */
4382struct z_work_canceller {
4383 sys_snode_t node;
4384 struct k_work *work;
4385 struct k_sem sem;
4386};
4387
4391
4406 union {
4407 struct z_work_flusher flusher;
4408 struct z_work_canceller canceller;
4409 };
4410};
4411
4423 const char *name;
4424
4438
4443
4453};
4454
4456struct k_work_q {
4457 /* The thread that animates the work. */
4459
4460 /* The thread ID that animates the work. This may be an external thread
4461 * if k_work_queue_run() is used.
4462 */
4464
4465 /* All the following fields must be accessed only while the
4466 * work module spinlock is held.
4467 */
4468
4469 /* List of k_work items to be worked. */
4471
4472 /* Wait queue for idle work thread. */
4473 _wait_q_t notifyq;
4474
4475 /* Wait queue for threads waiting for the queue to drain. */
4476 _wait_q_t drainq;
4477
4478 /* Flags describing queue state. */
4480
4481#if defined(CONFIG_WORKQUEUE_WORK_TIMEOUT)
4482 struct _timeout work_timeout_record;
4483 struct k_work *work;
4484 k_timeout_t work_timeout;
4485#endif /* defined(CONFIG_WORKQUEUE_WORK_TIMEOUT) */
4486};
4487
4488/* Provide the implementation for inline functions declared above */
4489
4490static inline bool k_work_is_pending(const struct k_work *work)
4491{
4492 return k_work_busy_get(work) != 0;
4493}
4494
4495static inline struct k_work_delayable *
4500
4502 const struct k_work_delayable *dwork)
4503{
4504 return k_work_delayable_busy_get(dwork) != 0;
4505}
4506
4508 const struct k_work_delayable *dwork)
4509{
4510 return z_timeout_expires(&dwork->timeout);
4511}
4512
4514 const struct k_work_delayable *dwork)
4515{
4516 return z_timeout_remaining(&dwork->timeout);
4517}
4518
4520{
4521 return queue->thread_id;
4522}
4523
4525
4526struct k_work_user;
4527
4532
4542typedef void (*k_work_user_handler_t)(struct k_work_user *work);
4543
4547
4548struct k_work_user_q {
4549 struct k_queue queue;
4550 struct k_thread thread;
4551};
4552
4553enum {
4554 K_WORK_USER_STATE_PENDING, /* Work item pending state */
4555};
4556
4557struct k_work_user {
4558 void *_reserved; /* Used by k_queue implementation. */
4559 k_work_user_handler_t handler;
4561};
4562
4566
4567#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
4568#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
4569#else
4570#define Z_WORK_USER_INITIALIZER(work_handler) \
4571 { \
4572 ._reserved = NULL, \
4573 .handler = (work_handler), \
4574 .flags = 0 \
4575 }
4576#endif
4577
4589#define K_WORK_USER_DEFINE(work, work_handler) \
4590 struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)
4591
4601static inline void k_work_user_init(struct k_work_user *work,
4602 k_work_user_handler_t handler)
4603{
4604 *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
4605}
4606
4623static inline bool k_work_user_is_pending(struct k_work_user *work)
4624{
4625 return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
4626}
4627
4646static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
4647 struct k_work_user *work)
4648{
4649 int ret = -EBUSY;
4650
4651 if (!atomic_test_and_set_bit(&work->flags,
4652 K_WORK_USER_STATE_PENDING)) {
4653 ret = k_queue_alloc_append(&work_q->queue, work);
4654
4655 /* Couldn't insert into the queue. Clear the pending bit
4656 * so the work item can be submitted again
4657 */
4658 if (ret != 0) {
4659 atomic_clear_bit(&work->flags,
4660 K_WORK_USER_STATE_PENDING);
4661 }
4662 }
4663
4664 return ret;
4665}
4666
4686void k_work_user_queue_start(struct k_work_user_q *work_q,
4687 k_thread_stack_t *stack,
4688 size_t stack_size, int prio,
4689 const char *name);
4690
4701static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
4702{
4703 return &work_q->thread;
4704}
4705
4707
4711
4712struct k_work_poll {
4713 struct k_work work;
4714 struct k_work_q *workq;
4715 struct z_poller poller;
4716 struct k_poll_event *events;
4717 int num_events;
4718 k_work_handler_t real_handler;
4719 struct _timeout timeout;
4720 int poll_result;
4721};
4722
4726
4731
4743#define K_WORK_DEFINE(work, work_handler) \
4744 struct k_work work = Z_WORK_INITIALIZER(work_handler)
4745
4755void k_work_poll_init(struct k_work_poll *work,
4756 k_work_handler_t handler);
4757
4793 struct k_work_poll *work,
4794 struct k_poll_event *events,
4795 int num_events,
4796 k_timeout_t timeout);
4797
4829int k_work_poll_submit(struct k_work_poll *work,
4830 struct k_poll_event *events,
4831 int num_events,
4832 k_timeout_t timeout);
4833
4848int k_work_poll_cancel(struct k_work_poll *work);
4849
4851
4857
4861struct k_msgq {
4863 _wait_q_t wait_q;
4867 size_t msg_size;
4880
4881 Z_DECL_POLL_EVENT
4882
4885
4887
4888#ifdef CONFIG_OBJ_CORE_MSGQ
4889 struct k_obj_core obj_core;
4890#endif
4891};
4892
4895
4896
4897#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
4898 { \
4899 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
4900 .lock = {}, \
4901 .msg_size = q_msg_size, \
4902 .max_msgs = q_max_msgs, \
4903 .buffer_start = q_buffer, \
4904 .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
4905 .read_ptr = q_buffer, \
4906 .write_ptr = q_buffer, \
4907 .used_msgs = 0, \
4908 Z_POLL_EVENT_OBJ_INIT(obj) \
4909 .flags = 0, \
4910 }
4911
4915
4916
4917#define K_MSGQ_FLAG_ALLOC BIT(0)
4918
4930
4931
4950#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align) \
4951 static char __noinit __aligned(q_align) \
4952 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
4953 STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
4954 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
4955 (q_msg_size), (q_max_msgs))
4956
4971void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
4972 uint32_t max_msgs);
4973
4993__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
4994 uint32_t max_msgs);
4995
5006int k_msgq_cleanup(struct k_msgq *msgq);
5007
5028__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);
5029
5054__syscall int k_msgq_put_front(struct k_msgq *msgq, const void *data);
5055
5076__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);
5077
5092__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);
5093
5110__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);
5111
5121__syscall void k_msgq_purge(struct k_msgq *msgq);
5122
5133__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);
5134
5143__syscall void k_msgq_get_attrs(struct k_msgq *msgq,
5144 struct k_msgq_attrs *attrs);
5145
5146
5147static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
5148{
5149 return msgq->max_msgs - msgq->used_msgs;
5150}
5151
5161__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
5162
5163static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
5164{
5165 return msgq->used_msgs;
5166}
5167
5169
5175
5182 size_t size;
5186 void *tx_data;
5192 k_tid_t _syncing_thread;
5193#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
5195 struct k_sem *_async_sem;
5196#endif
5197};
5198
5202struct k_mbox {
5204 _wait_q_t tx_msg_queue;
5206 _wait_q_t rx_msg_queue;
5208
5210
5211#ifdef CONFIG_OBJ_CORE_MAILBOX
5212 struct k_obj_core obj_core;
5213#endif
5214};
5215
5218
5219#define Z_MBOX_INITIALIZER(obj) \
5220 { \
5221 .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
5222 .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
5223 }
5224
5228
5238#define K_MBOX_DEFINE(name) \
5239 STRUCT_SECTION_ITERABLE(k_mbox, name) = \
5240 Z_MBOX_INITIALIZER(name) \
5241
5242
5249void k_mbox_init(struct k_mbox *mbox);
5250
5270int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
5271 k_timeout_t timeout);
5272
5286void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
5287 struct k_sem *sem);
5288
5306int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
5307 void *buffer, k_timeout_t timeout);
5308
5322void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);
5323
5325
5331
5341__syscall void k_pipe_init(struct k_pipe *pipe, uint8_t *buffer, size_t buffer_size);
5342
5347
5348struct k_pipe {
5349 size_t waiting;
5352 _wait_q_t data;
5353 _wait_q_t space;
5355
5356 Z_DECL_POLL_EVENT
5357#ifdef CONFIG_OBJ_CORE_PIPE
5358 struct k_obj_core obj_core;
5359#endif
5361};
5362
5366#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size) \
5367{ \
5368 .waiting = 0, \
5369 .buf = RING_BUF_INIT(pipe_buffer, pipe_buffer_size), \
5370 .data = Z_WAIT_Q_INIT(&obj.data), \
5371 .space = Z_WAIT_Q_INIT(&obj.space), \
5372 .flags = PIPE_FLAG_OPEN, \
5373 Z_POLL_EVENT_OBJ_INIT(obj) \
5374}
5378
5392#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align) \
5393 static unsigned char __noinit __aligned(pipe_align) \
5394 _k_pipe_buf_##name[pipe_buffer_size]; \
5395 STRUCT_SECTION_ITERABLE(k_pipe, name) = \
5396 Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
5397
5398
5415__syscall int k_pipe_write(struct k_pipe *pipe, const uint8_t *data, size_t len,
5416 k_timeout_t timeout);
5417
5433__syscall int k_pipe_read(struct k_pipe *pipe, uint8_t *data, size_t len,
5434 k_timeout_t timeout);
5435
5445__syscall void k_pipe_reset(struct k_pipe *pipe);
5446
5455__syscall void k_pipe_close(struct k_pipe *pipe);
5457
5461struct k_mem_slab_info {
5462 uint32_t num_blocks;
5463 size_t block_size;
5464 uint32_t num_used;
5465#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5466 uint32_t max_used;
5467#endif
5468};
5469
5470struct k_mem_slab {
5471 _wait_q_t wait_q;
5472 struct k_spinlock lock;
5473 char *buffer;
5474 char *free_list;
5475 struct k_mem_slab_info info;
5476
5478
5479#ifdef CONFIG_OBJ_CORE_MEM_SLAB
5480 struct k_obj_core obj_core;
5481#endif
5482};
5483
5484#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
5485 _slab_num_blocks) \
5486 { \
5487 .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q), \
5488 .lock = {}, \
5489 .buffer = _slab_buffer, \
5490 .free_list = NULL, \
5491 .info = {_slab_num_blocks, _slab_block_size, 0} \
5492 }
5493
5494
5498
5504
5530#define K_MEM_SLAB_DEFINE_IN_SECT(name, in_section, slab_block_size, slab_num_blocks, slab_align) \
5531 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
5532 "slab_block_size must be a multiple of slab_align"); \
5533 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
5534 "slab_align must be a power of 2"); \
5535 char in_section __aligned(WB_UP( \
5536 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5537 STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
5538 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
5539
5563#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align) \
5564 K_MEM_SLAB_DEFINE_IN_SECT(name, __noinit_named(k_mem_slab_buf_##name), slab_block_size, \
5565 slab_num_blocks, slab_align)
5566
5583#define K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, in_section, slab_block_size, slab_num_blocks, \
5584 slab_align) \
5585 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
5586 "slab_block_size must be a multiple of slab_align"); \
5587 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
5588 "slab_align must be a power of 2"); \
5589 static char in_section __aligned(WB_UP( \
5590 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5591 static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
5592 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
5593
5608#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align) \
5609 K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, __noinit_named(k_mem_slab_buf_##name), \
5610 slab_block_size, slab_num_blocks, slab_align)
5611
5633int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
5634 size_t block_size, uint32_t num_blocks);
5635
5658int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
5659 k_timeout_t timeout);
5660
5670void k_mem_slab_free(struct k_mem_slab *slab, void *mem);
5671
5682static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
5683{
5684 return slab->info.num_used;
5685}
5686
5697static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
5698{
5699#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5700 return slab->info.max_used;
5701#else
5702 ARG_UNUSED(slab);
5703 return 0;
5704#endif
5705}
5706
5717static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
5718{
5719 return slab->info.num_blocks - slab->info.num_used;
5720}
5721
5733
5734int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);
5735
5747int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);
5748
5750
5755
5756/* kernel synchronized heap struct */
5757
5758struct k_heap {
5760 _wait_q_t wait_q;
5762};
5763
5777void k_heap_init(struct k_heap *h, void *mem,
5778 size_t bytes) __attribute_nonnull(1);
5779
5800void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
5801 k_timeout_t timeout) __attribute_nonnull(1);
5802
5824void *k_heap_alloc(struct k_heap *h, size_t bytes,
5825 k_timeout_t timeout) __attribute_nonnull(1);
5826
5849void *k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
5850 __attribute_nonnull(1);
5851
5875void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
5876 __attribute_nonnull(1);
5877
5888void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
5889
5890/* Hand-calculated minimum heap sizes needed to return a successful
5891 * 1-byte allocation. See details in lib/os/heap.[ch]
5892 */
5893#define Z_HEAP_MIN_SIZE ((sizeof(void *) > 4) ? 56 : 44)
5894
5911#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section) \
5912 char in_section \
5913 __aligned(8) /* CHUNK_UNIT */ \
5914 kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)]; \
5915 STRUCT_SECTION_ITERABLE(k_heap, name) = { \
5916 .heap = { \
5917 .init_mem = kheap_##name, \
5918 .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
5919 }, \
5920 }
5921
5936#define K_HEAP_DEFINE(name, bytes) \
5937 Z_HEAP_DEFINE_IN_SECT(name, bytes, \
5938 __noinit_named(kheap_buf_##name))
5939
5954#define K_HEAP_DEFINE_NOCACHE(name, bytes) \
5955 Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)
5956
5966int k_heap_array_get(struct k_heap **heap);
5967
5971
5978
5997void *k_aligned_alloc(size_t align, size_t size);
5998
6010void *k_malloc(size_t size);
6011
6022void k_free(void *ptr);
6023
6035void *k_calloc(size_t nmemb, size_t size);
6036
6054void *k_realloc(void *ptr, size_t size);
6055
6057
6058/* polling API - PRIVATE */
6059
6060#ifdef CONFIG_POLL
6061#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
6062#else
6063#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
6064#endif
6065
6066/* private - types bit positions */
6067enum _poll_types_bits {
6068 /* can be used to ignore an event */
6069 _POLL_TYPE_IGNORE,
6070
6071 /* to be signaled by k_poll_signal_raise() */
6072 _POLL_TYPE_SIGNAL,
6073
6074 /* semaphore availability */
6075 _POLL_TYPE_SEM_AVAILABLE,
6076
6077 /* queue/FIFO/LIFO data availability */
6078 _POLL_TYPE_DATA_AVAILABLE,
6079
6080 /* msgq data availability */
6081 _POLL_TYPE_MSGQ_DATA_AVAILABLE,
6082
6083 /* pipe data availability */
6084 _POLL_TYPE_PIPE_DATA_AVAILABLE,
6085
6086 _POLL_NUM_TYPES
6087};
6088
6089#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
6090
6091/* private - states bit positions */
6092enum _poll_states_bits {
6093 /* default state when creating event */
6094 _POLL_STATE_NOT_READY,
6095
6096 /* signaled by k_poll_signal_raise() */
6097 _POLL_STATE_SIGNALED,
6098
6099 /* semaphore is available */
6100 _POLL_STATE_SEM_AVAILABLE,
6101
6102 /* data is available to read on queue/FIFO/LIFO */
6103 _POLL_STATE_DATA_AVAILABLE,
6104
6105 /* queue/FIFO/LIFO wait was cancelled */
6106 _POLL_STATE_CANCELLED,
6107
6108 /* data is available to read on a message queue */
6109 _POLL_STATE_MSGQ_DATA_AVAILABLE,
6110
6111 /* data is available to read from a pipe */
6112 _POLL_STATE_PIPE_DATA_AVAILABLE,
6113
6114 _POLL_NUM_STATES
6115};
6116
6117#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
6118
6119#define _POLL_EVENT_NUM_UNUSED_BITS \
6120 (32 - (0 \
6121 + 8 /* tag */ \
6122 + _POLL_NUM_TYPES \
6123 + _POLL_NUM_STATES \
6124 + 1 /* modes */ \
6125 ))
6126
6127/* end of polling API - PRIVATE */
6128
6129
6137
6138/* Public polling API */
6139
6140/* public - values for k_poll_event.type bitfield */
6141#define K_POLL_TYPE_IGNORE 0
6142#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
6143#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
6144#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
6145#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
6146#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
6147#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
6148
6149/* public - polling modes */
6151 /* polling thread does not take ownership of objects when available */
6153
6155};
6156
6157/* public - values for k_poll_event.state bitfield */
6158#define K_POLL_STATE_NOT_READY 0
6159#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
6160#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
6161#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
6162#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
6163#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
6164#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
6165#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
6166
6167/* public - poll signal object */
6171
6176 unsigned int signaled;
6177
6180};
6181
6182#define K_POLL_SIGNAL_INITIALIZER(obj) \
6183 { \
6184 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
6185 .signaled = 0, \
6186 .result = 0, \
6187 }
6188
6194 sys_dnode_t _node;
6195
6197 struct z_poller *poller;
6198
6201
6203 uint32_t type:_POLL_NUM_TYPES;
6204
6206 uint32_t state:_POLL_NUM_STATES;
6207
6210
6212 uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
6213
6215 union {
6216 /* The typed_* fields below are used by K_POLL_EVENT_*INITIALIZER() macros to ensure
6217 * type safety of polled objects.
6218 */
6226 };
6227};
6228
6229#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
6230 { \
6231 .poller = NULL, \
6232 .type = _event_type, \
6233 .state = K_POLL_STATE_NOT_READY, \
6234 .mode = _event_mode, \
6235 .unused = 0, \
6236 { \
6237 .typed_##_event_type = _event_obj, \
6238 }, \
6239 }
6240
6241#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
6242 event_tag) \
6243 { \
6244 .tag = event_tag, \
6245 .type = _event_type, \
6246 .state = K_POLL_STATE_NOT_READY, \
6247 .mode = _event_mode, \
6248 .unused = 0, \
6249 { \
6250 .typed_##_event_type = _event_obj, \
6251 }, \
6252 }
6253
6268
6269void k_poll_event_init(struct k_poll_event *event, uint32_t type,
6270 int mode, void *obj);
6271
6314
6315__syscall int k_poll(struct k_poll_event *events, int num_events,
6316 k_timeout_t timeout);
6317
6325
6326__syscall void k_poll_signal_init(struct k_poll_signal *sig);
6327
6333__syscall void k_poll_signal_reset(struct k_poll_signal *sig);
6334
6345__syscall void k_poll_signal_check(struct k_poll_signal *sig,
6346 unsigned int *signaled, int *result);
6347
6371
6372__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);
6373
6375
6394static inline void k_cpu_idle(void)
6395{
6396 arch_cpu_idle();
6397}
6398
6413static inline void k_cpu_atomic_idle(unsigned int key)
6414{
6416}
6417
6421
6426#ifdef ARCH_EXCEPT
6427/* This architecture has direct support for triggering a CPU exception */
6428#define z_except_reason(reason) ARCH_EXCEPT(reason)
6429#else
6430
6431#if !defined(CONFIG_ASSERT_NO_FILE_INFO)
6432#define __EXCEPT_LOC() __ASSERT_PRINT("@ %s:%d\n", __FILE__, __LINE__)
6433#else
6434#define __EXCEPT_LOC()
6435#endif
6436
6437/* NOTE: This is the implementation for arches that do not implement
6438 * ARCH_EXCEPT() to generate a real CPU exception.
6439 *
6440 * We won't have a real exception frame to determine the PC value when
6441 * the oops occurred, so print file and line number before we jump into
6442 * the fatal error handler.
6443 */
6444#define z_except_reason(reason) do { \
6445 __EXCEPT_LOC(); \
6446 z_fatal_error(reason, NULL); \
6447 } while (false)
6448
6449#endif /* _ARCH__EXCEPT */
6453
6465#define k_oops() z_except_reason(K_ERR_KERNEL_OOPS)
6466
6475#define k_panic() z_except_reason(K_ERR_KERNEL_PANIC)
6476
6480
6481/*
6482 * private APIs that are utilized by one or more public APIs
6483 */
6484
6488void z_timer_expiration_handler(struct _timeout *timeout);
6492
6493#ifdef CONFIG_PRINTK
6501__syscall void k_str_out(char *c, size_t n);
6502#endif
6503
6509
6530__syscall int k_float_disable(struct k_thread *thread);
6531
6570__syscall int k_float_enable(struct k_thread *thread, unsigned int options);
6571
6575
6585
6593
6602
6613
6624
6633
6642
6643#ifdef __cplusplus
6644}
6645#endif
6646
6647#include <zephyr/tracing/tracing.h>
6648#include <zephyr/syscalls/kernel.h>
6649
6650#endif /* !_ASMLANGUAGE */
6651
6652#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:2013
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1414
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:1965
uint32_t k_ticks_t
Tick precision used in timeout APIs.
Definition clock.h:48
static int64_t k_uptime_delta(int64_t *reftime)
Get elapsed time.
Definition kernel.h:1994
static uint32_t k_uptime_seconds(void)
Get system uptime in seconds.
Definition kernel.h:1978
static uint64_t k_cycle_get_64(void)
Read the 64-bit hardware clock.
Definition kernel.h:2028
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:1941
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:6394
static void k_cpu_atomic_idle(unsigned int key)
Make the CPU idle in an atomic fashion.
Definition kernel.h:6413
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
static void sys_dnode_init(sys_dnode_t *node)
initialize node to its state when not in a list
Definition dlist.h:219
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.
uint32_t k_event_wait_all_safe(struct k_event *event, uint32_t events, bool reset, k_timeout_t timeout)
Wait for all of the specified events (safe version)
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:2644
uint32_t k_event_wait_safe(struct k_event *event, uint32_t events, bool reset, k_timeout_t timeout)
Wait for any of the specified events (safe version)
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.
static bool sys_sflist_is_empty(const sys_sflist_t *list)
Test if the given list is empty.
Definition sflist.h:336
struct _sflist sys_sflist_t
Flagged single-linked list structure.
Definition sflist.h:54
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.
int k_heap_array_get(struct k_heap **heap)
Get the array of statically defined heaps.
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:1269
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:5682
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:5697
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:5717
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 the end of 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_put_front(struct k_msgq *msgq, const void *data)
Send a message to the front of 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.
int k_pipe_write(struct k_pipe *pipe, const uint8_t *data, size_t len, k_timeout_t timeout)
Write data to a pipe.
void k_pipe_close(struct k_pipe *pipe)
Close a pipe.
void k_pipe_reset(struct k_pipe *pipe)
Reset a pipe This routine resets the pipe, discarding any unread data and unblocking any threads wait...
void k_pipe_init(struct k_pipe *pipe, uint8_t *buffer, size_t buffer_size)
initialize a pipe
pipe_flags
Definition kernel.h:5343
int k_pipe_read(struct k_pipe *pipe, uint8_t *data, size_t len, k_timeout_t timeout)
Read data from a pipe This routine reads up to len bytes of data from pipe.
@ PIPE_FLAG_RESET
Definition kernel.h:5345
@ PIPE_FLAG_OPEN
Definition kernel.h:5344
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:6150
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:6152
@ K_POLL_NUM_MODES
Definition kernel.h:6154
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:285
#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.
void k_thread_absolute_deadline_set(k_tid_t thread, int deadline)
Set deadline expiration time for scheduler.
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:485
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:579
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:676
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:1146
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:106
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:1716
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:1700
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:1865
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:1707
#define k_ticks_to_sec_floor32(t)
Convert ticks to seconds.
Definition time_units.h:1611
#define k_ticks_to_ms_floor64(t)
Convert ticks to milliseconds.
Definition time_units.h:1723
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:4519
static bool k_work_is_pending(const struct k_work *work)
Test whether a work item is currently pending.
Definition kernel.h:4490
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:4507
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:4646
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:4623
void(* k_work_handler_t)(struct k_work *work)
The signature for a work item handler function.
Definition kernel.h:3663
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:4501
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:4601
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:4542
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:4701
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:4496
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:4513
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.
void k_work_queue_run(struct k_work_q *queue, const struct k_work_queue_config *cfg)
Run work queue using calling thread.
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:4270
@ K_WORK_QUEUED
Flag indicating a work item that has been submitted to a queue but has not started running.
Definition kernel.h:4277
@ K_WORK_DELAYED
Flag indicating a delayed work item that is scheduled for submission to a queue.
Definition kernel.h:4284
@ K_WORK_RUNNING
Flag indicating a work item that is running under a work queue thread.
Definition kernel.h:4264
@ K_WORK_FLUSHING
Flag indicating a synced work item that is being flushed.
Definition kernel.h:4290
#define BUILD_ASSERT(EXPR, MSG...)
Definition llvm.h:51
struct k_thread * k_tid_t
Definition thread.h:366
struct k_thread_runtime_stats k_thread_runtime_stats_t
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.
int k_ipi_work_add(struct k_ipi_work *work, uint32_t cpu_bitmask, k_ipi_func_t func)
Add an IPI work item to the IPI work queue.
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.
void k_ipi_work_signal(void)
Signal that there is one or more IPI work items to process.
int k_ipi_work_wait(struct k_ipi_work *work, k_timeout_t timeout)
Wait until the IPI work item has been processed by all targeted CPUs.
execution_context_types
Definition kernel.h:91
@ K_ISR
Definition kernel.h:92
@ K_COOP_THREAD
Definition kernel.h:93
@ K_PREEMPT_THREAD
Definition kernel.h:94
void(* k_ipi_func_t)(struct k_ipi_work *work)
Definition kernel.h:3547
int k_thread_runtime_stats_all_get(k_thread_runtime_stats_t *stats)
Get the runtime statistics of all threads.
static void k_ipi_work_init(struct k_ipi_work *work)
Initialize the specified IPI work item.
Definition kernel.h:3574
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:314
Memory Statistics.
flags
Definition parser.h:97
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
Definition kernel.h:3306
_wait_q_t wait_q
Definition kernel.h:3307
Event Structure.
Definition kernel.h:2421
Definition kernel.h:2664
futex structure
Definition kernel.h:2335
atomic_t val
Definition kernel.h:2336
Definition kernel.h:5758
struct k_spinlock lock
Definition kernel.h:5761
struct sys_heap heap
Definition kernel.h:5759
_wait_q_t wait_q
Definition kernel.h:5760
IPI work item structure.
Definition kernel.h:3555
Definition kernel.h:2905
Mailbox Message Structure.
Definition kernel.h:5180
k_tid_t tx_target_thread
target thread id
Definition kernel.h:5190
void * tx_data
sender's message data buffer
Definition kernel.h:5186
k_tid_t rx_source_thread
source thread id
Definition kernel.h:5188
uint32_t info
application-defined information value
Definition kernel.h:5184
size_t size
size of message (in bytes)
Definition kernel.h:5182
Mailbox Structure.
Definition kernel.h:5202
_wait_q_t tx_msg_queue
Transmit messages queue.
Definition kernel.h:5204
struct k_spinlock lock
Definition kernel.h:5207
_wait_q_t rx_msg_queue
Receive message queue.
Definition kernel.h:5206
Memory Domain.
Definition mem_domain.h:80
Memory Partition.
Definition mem_domain.h:55
Message Queue Attributes.
Definition kernel.h:4922
uint32_t used_msgs
Used messages.
Definition kernel.h:4928
size_t msg_size
Message Size.
Definition kernel.h:4924
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4926
Message Queue Structure.
Definition kernel.h:4861
size_t msg_size
Message size.
Definition kernel.h:4867
char * read_ptr
Read pointer.
Definition kernel.h:4875
uint32_t used_msgs
Number of used messages.
Definition kernel.h:4879
char * buffer_end
End of message buffer.
Definition kernel.h:4873
struct k_spinlock lock
Lock.
Definition kernel.h:4865
char * write_ptr
Write pointer.
Definition kernel.h:4877
char * buffer_start
Start of message buffer.
Definition kernel.h:4871
uint8_t flags
Message queue.
Definition kernel.h:4884
_wait_q_t wait_q
Message queue wait queue.
Definition kernel.h:4863
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4869
Mutex Structure.
Definition kernel.h:3194
uint32_t lock_count
Current lock count.
Definition kernel.h:3201
_wait_q_t wait_q
Mutex wait queue.
Definition kernel.h:3196
int owner_orig_prio
Original thread priority.
Definition kernel.h:3204
struct k_thread * owner
Mutex owner.
Definition kernel.h:3198
Object core structure.
Definition obj_core.h:121
Definition kernel.h:5348
uint8_t flags
Definition kernel.h:5354
struct ring_buf buf
Definition kernel.h:5350
_wait_q_t data
Definition kernel.h:5352
_wait_q_t space
Definition kernel.h:5353
struct k_spinlock lock
Definition kernel.h:5351
size_t waiting
Definition kernel.h:5349
Poll Event.
Definition kernel.h:6192
struct k_msgq * typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE
Definition kernel.h:6224
void * typed_K_POLL_TYPE_IGNORE
Definition kernel.h:6219
struct k_poll_signal * signal
Definition kernel.h:6220
struct k_pipe * pipe
Definition kernel.h:6225
uint32_t tag
optional user-specified tag, opaque, untouched by the API
Definition kernel.h:6200
struct k_fifo * fifo
Definition kernel.h:6222
struct k_msgq * msgq
Definition kernel.h:6224
struct k_queue * queue
Definition kernel.h:6223
uint32_t unused
unused bits in 32-bit word
Definition kernel.h:6212
struct k_pipe * typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE
Definition kernel.h:6225
uint32_t type
bitfield of event types (bitwise-ORed K_POLL_TYPE_xxx values)
Definition kernel.h:6203
struct k_sem * sem
Definition kernel.h:6221
struct k_queue * typed_K_POLL_TYPE_DATA_AVAILABLE
Definition kernel.h:6223
struct k_sem * typed_K_POLL_TYPE_SEM_AVAILABLE
Definition kernel.h:6221
uint32_t state
bitfield of event states (bitwise-ORed K_POLL_STATE_xxx values)
Definition kernel.h:6206
uint32_t mode
mode of operation, from enum k_poll_modes
Definition kernel.h:6209
struct z_poller * poller
PRIVATE - DO NOT TOUCH.
Definition kernel.h:6197
struct k_poll_signal * typed_K_POLL_TYPE_SIGNAL
Definition kernel.h:6220
void * obj
Definition kernel.h:6219
struct k_fifo * typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE
Definition kernel.h:6222
Definition kernel.h:6168
sys_dlist_t poll_events
PRIVATE - DO NOT TOUCH.
Definition kernel.h:6170
int result
custom result value passed to k_poll_signal_raise() if needed
Definition kernel.h:6179
unsigned int signaled
1 if the event has been signaled, 0 otherwise.
Definition kernel.h:6176
Definition kernel.h:2043
struct k_spinlock lock
Definition kernel.h:2045
_wait_q_t wait_q
Definition kernel.h:2046
sys_sflist_t data_q
Definition kernel.h:2044
Semaphore structure.
Definition kernel.h:3399
Kernel Spin Lock.
Definition spinlock.h:45
Thread Structure.
Definition thread.h:250
struct _thread_base base
Definition thread.h:252
struct k_heap * resource_pool
resource pool
Definition thread.h:340
struct __thread_entry entry
thread entry and parameters description
Definition thread.h:279
Kernel timeout type.
Definition clock.h:65
Kernel timer structure.
Definition kernel.h:1622
A structure used to submit work after a delay.
Definition kernel.h:4322
struct _timeout timeout
Definition kernel.h:4327
struct k_work_q * queue
Definition kernel.h:4330
struct k_work work
Definition kernel.h:4324
A structure used to hold work until it can be processed.
Definition kernel.h:4456
sys_slist_t pending
Definition kernel.h:4470
_wait_q_t drainq
Definition kernel.h:4476
k_tid_t thread_id
Definition kernel.h:4463
_wait_q_t notifyq
Definition kernel.h:4473
uint32_t flags
Definition kernel.h:4479
struct k_thread thread
Definition kernel.h:4458
A structure holding optional configuration items for a work queue.
Definition kernel.h:4418
const char * name
The name to be given to the work queue thread.
Definition kernel.h:4423
uint32_t work_timeout_ms
Controls whether work queue monitors work timeouts.
Definition kernel.h:4452
bool essential
Control whether the work queue thread should be marked as essential thread.
Definition kernel.h:4442
bool no_yield
Control whether the work queue thread should yield between items.
Definition kernel.h:4437
A structure holding internal state for a pending synchronous operation on a work item or queue.
Definition kernel.h:4405
struct z_work_canceller canceller
Definition kernel.h:4408
struct z_work_flusher flusher
Definition kernel.h:4407
A structure used to submit work.
Definition kernel.h:4294
k_work_handler_t handler
Definition kernel.h:4303
uint32_t flags
Definition kernel.h:4314
struct k_work_q * queue
Definition kernel.h:4306
sys_snode_t node
Definition kernel.h:4300
A structure to represent a ring buffer.
Definition ring_buffer.h:49
Definition sys_heap.h:57
Definition mem_stats.h:24
Macros to abstract toolchain specific capabilities.